Only shuffle the scoop buffer if it's necessary to make space.

Rename rs_scoop_total_avail() to rs_scoop_avail() and make it a static inline
in stream.h

Remove rs_job_input_is_ending() from job.[hc] and replace it with a
rs_scoop_eof() static inline in stream.h.

In scoop.c make rs_scoop_input() only shuffle data to the start of the buffer
if necessary to free up space. Also make an assert() check more strict about
the data being within the buffer. Slightly tidy up rs_scoop_read_rest().

In delta.c make rs_delta_s_slack() neater by using the new rs_scoop_*()
functions.

5 files changed, 20 insertions, 25 deletions

diff --git a/src/delta.c b/src/delta.c
index ed09ca7..bee6663 100644
--- a/src/delta.c
+++ b/src/delta.c
@@ -203,7 +203,7 @@ static inline void rs_getinput(rs_job_t *job)
 {
     size_t len;
 
-    len = rs_scoop_total_avail(job);
+    len = rs_scoop_avail(job);
     if (job->scoop_avail < len) {
         rs_scoop_input(job, len);
     }
@@ -354,15 +354,14 @@ static inline rs_result rs_processmiss(rs_job_t *job)
  * recreate the input. */
 static rs_result rs_delta_s_slack(rs_job_t *job)
 {
-    rs_buffers_t *const stream = job->stream;
-    size_t avail = stream->avail_in;
+    size_t avail = rs_scoop_avail(job);
 
     if (avail) {
         rs_trace("emit slack delta for " FMT_SIZE " available bytes", avail);
         rs_emit_literal_cmd(job, (int)avail);
         rs_tube_copy(job, avail);
         return RS_RUNNING;
-    } else if (rs_job_input_is_ending(job)) {
+    } else if (rs_scoop_eof(job)) {
         job->statefn = rs_delta_s_end;
         return RS_RUNNING;
     }
diff --git a/src/job.c b/src/job.c
index 84b72f4..f7fef38 100644
--- a/src/job.c
+++ b/src/job.c
@@ -135,11 +135,6 @@ const rs_stats_t *rs_job_statistics(rs_job_t *job)
     return &job->stats;
 }
 
-int rs_job_input_is_ending(rs_job_t *job)
-{
-    return job->stream->eof_in;
-}
-
 rs_result rs_job_drive(rs_job_t *job, rs_buffers_t *buf, rs_driven_cb in_cb,
                        void *in_opaque, rs_driven_cb out_cb, void *out_opaque)
 {
diff --git a/src/job.h b/src/job.h
index e5c8ba5..95782bf 100644
--- a/src/job.h
+++ b/src/job.h
@@ -111,8 +111,6 @@ struct rs_job {
 
 rs_job_t *rs_job_new(const char *, rs_result (*statefn)(rs_job_t *));
 
-int rs_job_input_is_ending(rs_job_t *job);
-
 /** Magic job tag number for checking jobs have been initialized. */
 #  define RS_JOB_TAG 20010225
 
diff --git a/src/scoop.c b/src/scoop.c
index d883693..386cea9 100644
--- a/src/scoop.c
+++ b/src/scoop.c
@@ -84,7 +84,7 @@ void rs_scoop_input(rs_job_t *job, size_t len)
         rs_trace("resized scoop buffer to " FMT_SIZE " bytes from " FMT_SIZE "",
                  newsize, job->scoop_alloc);
         job->scoop_alloc = newsize;
-    } else if (job->scoop_buf != job->scoop_next) {
+    } else if (job->scoop_buf + job->scoop_alloc < job->scoop_next + len) {
         /* Move existing data to the front of the scoop. */
         rs_trace("moving scoop " FMT_SIZE " bytes to reuse " FMT_SIZE " bytes",
                  job->scoop_avail, (size_t)(job->scoop_next - job->scoop_buf));
@@ -96,7 +96,8 @@ void rs_scoop_input(rs_job_t *job, size_t len)
     tocopy = len - job->scoop_avail;
     if (tocopy > stream->avail_in)
         tocopy = stream->avail_in;
-    assert(tocopy + job->scoop_avail <= job->scoop_alloc);
+    assert(job->scoop_next + tocopy + job->scoop_avail <=
+           job->scoop_buf + job->scoop_alloc);
 
     memcpy(job->scoop_next + job->scoop_avail, stream->next_in, tocopy);
     rs_trace("accepted " FMT_SIZE " bytes from input to scoop", tocopy);
@@ -210,20 +211,11 @@ rs_result rs_scoop_read(rs_job_t *job, size_t len, void **ptr)
  * at EOF, RS_BLOCKED if there was no data and not at EOF. */
 rs_result rs_scoop_read_rest(rs_job_t *job, size_t *len, void **ptr)
 {
-    rs_buffers_t *stream = job->stream;
-
-    *len = job->scoop_avail + stream->avail_in;
+    *len = rs_scoop_avail(job);
     if (*len)
         return rs_scoop_read(job, *len, ptr);
-    else if (stream->eof_in)
+    else if (job->stream->eof_in)
         return RS_INPUT_ENDED;
     else
         return RS_BLOCKED;
 }
-
-/** Return the total number of bytes available including the scoop and input
- * buffer. */
-size_t rs_scoop_total_avail(rs_job_t *job)
-{
-    return job->scoop_avail + job->stream->avail_in;
-}
diff --git a/src/stream.h b/src/stream.h
index be6e286..e5f6a44 100644
--- a/src/stream.h
+++ b/src/stream.h
@@ -75,6 +75,7 @@
  * nothing else can be done. */
 #ifndef STREAM_H
 #  define STREAM_H
+#  include "job.h"
 
 size_t rs_buffers_copy(rs_buffers_t *stream, size_t len);
 
@@ -88,6 +89,16 @@ void rs_scoop_advance(rs_job_t *job, size_t len);
 rs_result rs_scoop_readahead(rs_job_t *job, size_t len, void **ptr);
 rs_result rs_scoop_read(rs_job_t *job, size_t len, void **ptr);
 rs_result rs_scoop_read_rest(rs_job_t *job, size_t *len, void **ptr);
-size_t rs_scoop_total_avail(rs_job_t *job);
+
+static inline size_t rs_scoop_avail(rs_job_t *job)
+{
+    return job->scoop_avail + job->stream->avail_in;
+}
+
+/** Test if the scoop has reached eof. */
+static inline bool rs_scoop_eof(rs_job_t *job)
+{
+    return !rs_scoop_avail(job) && job->stream->eof_in;
+}
 
 #endif                          /* !STREAM_H */