From 6aa58d51be42e7d5fa7770171f656b9222026366 Mon Sep 17 00:00:00 2001
From: Jay Berkenbilt <ejb@ql.org>
Date: Sat, 26 Feb 2022 12:04:24 -0500
Subject: Rename bits.icc to bits_include.cc

---
 libqpdf/bits_include.cc | 154 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 154 insertions(+)
 create mode 100644 libqpdf/bits_include.cc

(limited to 'libqpdf/bits_include.cc')

diff --git a/libqpdf/bits_include.cc b/libqpdf/bits_include.cc
new file mode 100644
index 00000000..14c4640d
--- /dev/null
+++ b/libqpdf/bits_include.cc
@@ -0,0 +1,154 @@
+
+#ifndef __BITS_CC__
+#define __BITS_CC__
+
+#include <algorithm>
+#include <stdexcept>
+#include <qpdf/QTC.hh>
+#include <qpdf/Pipeline.hh>
+#include <qpdf/QUtil.hh>
+
+// These functions may be run at places where the function call
+// overhead from test coverage testing would be too high.  Therefore,
+// we make the test coverage cases conditional upon a preprocessor
+// symbol.  BitStream.cc includes this file without defining the
+// symbol, and the specially designed test code that fully exercises
+// this code includes with the symbol defined.
+
+#ifdef BITS_READ
+static unsigned long long
+read_bits(unsigned char const*& p, size_t& bit_offset,
+          size_t& bits_available, size_t bits_wanted)
+{
+    // View p as a stream of bits:
+
+    // 76543210 76543210 ....
+
+    // bit_offset is the bit number within the first byte that marks
+    // the first bit that we would read.
+
+    if (bits_wanted > bits_available)
+    {
+        throw std::runtime_error(
+            "overflow reading bit stream: wanted = " +
+            QUtil::uint_to_string(bits_wanted) + "; available = " +
+            QUtil::uint_to_string(bits_available));
+    }
+    if (bits_wanted > 32)
+    {
+        throw std::out_of_range("read_bits: too many bits requested");
+    }
+
+    unsigned long result = 0;
+#ifdef BITS_TESTING
+    if (bits_wanted == 0)
+    {
+        QTC::TC("libtests", "bits zero bits wanted");
+    }
+#endif
+    while (bits_wanted > 0)
+    {
+        // Grab bits from the first byte clearing anything before
+        // bit_offset.
+        unsigned char byte = static_cast<unsigned char>(
+            *p & ((1U << (bit_offset + 1U)) - 1U));
+
+        // There are bit_offset + 1 bits available in the first byte.
+        size_t to_copy = std::min(bits_wanted, bit_offset + 1);
+        size_t leftover = (bit_offset + 1) - to_copy;
+
+#ifdef BITS_TESTING
+        QTC::TC("libtests", "bits bit_offset",
+                ((bit_offset == 0) ? 0 :
+                 (bit_offset == 7) ? 1 :
+                 2));
+        QTC::TC("libtests", "bits leftover", (leftover > 0) ? 1 : 0);
+#endif
+
+        // Right shift so that all the bits we want are right justified.
+        byte = static_cast<unsigned char>(byte >> leftover);
+
+        // Copy the bits into result
+        result <<= to_copy;
+        result |= byte;
+
+        // Update pointers
+        if (leftover)
+        {
+            bit_offset = leftover - 1;
+        }
+        else
+        {
+            bit_offset = 7;
+            ++p;
+        }
+        bits_wanted -= to_copy;
+        bits_available -= to_copy;
+
+#ifdef BITS_TESTING
+        QTC::TC("libtests", "bits iterations",
+                ((bits_wanted > 8) ? 0 :
+                 (bits_wanted > 0) ? 1 :
+                 2));
+#endif
+    }
+
+    return result;
+}
+#endif
+
+#ifdef BITS_WRITE
+static void
+write_bits(unsigned char& ch, size_t& bit_offset,
+           unsigned long long val, size_t bits, Pipeline* pipeline)
+{
+    if (bits > 32)
+    {
+        throw std::out_of_range("write_bits: too many bits requested");
+    }
+
+    // bit_offset + 1 is the number of bits left in ch
+#ifdef BITS_TESTING
+    if (bits == 0)
+    {
+        QTC::TC("libtests", "bits write zero bits");
+    }
+#endif
+    while (bits > 0)
+    {
+        size_t bits_to_write = std::min(bits, bit_offset + 1);
+        unsigned char newval = static_cast<unsigned char>(
+            (val >> (bits - bits_to_write)) & ((1U << bits_to_write) - 1));
+        size_t bits_left_in_ch = bit_offset + 1 - bits_to_write;
+        newval = static_cast<unsigned char>(newval << bits_left_in_ch);
+        ch |= newval;
+        if (bits_left_in_ch == 0)
+        {
+#ifdef BITS_TESTING
+            QTC::TC("libtests", "bits write pipeline");
+#endif
+            pipeline->write(&ch, 1);
+            bit_offset = 7;
+            ch = 0;
+        }
+        else
+        {
+#ifdef BITS_TESTING
+            QTC::TC("libtests", "bits write leftover");
+#endif
+            bit_offset -= bits_to_write;
+        }
+        bits -= bits_to_write;
+#ifdef BITS_TESTING
+        QTC::TC("libtests", "bits write iterations",
+                ((bits > 8) ? 0 :
+                 (bits > 0) ? 1 :
+                 2));
+#endif
+    }
+
+}
+#endif
+
+
+#endif // __BITS_CC__
-- 
cgit v1.2.3-54-g00ecf