Sort of garbage collection commit. :-| Many things are still

broken. API has changed a lot and it will still change a
little more here and there. The command line tool doesn't
have all the required changes to reflect the API changes, so
it's easy to get "internal error" or trigger assertions.

4 files changed, 27 insertions, 27 deletions

diff --git a/src/liblzma/subblock/Makefile.am b/src/liblzma/subblock/Makefile.am
index 8f2daf59..2577e0b4 100644
--- a/src/liblzma/subblock/Makefile.am
+++ b/src/liblzma/subblock/Makefile.am
@@ -18,13 +18,13 @@ libsubblock_la_CPPFLAGS = \
 	-I@top_srcdir@/src/liblzma/api \
 	-I@top_srcdir@/src/liblzma/common
 
-if COND_MAIN_ENCODER
+if COND_ENCODER_SUBBLOCK
 libsubblock_la_SOURCES += \
 	subblock_encoder.c \
 	subblock_encoder.h
 endif
 
-if COND_MAIN_DECODER
+if COND_DECODER_SUBBLOCK
 libsubblock_la_SOURCES += \
 	subblock_decoder.c \
 	subblock_decoder.h \
diff --git a/src/liblzma/subblock/subblock_decoder.c b/src/liblzma/subblock/subblock_decoder.c
index 39ec35c1..faf198c6 100644
--- a/src/liblzma/subblock/subblock_decoder.c
+++ b/src/liblzma/subblock/subblock_decoder.c
@@ -19,7 +19,7 @@
 
 #include "subblock_decoder.h"
 #include "subblock_decoder_helper.h"
-#include "raw_decoder.h"
+#include "filter_decoder.h"
 
 
 /// Maximum number of consecutive Subblocks with Subblock Type Padding
@@ -78,7 +78,7 @@ struct lzma_coder_s {
 	lzma_next_coder filter_flags_decoder;
 
 	/// The filter_flags_decoder stores its results here.
-	lzma_options_filter filter_flags;
+	lzma_filter filter_flags;
 
 	/// Options for the Subblock decoder helper. This is used to tell
 	/// the helper when it should return LZMA_STREAM_END to the subfilter.
@@ -239,7 +239,7 @@ decode_buffer(lzma_coder *coder, lzma_allocator *allocator,
 			// if Subfilter isn't used again, we could leave
 			// a memory-hogging filter dangling until someone
 			// frees Subblock filter itself.
-			lzma_next_coder_end(&coder->subfilter, allocator);
+			lzma_next_end(&coder->subfilter, allocator);
 
 			// Free memory used for subfilter options. This is
 			// safe, because we don't support any Subfilter that
@@ -276,7 +276,7 @@ decode_buffer(lzma_coder *coder, lzma_allocator *allocator,
 
 		coder->helper.end_was_reached = false;
 
-		lzma_options_filter filters[3] = {
+		lzma_filter filters[3] = {
 			{
 				.id = coder->filter_flags.id,
 				.options = coder->filter_flags.options,
@@ -406,7 +406,7 @@ decode_buffer(lzma_coder *coder, lzma_allocator *allocator,
 			in_limit = in_size;
 
 		if (coder->subfilter.code == NULL) {
-			const size_t copy_size = bufcpy(
+			const size_t copy_size = lzma_bufcpy(
 					in, in_pos, in_limit,
 					out, out_pos, out_size);
 
@@ -480,7 +480,7 @@ decode_buffer(lzma_coder *coder, lzma_allocator *allocator,
 			}
 
 			if (coder->subfilter.code == NULL) {
-				bufcpy(coder->repeat.buffer,
+				lzma_bufcpy(coder->repeat.buffer,
 						&coder->repeat.pos,
 						coder->repeat.size,
 						out, out_pos, out_size);
@@ -586,9 +586,9 @@ subblock_decode(lzma_coder *coder, lzma_allocator *allocator,
 static void
 subblock_decoder_end(lzma_coder *coder, lzma_allocator *allocator)
 {
-	lzma_next_coder_end(&coder->next, allocator);
-	lzma_next_coder_end(&coder->subfilter, allocator);
-	lzma_next_coder_end(&coder->filter_flags_decoder, allocator);
+	lzma_next_end(&coder->next, allocator);
+	lzma_next_end(&coder->subfilter, allocator);
+	lzma_next_end(&coder->filter_flags_decoder, allocator);
 	lzma_free(coder->filter_flags.options, allocator);
 	lzma_free(coder, allocator);
 	return;
@@ -612,7 +612,7 @@ lzma_subblock_decoder_init(lzma_next_coder *next, lzma_allocator *allocator,
 		next->coder->filter_flags_decoder = LZMA_NEXT_CODER_INIT;
 
 	} else {
-		lzma_next_coder_end(&next->coder->subfilter, allocator);
+		lzma_next_end(&next->coder->subfilter, allocator);
 		lzma_free(next->coder->filter_flags.options, allocator);
 	}
 
diff --git a/src/liblzma/subblock/subblock_decoder_helper.c b/src/liblzma/subblock/subblock_decoder_helper.c
index e8063e1e..ca8fed93 100644
--- a/src/liblzma/subblock/subblock_decoder_helper.c
+++ b/src/liblzma/subblock/subblock_decoder_helper.c
@@ -40,7 +40,7 @@ helper_decode(lzma_coder *coder,
 
 	// We can safely copy as much as possible, because we are never
 	// given more data than a single Subblock Data field.
-	bufcpy(in, in_pos, in_size, out, out_pos, out_size);
+	lzma_bufcpy(in, in_pos, in_size, out, out_pos, out_size);
 
 	// Return LZMA_STREAM_END when instructed so by the Subblock decoder.
 	return coder->options->end_was_reached ? LZMA_STREAM_END : LZMA_OK;
diff --git a/src/liblzma/subblock/subblock_encoder.c b/src/liblzma/subblock/subblock_encoder.c
index 01e8007a..e78ffca6 100644
--- a/src/liblzma/subblock/subblock_encoder.c
+++ b/src/liblzma/subblock/subblock_encoder.c
@@ -18,7 +18,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "subblock_encoder.h"
-#include "raw_encoder.h"
+#include "filter_encoder.h"
 
 
 /// Maximum number of repeats that a single Repeating Data can indicate.
@@ -398,7 +398,7 @@ subblock_buffer(lzma_coder *coder, lzma_allocator *allocator,
 			assert(coder->subfilter.subcoder.code == NULL);
 
 			// No Subfilter is enabled, just copy the data as is.
-			coder->subblock.in_pending += bufcpy(
+			coder->subblock.in_pending += lzma_bufcpy(
 					in, in_pos, in_size,
 					coder->subblock.data,
 					&coder->subblock.size,
@@ -480,7 +480,7 @@ subblock_buffer(lzma_coder *coder, lzma_allocator *allocator,
 				// otherwise the Subfilter's memory could be
 				// left allocated for long time, and would
 				// just waste memory.
-				lzma_next_coder_end(&coder->subfilter.subcoder,
+				lzma_next_end(&coder->subfilter.subcoder,
 						allocator);
 
 				// We need to flush the currently buffered
@@ -728,7 +728,7 @@ subblock_buffer(lzma_coder *coder, lzma_allocator *allocator,
 		break;
 
 	case SEQ_RLE_DATA:
-		bufcpy(coder->rle.buffer, &coder->pos, coder->rle.size,
+		lzma_bufcpy(coder->rle.buffer, &coder->pos, coder->rle.size,
 				out, out_pos, out_size);
 		if (coder->pos < coder->rle.size)
 			return LZMA_OK;
@@ -767,7 +767,7 @@ subblock_buffer(lzma_coder *coder, lzma_allocator *allocator,
 		break;
 
 	case SEQ_DATA:
-		bufcpy(coder->subblock.data, &coder->pos,
+		lzma_bufcpy(coder->subblock.data, &coder->pos,
 				coder->subblock.size, out, out_pos, out_size);
 		if (coder->pos < coder->subblock.size)
 			return LZMA_OK;
@@ -791,7 +791,7 @@ subblock_buffer(lzma_coder *coder, lzma_allocator *allocator,
 			return LZMA_HEADER_ERROR;
 
 		// Initialize a raw encoder to work as a Subfilter.
-		lzma_options_filter options[2];
+		lzma_filter options[2];
 		options[0] = coder->options->subfilter_options;
 		options[1].id = LZMA_VLI_VALUE_UNKNOWN;
 
@@ -817,8 +817,8 @@ subblock_buffer(lzma_coder *coder, lzma_allocator *allocator,
 		// Now we have a big-enough buffer. Encode the Filter Flags.
 		// Like above, this should never fail.
 		size_t dummy = 0;
-		ret = lzma_filter_flags_encode(coder->subfilter.flags,
-				&dummy, coder->subfilter.flags_size, options);
+		ret = lzma_filter_flags_encode(options, coder->subfilter.flags,
+				&dummy, coder->subfilter.flags_size);
 		assert(ret == LZMA_OK);
 		assert(dummy == coder->subfilter.flags_size);
 		if (ret != LZMA_OK || dummy != coder->subfilter.flags_size)
@@ -833,15 +833,15 @@ subblock_buffer(lzma_coder *coder, lzma_allocator *allocator,
 		coder->sequence = SEQ_SUBFILTER_FLAGS;
 
 		// It is safe to fall through because SEQ_SUBFILTER_FLAGS
-		// uses bufcpy() which doesn't write unless there is output
-		// space.
+		// uses lzma_bufcpy() which doesn't write unless there is
+		// output space.
 	}
 
 	// Fall through
 
 	case SEQ_SUBFILTER_FLAGS:
 		// Copy the Filter Flags to the output stream.
-		bufcpy(coder->subfilter.flags, &coder->pos,
+		lzma_bufcpy(coder->subfilter.flags, &coder->pos,
 				coder->subfilter.flags_size,
 				out, out_pos, out_size);
 		if (coder->pos < coder->subfilter.flags_size)
@@ -912,8 +912,8 @@ subblock_encode(lzma_coder *coder, lzma_allocator *allocator,
 static void
 subblock_encoder_end(lzma_coder *coder, lzma_allocator *allocator)
 {
-	lzma_next_coder_end(&coder->next, allocator);
-	lzma_next_coder_end(&coder->subfilter.subcoder, allocator);
+	lzma_next_end(&coder->next, allocator);
+	lzma_next_end(&coder->subfilter.subcoder, allocator);
 	lzma_free(coder->subblock.data, allocator);
 	lzma_free(coder->subfilter.flags, allocator);
 	lzma_free(coder, allocator);
@@ -938,7 +938,7 @@ lzma_subblock_encoder_init(lzma_next_coder *next, lzma_allocator *allocator,
 		next->coder->subblock.limit = 0;
 		next->coder->subfilter.subcoder = LZMA_NEXT_CODER_INIT;
 	} else {
-		lzma_next_coder_end(&next->coder->subfilter.subcoder,
+		lzma_next_end(&next->coder->subfilter.subcoder,
 				allocator);
 		lzma_free(next->coder->subfilter.flags, allocator);
 	}