Fix sign and conversion warnings (major)

This makes all integer type conversions that have potential data loss
explicit with calls that do range checks and raise an exception. After
this commit, qpdf builds with no warnings when -Wsign-conversion
-Wconversion is used with gcc or clang or when -W3 -Wd4800 is used
with MSVC. This significantly reduces the likelihood of potential
crashes from bogus integer values.

There are some parts of the code that take int when they should take
size_t or an offset. Such places would make qpdf not support files
with more than 2^31 of something that usually wouldn't be so large. In
the event that such a file shows up and is valid, at least qpdf would
raise an error in the right spot so the issue could be legitimately
addressed rather than failing in some weird way because of a silent
overflow condition.

1 files changed, 144 insertions, 135 deletions

diff --git a/libqpdf/QPDF_linearization.cc b/libqpdf/QPDF_linearization.cc
index 5de1e8f6..04b646d3 100644
--- a/libqpdf/QPDF_linearization.cc
+++ b/libqpdf/QPDF_linearization.cc
@@ -26,15 +26,15 @@ load_vector_int(BitStream& bit_stream, int nitems, std::vector<T>& vec,
     // nitems times, read bits_wanted from the given bit stream,
     // storing results in the ith vector entry.
 
-    for (int i = 0; i < nitems; ++i)
+    for (size_t i = 0; i < QIntC::to_size(nitems); ++i)
     {
         if (append)
         {
             vec.push_back(T());
         }
-	vec.at(i).*field = bit_stream.getBits(bits_wanted);
+	vec.at(i).*field = bit_stream.getBitsInt(QIntC::to_size(bits_wanted));
     }
-    if (static_cast<int>(vec.size()) != nitems)
+    if (QIntC::to_int(vec.size()) != nitems)
     {
         throw std::logic_error("vector has wrong size in load_vector_int");
     }
@@ -51,11 +51,12 @@ load_vector_vector(BitStream& bit_stream,
 {
     // nitems1 times, read nitems2 (from the ith element of vec1) items
     // into the vec2 vector field of the ith item of vec1.
-    for (int i1 = 0; i1 < nitems1; ++i1)
+    for (size_t i1 = 0; i1 < QIntC::to_size(nitems1); ++i1)
     {
 	for (int i2 = 0; i2 < vec1.at(i1).*nitems2; ++i2)
 	{
-	    (vec1.at(i1).*vec2).push_back(bit_stream.getBits(bits_wanted));
+	    (vec1.at(i1).*vec2).push_back(
+                bit_stream.getBitsInt(QIntC::to_size(bits_wanted)));
 	}
     }
     bit_stream.skipToNextByte();
@@ -131,7 +132,7 @@ QPDF::isLinearized()
             (t4.getType() == QPDFTokenizer::tt_dict_open))
         {
 	    lindict_obj =
-                static_cast<int>(QUtil::string_to_ll(t1.getValue().c_str()));
+                QIntC::to_int(QUtil::string_to_ll(t1.getValue().c_str()));
 	}
     }
 
@@ -149,7 +150,7 @@ QPDF::isLinearized()
 
     QPDFObjectHandle linkey = candidate.getKey("/Linearized");
     if (! (linkey.isNumber() &&
-           (static_cast<int>(floor(linkey.getNumericValue())) == 1)))
+           (QIntC::to_int(floor(linkey.getNumericValue())) == 1)))
     {
 	return false;
     }
@@ -213,7 +214,7 @@ QPDF::readLinearizationData()
     }
 
     // Hint table array: offset length [ offset length ]
-    unsigned int n_H_items = H.getArrayNItems();
+    size_t n_H_items = toS(H.getArrayNItems());
     if (! ((n_H_items == 2) || (n_H_items == 4)))
     {
 	throw QPDFExc(qpdf_e_damaged_pdf, this->m->file->getName(),
@@ -223,12 +224,12 @@ QPDF::readLinearizationData()
     }
 
     std::vector<int> H_items;
-    for (unsigned int i = 0; i < n_H_items; ++i)
+    for (size_t i = 0; i < n_H_items; ++i)
     {
-	QPDFObjectHandle oh(H.getArrayItem(i));
+	QPDFObjectHandle oh(H.getArrayItem(toI(i)));
 	if (oh.isInteger())
 	{
-	    H_items.push_back(oh.getIntValue());
+	    H_items.push_back(oh.getIntValueAsInt());
 	}
 	else
 	{
@@ -258,7 +259,7 @@ QPDF::readLinearizationData()
     if (P.isInteger())
     {
 	QTC::TC("qpdf", "QPDF P present in lindict");
-	first_page = P.getIntValue();
+	first_page = P.getIntValueAsInt();
     }
     else
     {
@@ -279,9 +280,9 @@ QPDF::readLinearizationData()
     }
 
     // file_size initialized by isLinearized()
-    this->m->linp.first_page_object = O.getIntValue();
+    this->m->linp.first_page_object = O.getIntValueAsInt();
     this->m->linp.first_page_end = E.getIntValue();
-    this->m->linp.npages = N.getIntValue();
+    this->m->linp.npages = N.getIntValueAsInt();
     this->m->linp.xref_zero_offset = T.getIntValue();
     this->m->linp.first_page = first_page;
     this->m->linp.H_offset = H0_offset;
@@ -290,10 +291,10 @@ QPDF::readLinearizationData()
     // Read hint streams
 
     Pl_Buffer pb("hint buffer");
-    QPDFObjectHandle H0 = readHintStream(pb, H0_offset, H0_length);
+    QPDFObjectHandle H0 = readHintStream(pb, H0_offset, toS(H0_length));
     if (H1_offset)
     {
-	(void) readHintStream(pb, H1_offset, H1_length);
+	(void) readHintStream(pb, H1_offset, toS(H1_length));
     }
 
     // PDF 1.4 hint tables that we ignore:
@@ -313,31 +314,31 @@ QPDF::readLinearizationData()
     PointerHolder<Buffer> hbp = pb.getBuffer();
     Buffer* hb = hbp.getPointer();
     unsigned char const* h_buf = hb->getBuffer();
-    int h_size = hb->getSize();
+    size_t h_size = hb->getSize();
 
     readHPageOffset(BitStream(h_buf, h_size));
 
-    int HSi = HS.getIntValue();
-    if ((HSi < 0) || (HSi >= h_size))
+    int HSi = HS.getIntValueAsInt();
+    if ((HSi < 0) || (toS(HSi) >= h_size))
     {
         throw QPDFExc(qpdf_e_damaged_pdf, this->m->file->getName(),
                       "linearization hint table",
                       this->m->file->getLastOffset(),
                       "/S (shared object) offset is out of bounds");
     }
-    readHSharedObject(BitStream(h_buf + HSi, h_size - HSi));
+    readHSharedObject(BitStream(h_buf + HSi, h_size - toS(HSi)));
 
     if (HO.isInteger())
     {
-	int HOi = HO.getIntValue();
-        if ((HOi < 0) || (HOi >= h_size))
+	int HOi = HO.getIntValueAsInt();
+        if ((HOi < 0) || (toS(HOi) >= h_size))
         {
             throw QPDFExc(qpdf_e_damaged_pdf, this->m->file->getName(),
                           "linearization hint table",
                           this->m->file->getLastOffset(),
                           "/O (outline) offset is out of bounds");
         }
-	readHGeneric(BitStream(h_buf + HOi, h_size - HOi),
+	readHGeneric(BitStream(h_buf + HOi, h_size - toS(HOi)),
 		     this->m->outline_hints);
     }
 }
@@ -381,7 +382,7 @@ QPDF::readHintStream(Pipeline& pl, qpdf_offset_t offset, size_t length)
     {
 	QTC::TC("qpdf", "QPDF hint table length direct");
     }
-    qpdf_offset_t computed_end = offset + length;
+    qpdf_offset_t computed_end = offset + toO(length);
     if ((computed_end < min_end_offset) ||
 	(computed_end > max_end_offset))
     {
@@ -405,23 +406,23 @@ QPDF::readHPageOffset(BitStream h)
 
     HPageOffset& t = this->m->page_offset_hints;
 
-    t.min_nobjects = h.getBits(32);		  	    // 1
-    t.first_page_offset = h.getBits(32);		    // 2
-    t.nbits_delta_nobjects = h.getBits(16);		    // 3
-    t.min_page_length = h.getBits(32);			    // 4
-    t.nbits_delta_page_length = h.getBits(16);		    // 5
-    t.min_content_offset = h.getBits(32);		    // 6
-    t.nbits_delta_content_offset = h.getBits(16);	    // 7
-    t.min_content_length = h.getBits(32);		    // 8
-    t.nbits_delta_content_length = h.getBits(16);	    // 9
-    t.nbits_nshared_objects = h.getBits(16);		    // 10
-    t.nbits_shared_identifier = h.getBits(16);		    // 11
-    t.nbits_shared_numerator = h.getBits(16);		    // 12
-    t.shared_denominator = h.getBits(16);		    // 13
+    t.min_nobjects = h.getBitsInt(32);                      // 1
+    t.first_page_offset = h.getBitsInt(32);                 // 2
+    t.nbits_delta_nobjects = h.getBitsInt(16);              // 3
+    t.min_page_length = h.getBitsInt(32);                   // 4
+    t.nbits_delta_page_length = h.getBitsInt(16);           // 5
+    t.min_content_offset = h.getBitsInt(32);                // 6
+    t.nbits_delta_content_offset = h.getBitsInt(16);        // 7
+    t.min_content_length = h.getBitsInt(32);                // 8
+    t.nbits_delta_content_length = h.getBitsInt(16);        // 9
+    t.nbits_nshared_objects = h.getBitsInt(16);             // 10
+    t.nbits_shared_identifier = h.getBitsInt(16);           // 11
+    t.nbits_shared_numerator = h.getBitsInt(16);            // 12
+    t.shared_denominator = h.getBitsInt(16);                // 13
 
     std::vector<HPageOffsetEntry>& entries = t.entries;
     entries.clear();
-    unsigned int nitems = this->m->linp.npages;
+    int nitems = this->m->linp.npages;
     load_vector_int(h, nitems, entries,
 		    t.nbits_delta_nobjects,
 		    &HPageOffsetEntry::delta_nobjects);
@@ -452,13 +453,13 @@ QPDF::readHSharedObject(BitStream h)
 {
     HSharedObject& t = this->m->shared_object_hints;
 
-    t.first_shared_obj = h.getBits(32);			    // 1
-    t.first_shared_offset = h.getBits(32);		    // 2
-    t.nshared_first_page = h.getBits(32);		    // 3
-    t.nshared_total = h.getBits(32);			    // 4
-    t.nbits_nobjects = h.getBits(16);			    // 5
-    t.min_group_length = h.getBits(32);			    // 6
-    t.nbits_delta_group_length = h.getBits(16);		    // 7
+    t.first_shared_obj = h.getBitsInt(32);                  // 1
+    t.first_shared_offset = h.getBitsInt(32);               // 2
+    t.nshared_first_page = h.getBitsInt(32);                // 3
+    t.nshared_total = h.getBitsInt(32);                     // 4
+    t.nbits_nobjects = h.getBitsInt(16);                    // 5
+    t.min_group_length = h.getBitsInt(32);                  // 6
+    t.nbits_delta_group_length = h.getBitsInt(16);          // 7
 
     QTC::TC("qpdf", "QPDF lin nshared_total > nshared_first_page",
 	    (t.nshared_total > t.nshared_first_page) ? 1 : 0);
@@ -471,7 +472,7 @@ QPDF::readHSharedObject(BitStream h)
 		    &HSharedObjectEntry::delta_group_length);
     load_vector_int(h, nitems, entries,
 		    1, &HSharedObjectEntry::signature_present);
-    for (int i = 0; i < nitems; ++i)
+    for (size_t i = 0; i < toS(nitems); ++i)
     {
 	if (entries.at(i).signature_present)
 	{
@@ -492,10 +493,10 @@ QPDF::readHSharedObject(BitStream h)
 void
 QPDF::readHGeneric(BitStream h, HGeneric& t)
 {
-    t.first_object = h.getBits(32);			    // 1
-    t.first_object_offset = h.getBits(32);		    // 2
-    t.nobjects = h.getBits(32);				    // 3
-    t.group_length = h.getBits(32);			    // 4
+    t.first_object = h.getBitsInt(32);                      // 1
+    t.first_object_offset = h.getBitsInt(32);               // 2
+    t.nobjects = h.getBitsInt(32);                          // 3
+    t.group_length = h.getBitsInt(32);                      // 4
 }
 
 bool
@@ -522,21 +523,21 @@ QPDF::checkLinearizationInternal()
     }
 
     // N: number of pages
-    int npages = pages.size();
+    int npages = toI(pages.size());
     if (p.npages != npages)
     {
 	// Not tested in the test suite
 	errors.push_back("page count (/N) mismatch");
     }
 
-    for (int i = 0; i < npages; ++i)
+    for (size_t i = 0; i < toS(npages); ++i)
     {
 	QPDFObjectHandle const& page = pages.at(i);
 	QPDFObjGen og(page.getObjGen());
 	if (this->m->xref_table[og].getType() == 2)
 	{
 	    errors.push_back("page dictionary for page " +
-			     QUtil::int_to_string(i) + " is compressed");
+			     QUtil::uint_to_string(i) + " is compressed");
 	}
     }
 
@@ -756,8 +757,8 @@ QPDF::lengthNextN(int first_object, int n,
                 stopOnError("found unknown object while"
                             " calculating length for linearization data");
             }
-	    length += this->m->obj_cache[og].end_after_space -
-		getLinearizationOffset(og);
+	    length += toI(this->m->obj_cache[og].end_after_space -
+                          getLinearizationOffset(og));
 	}
     }
     return length;
@@ -786,8 +787,8 @@ QPDF::checkHPageOffset(std::list<std::string>& errors,
     // under a page's /Resources dictionary in with shared objects
     // even when they are private.
 
-    unsigned int npages = pages.size();
-    int table_offset = adjusted_offset(
+    int npages = toI(pages.size());
+    qpdf_offset_t table_offset = adjusted_offset(
 	this->m->page_offset_hints.first_page_offset);
     QPDFObjGen first_page_og(pages.at(0).getObjGen());
     if (this->m->xref_table.count(first_page_og) == 0)
@@ -800,9 +801,9 @@ QPDF::checkHPageOffset(std::list<std::string>& errors,
 	warnings.push_back("first page object offset mismatch");
     }
 
-    for (unsigned int pageno = 0; pageno < npages; ++pageno)
+    for (int pageno = 0; pageno < npages; ++pageno)
     {
-	QPDFObjGen page_og(pages.at(pageno).getObjGen());
+	QPDFObjGen page_og(pages.at(toS(pageno)).getObjGen());
 	int first_object = page_og.getObj();
 	if (this->m->xref_table.count(page_og) == 0)
         {
@@ -810,8 +811,10 @@ QPDF::checkHPageOffset(std::list<std::string>& errors,
         }
 	offset = getLinearizationOffset(page_og);
 
-	HPageOffsetEntry& he = this->m->page_offset_hints.entries.at(pageno);
-	CHPageOffsetEntry& ce = this->m->c_page_offset_data.entries.at(pageno);
+	HPageOffsetEntry& he =
+            this->m->page_offset_hints.entries.at(toS(pageno));
+	CHPageOffsetEntry& ce =
+            this->m->c_page_offset_data.entries.at(toS(pageno));
 	int h_nobjects = he.delta_nobjects +
 	    this->m->page_offset_hints.min_nobjects;
 	if (h_nobjects != ce.nobjects)
@@ -827,8 +830,8 @@ QPDF::checkHPageOffset(std::list<std::string>& errors,
 	// Use value for number of objects in hint table rather than
 	// computed value if there is a discrepancy.
 	int length = lengthNextN(first_object, h_nobjects, errors);
-	int h_length = he.delta_page_length +
-	    this->m->page_offset_hints.min_page_length;
+	int h_length = toI(he.delta_page_length +
+                           this->m->page_offset_hints.min_page_length);
 	if (length != h_length)
 	{
 	    // This condition almost certainly indicates a bad hint
@@ -854,7 +857,7 @@ QPDF::checkHPageOffset(std::list<std::string>& errors,
 	    warnings.push_back("page 0 has shared identifier entries");
 	}
 
-	for (int i = 0; i < he.nshared_objects; ++i)
+	for (size_t i = 0; i < toS(he.nshared_objects); ++i)
 	{
 	    int idx = he.shared_identifiers.at(i);
 	    if (shared_idx_to_obj.count(idx) == 0)
@@ -866,7 +869,7 @@ QPDF::checkHPageOffset(std::list<std::string>& errors,
 	    hint_shared.insert(shared_idx_to_obj[idx]);
 	}
 
-	for (int i = 0; i < ce.nshared_objects; ++i)
+	for (size_t i = 0; i < toS(ce.nshared_objects); ++i)
 	{
 	    int idx = ce.shared_identifiers.at(i);
 	    if (idx >= this->m->c_shared_object_data.nshared_total)
@@ -874,7 +877,7 @@ QPDF::checkHPageOffset(std::list<std::string>& errors,
                 throw std::logic_error(
                     "index out of bounds for shared object hint table");
             }
-	    int obj = this->m->c_shared_object_data.entries.at(idx).object;
+	    int obj = this->m->c_shared_object_data.entries.at(toS(idx)).object;
 	    computed_shared.insert(obj);
 	}
 
@@ -975,8 +978,9 @@ QPDF::checkHSharedObject(std::list<std::string>& errors,
                 {
                     stopOnError("unknown object in shared object hint table");
                 }
-		int offset = getLinearizationOffset(og);
-		int h_offset = adjusted_offset(so.first_shared_offset);
+		qpdf_offset_t offset = getLinearizationOffset(og);
+		qpdf_offset_t h_offset =
+                    adjusted_offset(so.first_shared_offset);
 		if (offset != h_offset)
 		{
 		    errors.push_back(
@@ -987,7 +991,7 @@ QPDF::checkHSharedObject(std::list<std::string>& errors,
 	    }
 
 	    idx_to_obj[i] = cur_object;
-	    HSharedObjectEntry& se = so.entries.at(i);
+	    HSharedObjectEntry& se = so.entries.at(toS(i));
 	    int nobjects = se.nobjects_minus_one + 1;
 	    int length = lengthNextN(cur_object, nobjects, errors);
 	    int h_length = so.min_group_length + se.delta_group_length;
@@ -1041,10 +1045,10 @@ QPDF::checkHOutlines(std::list<std::string>& warnings)
             {
                 stopOnError("unknown object in outlines hint table");
             }
-	    int offset = getLinearizationOffset(og);
+	    qpdf_offset_t offset = getLinearizationOffset(og);
 	    ObjUser ou(ObjUser::ou_root_key, "/Outlines");
-	    int length = maxEnd(ou) - offset;
-	    int table_offset =
+	    int length = toI(maxEnd(ou) - offset);
+	    qpdf_offset_t table_offset =
 		adjusted_offset(this->m->outline_hints.first_object_offset);
 	    if (offset != table_offset)
 	    {
@@ -1124,8 +1128,8 @@ QPDF::dumpLinearizationDataInternal()
     }
 }
 
-int
-QPDF::adjusted_offset(int offset)
+qpdf_offset_t
+QPDF::adjusted_offset(qpdf_offset_t offset)
 {
     // All offsets >= H_offset have to be increased by H_length
     // since all hint table location values disregard the hint table
@@ -1170,7 +1174,7 @@ QPDF::dumpHPageOffset()
 	<< "shared_denominator: " << t.shared_denominator
 	<< std::endl;
 
-    for (int i1 = 0; i1 < this->m->linp.npages; ++i1)
+    for (size_t i1 = 0; i1 < toS(this->m->linp.npages); ++i1)
     {
 	HPageOffsetEntry& pe = t.entries.at(i1);
 	*this->m->out_stream
@@ -1185,7 +1189,7 @@ QPDF::dumpHPageOffset()
 	    << "  content_length: "
 	    << pe.delta_content_length + t.min_content_length << std::endl
 	    << "  nshared_objects: " << pe.nshared_objects << std::endl;
-	for (int i2 = 0; i2 < pe.nshared_objects; ++i2)
+	for (size_t i2 = 0; i2 < toS(pe.nshared_objects); ++i2)
 	{
 	    *this->m->out_stream << "    identifier " << i2 << ": "
                                  << pe.shared_identifiers.at(i2) << std::endl;
@@ -1215,7 +1219,7 @@ QPDF::dumpHSharedObject()
 	<< "nbits_delta_group_length: " << t.nbits_delta_group_length
 	<< std::endl;
 
-    for (int i = 0; i < t.nshared_total; ++i)
+    for (size_t i = 0; i < toS(t.nshared_total); ++i)
     {
 	HSharedObjectEntry& se = t.entries.at(i);
 	*this->m->out_stream
@@ -1516,7 +1520,7 @@ QPDF::calculateLinearizationData(std::map<int, int> const& object_stream_data)
 	    pages.push_back(getUncompressedObject(*iter, object_stream_data));
 	}
     }
-    unsigned int npages = pages.size();
+    int npages = toI(pages.size());
 
     // We will be initializing some values of the computed hint
     // tables.  Specifically, we can initialize any items that deal
@@ -1531,7 +1535,7 @@ QPDF::calculateLinearizationData(std::map<int, int> const& object_stream_data)
     // reasonable size.
     this->m->c_linp.npages = npages;
     this->m->c_page_offset_data.entries =
-        std::vector<CHPageOffsetEntry>(npages);
+        std::vector<CHPageOffsetEntry>(toS(npages));
 
     // Part 4: open document objects.  We don't care about the order.
 
@@ -1594,12 +1598,13 @@ QPDF::calculateLinearizationData(std::map<int, int> const& object_stream_data)
     // in garbage values for all the shared object identifiers on the
     // first page.
 
-    this->m->c_page_offset_data.entries.at(0).nobjects = this->m->part6.size();
+    this->m->c_page_offset_data.entries.at(0).nobjects =
+        toI(this->m->part6.size());
 
     // Part 7: other pages' private objects
 
     // For each page in order:
-    for (unsigned int i = 1; i < npages; ++i)
+    for (size_t i = 1; i < toS(npages); ++i)
     {
 	// Place this page's page object
 
@@ -1609,7 +1614,7 @@ QPDF::calculateLinearizationData(std::map<int, int> const& object_stream_data)
 	    throw std::logic_error(
 		"INTERNAL ERROR: "
 		"QPDF::calculateLinearizationData: page object for page " +
-		QUtil::int_to_string(i) + " not in lc_other_page_private");
+		QUtil::uint_to_string(i) + " not in lc_other_page_private");
 	}
 	lc_other_page_private.erase(page_og);
 	this->m->part7.push_back(pages.at(i));
@@ -1619,7 +1624,7 @@ QPDF::calculateLinearizationData(std::map<int, int> const& object_stream_data)
 
 	this->m->c_page_offset_data.entries.at(i).nobjects = 1;
 
-	ObjUser ou(ObjUser::ou_page, i);
+	ObjUser ou(ObjUser::ou_page, toI(i));
 	if (this->m->obj_user_to_objects.count(ou) == 0)
         {
             stopOnError("found unreferenced page while"
@@ -1687,7 +1692,7 @@ QPDF::calculateLinearizationData(std::map<int, int> const& object_stream_data)
     // Place private thumbnail images in page order.  Slightly more
     // information would be required if we were going to bother with
     // thumbnail hint tables.
-    for (unsigned int i = 0; i < npages; ++i)
+    for (size_t i = 0; i < toS(npages); ++i)
     {
 	QPDFObjectHandle thumb = pages.at(i).getKey("/Thumb");
 	thumb = getUncompressedObject(thumb, object_stream_data);
@@ -1710,7 +1715,8 @@ QPDF::calculateLinearizationData(std::map<int, int> const& object_stream_data)
 		// lc_thumbnail_private.
 	    }
 	    std::set<QPDFObjGen>& ogs =
-		this->m->obj_user_to_objects[ObjUser(ObjUser::ou_thumb, i)];
+		this->m->obj_user_to_objects[
+                    ObjUser(ObjUser::ou_thumb, toI(i))];
 	    for (std::set<QPDFObjGen>::iterator iter = ogs.begin();
 		 iter != ogs.end(); ++iter)
 	    {
@@ -1753,18 +1759,18 @@ QPDF::calculateLinearizationData(std::map<int, int> const& object_stream_data)
 
     // Make sure we got everything exactly once.
 
-    unsigned int num_placed =
+    size_t num_placed =
         this->m->part4.size() + this->m->part6.size() + this->m->part7.size() +
         this->m->part8.size() + this->m->part9.size();
-    unsigned int num_wanted = this->m->object_to_obj_users.size();
+    size_t num_wanted = this->m->object_to_obj_users.size();
     if (num_placed != num_wanted)
     {
 	throw std::logic_error(
 	    "INTERNAL ERROR: QPDF::calculateLinearizationData: wrong "
 	    "number of objects placed (num_placed = " +
-	    QUtil::int_to_string(num_placed) +
+	    QUtil::uint_to_string(num_placed) +
 	    "; number of objects: " +
-	    QUtil::int_to_string(num_wanted));
+	    QUtil::uint_to_string(num_wanted));
     }
 
     // Calculate shared object hint table information including
@@ -1780,10 +1786,11 @@ QPDF::calculateLinearizationData(std::map<int, int> const& object_stream_data)
     // can map from object number only without regards to generation.
     std::map<int, int> obj_to_index;
 
-    this->m->c_shared_object_data.nshared_first_page = this->m->part6.size();
+    this->m->c_shared_object_data.nshared_first_page =
+        toI(this->m->part6.size());
     this->m->c_shared_object_data.nshared_total =
 	this->m->c_shared_object_data.nshared_first_page +
-        this->m->part8.size();
+        toI(this->m->part8.size());
 
     std::vector<CHSharedObjectEntry>& shared =
 	this->m->c_shared_object_data.entries;
@@ -1792,7 +1799,7 @@ QPDF::calculateLinearizationData(std::map<int, int> const& object_stream_data)
     {
 	QPDFObjectHandle& oh = *iter;
 	int obj = oh.getObjectID();
-	obj_to_index[obj] = shared.size();
+	obj_to_index[obj] = toI(shared.size());
 	shared.push_back(CHSharedObjectEntry(obj));
     }
     QTC::TC("qpdf", "QPDF lin part 8 empty", this->m->part8.empty() ? 1 : 0);
@@ -1806,7 +1813,7 @@ QPDF::calculateLinearizationData(std::map<int, int> const& object_stream_data)
 	{
 	    QPDFObjectHandle& oh = *iter;
 	    int obj = oh.getObjectID();
-	    obj_to_index[obj] = shared.size();
+	    obj_to_index[obj] = toI(shared.size());
 	    shared.push_back(CHSharedObjectEntry(obj));
 	}
     }
@@ -1820,10 +1827,10 @@ QPDF::calculateLinearizationData(std::map<int, int> const& object_stream_data)
     // Now compute the list of shared objects for each page after the
     // first page.
 
-    for (unsigned int i = 1; i < npages; ++i)
+    for (size_t i = 1; i < toS(npages); ++i)
     {
 	CHPageOffsetEntry& pe = this->m->c_page_offset_data.entries.at(i);
-	ObjUser ou(ObjUser::ou_page, i);
+	ObjUser ou(ObjUser::ou_page, toI(i));
 	if (this->m->obj_user_to_objects.count(ou) == 0)
         {
             stopOnError("found unreferenced page while"
@@ -1921,7 +1928,7 @@ QPDF::outputLengthNextN(
             stopOnError("found item with unknown length"
                         " while writing linearization data");
         }
-	length += (*(lengths.find(first + i))).second;
+	length += toI((*(lengths.find(first + toI(i)))).second);
     }
     return length;
 }
@@ -1938,7 +1945,7 @@ QPDF::calculateHPageOffset(
     // values.
 
     std::vector<QPDFObjectHandle> const& pages = getAllPages();
-    unsigned int npages = pages.size();
+    size_t npages = pages.size();
     CHPageOffset& cph = this->m->c_page_offset_data;
     std::vector<CHPageOffsetEntry>& cphe = cph.entries;
 
@@ -2001,7 +2008,7 @@ QPDF::calculateHPageOffset(
     ph.nbits_delta_content_length = ph.nbits_delta_page_length;
     ph.min_content_length = ph.min_page_length;
 
-    for (unsigned int i = 0; i < npages; ++i)
+    for (size_t i = 0; i < npages; ++i)
     {
 	// Adjust delta entries
 	if ((phe.at(i).delta_nobjects < min_nobjects) ||
@@ -2014,7 +2021,7 @@ QPDF::calculateHPageOffset(
 	phe.at(i).delta_page_length -= min_length;
 	phe.at(i).delta_content_length = phe.at(i).delta_page_length;
 
-	for (int j = 0; j < cphe.at(i).nshared_objects; ++j)
+	for (size_t j = 0; j < toS(cphe.at(i).nshared_objects); ++j)
 	{
 	    phe.at(i).shared_identifiers.push_back(
 		cphe.at(i).shared_identifiers.at(j));
@@ -2039,7 +2046,7 @@ QPDF::calculateHSharedObject(
 	csoe.at(0).object, 1, lengths, obj_renumber);
     int max_length = min_length;
 
-    for (int i = 0; i < cso.nshared_total; ++i)
+    for (size_t i = 0; i < toS(cso.nshared_total); ++i)
     {
 	// Assign absolute numbers to deltas; adjust later
 	int length = outputLengthNextN(
@@ -2066,7 +2073,7 @@ QPDF::calculateHSharedObject(
     so.min_group_length = min_length;
     so.nbits_delta_group_length = nbits(max_length - min_length);
 
-    for (int i = 0; i < cso.nshared_total; ++i)
+    for (size_t i = 0; i < toS(cso.nshared_total); ++i)
     {
 	// Adjust deltas
 	if (soe.at(i).delta_group_length < min_length)
@@ -2110,9 +2117,10 @@ write_vector_int(BitWriter& w, int nitems, std::vector<T>& vec,
     // nitems times, write bits bits from the given field of the ith
     // vector to the given bit writer.
 
-    for (int i = 0; i < nitems; ++i)
+    for (size_t i = 0; i < QIntC::to_size(nitems); ++i)
     {
-	w.writeBits(vec.at(i).*field, bits);
+	w.writeBits(QIntC::to_ulonglong(vec.at(i).*field),
+                    QIntC::to_size(bits));
     }
     // The PDF spec says that each hint table starts at a byte
     // boundary.  Each "row" actually must start on a byte boundary.
@@ -2127,11 +2135,12 @@ write_vector_vector(BitWriter& w,
 {
     // nitems1 times, write nitems2 (from the ith element of vec1) items
     // from the vec2 vector field of the ith item of vec1.
-    for (int i1 = 0; i1 < nitems1; ++i1)
+    for (size_t i1 = 0; i1 < QIntC::to_size(nitems1); ++i1)
     {
-	for (int i2 = 0; i2 < vec1.at(i1).*nitems2; ++i2)
+	for (size_t i2 = 0; i2 < QIntC::to_size(vec1.at(i1).*nitems2); ++i2)
 	{
-	    w.writeBits((vec1.at(i1).*vec2).at(i2), bits);
+	    w.writeBits(QIntC::to_ulonglong((vec1.at(i1).*vec2).at(i2)),
+                        QIntC::to_size(bits));
 	}
     }
     w.flush();
@@ -2143,21 +2152,21 @@ QPDF::writeHPageOffset(BitWriter& w)
 {
     HPageOffset& t = this->m->page_offset_hints;
 
-    w.writeBits(t.min_nobjects, 32);			    // 1
-    w.writeBits(t.first_page_offset, 32);		    // 2
-    w.writeBits(t.nbits_delta_nobjects, 16);		    // 3
-    w.writeBits(t.min_page_length, 32);			    // 4
-    w.writeBits(t.nbits_delta_page_length, 16);		    // 5
-    w.writeBits(t.min_content_offset, 32);		    // 6
-    w.writeBits(t.nbits_delta_content_offset, 16);	    // 7
-    w.writeBits(t.min_content_length, 32);		    // 8
-    w.writeBits(t.nbits_delta_content_length, 16);	    // 9
-    w.writeBits(t.nbits_nshared_objects, 16);		    // 10
-    w.writeBits(t.nbits_shared_identifier, 16);		    // 11
-    w.writeBits(t.nbits_shared_numerator, 16);		    // 12
-    w.writeBits(t.shared_denominator, 16);		    // 13
-
-    unsigned int nitems = getAllPages().size();
+    w.writeBitsInt(t.min_nobjects, 32);                     // 1
+    w.writeBitsInt(toI(t.first_page_offset), 32);           // 2
+    w.writeBitsInt(t.nbits_delta_nobjects, 16);             // 3
+    w.writeBitsInt(t.min_page_length, 32);                  // 4
+    w.writeBitsInt(t.nbits_delta_page_length, 16);          // 5
+    w.writeBitsInt(t.min_content_offset, 32);               // 6
+    w.writeBitsInt(t.nbits_delta_content_offset, 16);       // 7
+    w.writeBitsInt(t.min_content_length, 32);               // 8
+    w.writeBitsInt(t.nbits_delta_content_length, 16);       // 9
+    w.writeBitsInt(t.nbits_nshared_objects, 16);            // 10
+    w.writeBitsInt(t.nbits_shared_identifier, 16);          // 11
+    w.writeBitsInt(t.nbits_shared_numerator, 16);           // 12
+    w.writeBitsInt(t.shared_denominator, 16);               // 13
+
+    int nitems = toI(getAllPages().size());
     std::vector<HPageOffsetEntry>& entries = t.entries;
 
     write_vector_int(w, nitems, entries,
@@ -2190,13 +2199,13 @@ QPDF::writeHSharedObject(BitWriter& w)
 {
     HSharedObject& t = this->m->shared_object_hints;
 
-    w.writeBits(t.first_shared_obj, 32);		    // 1
-    w.writeBits(t.first_shared_offset, 32);		    // 2
-    w.writeBits(t.nshared_first_page, 32);		    // 3
-    w.writeBits(t.nshared_total, 32);			    // 4
-    w.writeBits(t.nbits_nobjects, 16);			    // 5
-    w.writeBits(t.min_group_length, 32);		    // 6
-    w.writeBits(t.nbits_delta_group_length, 16);	    // 7
+    w.writeBitsInt(t.first_shared_obj, 32);                 // 1
+    w.writeBitsInt(toI(t.first_shared_offset), 32);         // 2
+    w.writeBitsInt(t.nshared_first_page, 32);               // 3
+    w.writeBitsInt(t.nshared_total, 32);                    // 4
+    w.writeBitsInt(t.nbits_nobjects, 16);                   // 5
+    w.writeBitsInt(t.min_group_length, 32);                 // 6
+    w.writeBitsInt(t.nbits_delta_group_length, 16);         // 7
 
     QTC::TC("qpdf", "QPDF lin write nshared_total > nshared_first_page",
 	    (t.nshared_total > t.nshared_first_page) ? 1 : 0);
@@ -2209,7 +2218,7 @@ QPDF::writeHSharedObject(BitWriter& w)
 		     &HSharedObjectEntry::delta_group_length);
     write_vector_int(w, nitems, entries,
 		     1, &HSharedObjectEntry::signature_present);
-    for (int i = 0; i < nitems; ++i)
+    for (size_t i = 0; i < toS(nitems); ++i)
     {
 	// If signature were present, we'd have to write a 128-bit hash.
 	if (entries.at(i).signature_present != 0)
@@ -2226,10 +2235,10 @@ QPDF::writeHSharedObject(BitWriter& w)
 void
 QPDF::writeHGeneric(BitWriter& w, HGeneric& t)
 {
-    w.writeBits(t.first_object, 32);			    // 1
-    w.writeBits(t.first_object_offset, 32);		    // 2
-    w.writeBits(t.nobjects, 32);			    // 3
-    w.writeBits(t.group_length, 32);			    // 4
+    w.writeBitsInt(t.first_object, 32);                     // 1
+    w.writeBitsInt(toI(t.first_object_offset), 32);         // 2
+    w.writeBitsInt(t.nobjects, 32);                         // 3
+    w.writeBitsInt(t.group_length, 32);                     // 4
 }
 
 void
@@ -2252,12 +2261,12 @@ QPDF::generateHintStream(std::map<int, QPDFXRefEntry> const& xref,
     BitWriter w(&c);
 
     writeHPageOffset(w);
-    S = c.getCount();
+    S = toI(c.getCount());
     writeHSharedObject(w);
     O = 0;
     if (this->m->outline_hints.nobjects > 0)
     {
-	O = c.getCount();
+	O = toI(c.getCount());
 	writeHGeneric(w, this->m->outline_hints);
     }
     c.finish();