Update to 7-Zip Version 21.02

CPP/7zip/Common/CWrappers.cpp

@@ -1,4 +1,4 @@
-// CWrappers.h
+// CWrappers.c
 
 #include "StdAfx.h"
 
@@ -158,27 +158,27 @@ void CSeekInStreamWrap::Init(IInStream *stream) throw()
 void CByteInBufWrap::Free() throw()
 {
   ::MidFree(Buf);
-  Buf = 0;
+  Buf = NULL;
 }
 
 bool CByteInBufWrap::Alloc(UInt32 size) throw()
 {
-  if (Buf == 0 || size != Size)
+  if (!Buf || size != Size)
   {
     Free();
     Lim = Cur = Buf = (Byte *)::MidAlloc((size_t)size);
     Size = size;
   }
-  return (Buf != 0);
+  return (Buf != NULL);
 }
 
 Byte CByteInBufWrap::ReadByteFromNewBlock() throw()
 {
-  if (Res == S_OK)
+  if (!Extra && Res == S_OK)
   {
     UInt32 avail;
-    Processed += (Cur - Buf);
     Res = Stream->Read(Buf, Size, &avail);
+    Processed += (size_t)(Cur - Buf);
     Cur = Buf;
     Lim = Buf + avail;
     if (avail != 0)
@@ -196,41 +196,88 @@ static Byte Wrap_ReadByte(const IByteIn *pp) throw()
   return p->ReadByteFromNewBlock();
 }
 
-CByteInBufWrap::CByteInBufWrap(): Buf(0)
+CByteInBufWrap::CByteInBufWrap(): 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(ILookInSeqStream *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 = 0;
+  Buf = NULL;
 }
 
 bool CByteOutBufWrap::Alloc(size_t size) throw()
 {
-  if (Buf == 0 || size != Size)
+  if (!Buf || size != Size)
   {
     Free();
     Buf = (Byte *)::MidAlloc(size);
     Size = size;
   }
-  return (Buf != 0);
+  return (Buf != NULL);
 }
 
 HRESULT CByteOutBufWrap::Flush() throw()
 {
   if (Res == S_OK)
   {
-    size_t size = (Cur - Buf);
+    const size_t size = (size_t)(Cur - Buf);
     Res = WriteStream(Stream, Buf, size);
     if (Res == S_OK)
       Processed += size;
-    Cur = Buf;
+    // else throw 11;
   }
+  Cur = Buf; // reset pointer for later Wrap_WriteByte()
   return Res;
 }
 
@@ -244,7 +291,57 @@ static void Wrap_WriteByte(const IByteOut *pp, Byte b) throw()
     p->Flush();
 }
 
-CByteOutBufWrap::CByteOutBufWrap() throw(): Buf(0)
+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(const ILookOutStream *pp, void **buf) throw()
+{
+  CLookOutWrap *p = CONTAINER_FROM_VTBL_CLS(pp, CLookOutWrap, vt);
+  *buf = p->Buf;
+  return p->Size;
+}
+
+static size_t LookOutWrap_Write(const ILookOutStream *pp, size_t size) throw()
+{
+  CLookOutWrap *p = 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;
+}
+*/