Update XZ Utils to 5.0.3 (in deps)

src/liblzma/api/lzma/base.h

 /**
  * \file        lzma/base.h
  * \brief       Data types and functions used in many places in liblzma API
  */
 
 /*
  * Author: Lasse Collin
  *
  * This file has been put into the public domain.
  * You can do whatever you want with this file.
@@ skipping 263 matching lines @@
                  * network.
                  *
                  * Only some filters support LZMA_SYNC_FLUSH. Trying to use
                  * LZMA_SYNC_FLUSH with filters that don't support it will
                  * make lzma_code() return LZMA_OPTIONS_ERROR. For example,
                  * LZMA1 doesn't support LZMA_SYNC_FLUSH but LZMA2 does.
                  *
                  * Using LZMA_SYNC_FLUSH very often can dramatically reduce
                  * the compression ratio. With some filters (for example,
                  * LZMA2), fine-tuning the compression options may help
-                 * mitigate this problem significantly.
+                 * mitigate this problem significantly (for example,
+                 * match finder with LZMA2).
                  *
                  * Decoders don't support LZMA_SYNC_FLUSH.
                  */
 
         LZMA_FULL_FLUSH = 2,
                 /**<
-                 * \brief       Make all the input available at output
+                 * \brief       Finish encoding of the current Block
                  *
-                 * Finish encoding of the current Block. All the input
-                 * data going to the current Block must have been given
-                 * to the encoder (the last bytes can still be pending in
-                 * next_in). Call lzma_code() with LZMA_FULL_FLUSH until
-                 * it returns LZMA_STREAM_END. Then continue normally with
-                 * LZMA_RUN or finish the Stream with LZMA_FINISH.
+                 * All the input data going to the current Block must have
+                 * been given to the encoder (the last bytes can still be
+                 * pending in* next_in). Call lzma_code() with LZMA_FULL_FLUSH
+                 * until it returns LZMA_STREAM_END. Then continue normally
+                 * with LZMA_RUN or finish the Stream with LZMA_FINISH.
                  *
                  * This action is currently supported only by Stream encoder
                  * and easy encoder (which uses Stream encoder). If there is
                  * no unfinished Block, no empty Block is created.
                  */
 
         LZMA_FINISH = 3
                 /**<
                  * \brief       Finish the coding operation
                  *
-                 * Finishes the coding operation. All the input data must
-                 * have been given to the encoder (the last bytes can still
-                 * be pending in next_in). Call lzma_code() with LZMA_FINISH
-                 * until it returns LZMA_STREAM_END. Once LZMA_FINISH has
-                 * been used, the amount of input must no longer be changed
-                 * by the application.
+                 * All the input data must have been given to the encoder
+                 * (the last bytes can still be pending in next_in).
+                 * Call lzma_code() with LZMA_FINISH until it returns
+                 * LZMA_STREAM_END. Once LZMA_FINISH has been used,
+                 * the amount of input must no longer be changed by
+                 * the application.
                  *
                  * When decoding, using LZMA_FINISH is optional unless the
                  * LZMA_CONCATENATED flag was used when the decoder was
                  * initialized. When LZMA_CONCATENATED was not used, the only
                  * effect of LZMA_FINISH is that the amount of input must not
                  * be changed just like in the encoder.
                  */
 } lzma_action;
 
 
@@ skipping 146 matching lines @@
         lzma_internal *internal;
 
         /*
          * Reserved space to allow possible future extensions without
          * breaking the ABI. Excluding the initialization of this structure,
          * you should not touch these, because the names of these variables
          * may change.
          */
         void *reserved_ptr1;
         void *reserved_ptr2;
+        void *reserved_ptr3;
+        void *reserved_ptr4;
         uint64_t reserved_int1;
         uint64_t reserved_int2;
+        size_t reserved_int3;
+        size_t reserved_int4;
         lzma_reserved_enum reserved_enum1;
         lzma_reserved_enum reserved_enum2;
 
 } lzma_stream;
 
 
 /**
  * \brief       Initialization for lzma_stream
  *
  * When you declare an instance of lzma_stream, you can immediately
  * initialize it so that initialization functions know that no memory
  * has been allocated yet:
  *
  *     lzma_stream strm = LZMA_STREAM_INIT;
  *
  * If you need to initialize a dynamically allocated lzma_stream, you can use
  * memset(strm_pointer, 0, sizeof(lzma_stream)). Strictly speaking, this
  * violates the C standard since NULL may have different internal
  * representation than zero, but it should be portable enough in practice.
  * Anyway, for maximum portability, you can use something like this:
  *
  *     lzma_stream tmp = LZMA_STREAM_INIT;
  *     *strm = tmp;
  */
 #define LZMA_STREAM_INIT \
         { NULL, 0, 0, NULL, 0, 0, NULL, NULL, \
-        NULL, NULL, 0, 0, LZMA_RESERVED_ENUM, LZMA_RESERVED_ENUM }
+        NULL, NULL, NULL, NULL, 0, 0, 0, 0, \
+        LZMA_RESERVED_ENUM, LZMA_RESERVED_ENUM }
 
 
 /**
  * \brief       Encode or decode data
  *
  * Once the lzma_stream has been successfully initialized (e.g. with
  * lzma_stream_encoder()), the actual encoding or decoding is done
  * using this function. The application has to update strm->next_in,
  * strm->avail_in, strm->next_out, and strm->avail_out to pass input
  * to and get output from liblzma.
@@ skipping 27 matching lines @@
  * This function is currently supported only when *strm has been initialized
  * with a function that takes a memlimit argument. With other functions, you
  * should use e.g. lzma_raw_encoder_memusage() or lzma_raw_decoder_memusage()
  * to estimate the memory requirements.
  *
  * This function is useful e.g. after LZMA_MEMLIMIT_ERROR to find out how big
  * the memory usage limit should have been to decode the input. Note that
  * this may give misleading information if decoding .xz Streams that have
  * multiple Blocks, because each Block can have different memory requirements.
  *
- * \return      Rough estimate of how much memory is currently allocated
- *              for the filter decoders. If no filter chain is currently
- *              allocated, some non-zero value is still returned, which is
- *              less than or equal to what any filter chain would indicate
- *              as its memory requirement.
+ * \return      How much memory is currently allocated for the filter
+ *              decoders. If no filter chain is currently allocated,
+ *              some non-zero value is still returned, which is less than
+ *              or equal to what any filter chain would indicate as its
+ *              memory requirement.
  *
  *              If this function isn't supported by *strm or some other error
  *              occurs, zero is returned.
  */
 extern LZMA_API(uint64_t) lzma_memusage(const lzma_stream *strm)
                 lzma_nothrow lzma_attr_pure;
 
 
 /**
  * \brief       Get the current memory usage limit
@@ skipping 15 matching lines @@
  * a function that takes a memlimit argument.
  *
  * \return      - LZMA_OK: New memory usage limit successfully set.
  *              - LZMA_MEMLIMIT_ERROR: The new limit is too small.
  *                The limit was not changed.
  *              - LZMA_PROG_ERROR: Invalid arguments, e.g. *strm doesn't
  *                support memory usage limit or memlimit was zero.
  */
 extern LZMA_API(lzma_ret) lzma_memlimit_set(
                 lzma_stream *strm, uint64_t memlimit) lzma_nothrow;