diff options
author | m-holger <m-holger@kubitscheck.org> | 2022-09-21 18:49:21 +0200 |
---|---|---|
committer | Jay Berkenbilt <jberkenbilt@users.noreply.github.com> | 2022-09-21 21:57:14 +0200 |
commit | 2e6869483bba657515aad305a3aa7013e477c448 (patch) | |
tree | 0487066d6069127082a5f176baf031e6ec6308b0 /libqpdf | |
parent | da67a0aa043c2c8ad129fbc87b93afcdab7042a7 (diff) | |
download | qpdf-2e6869483bba657515aad305a3aa7013e477c448.tar.zst |
Replace calls to QUtil::int_to_string with std::to_string
Diffstat (limited to 'libqpdf')
31 files changed, 195 insertions, 220 deletions
diff --git a/libqpdf/FileInputSource.cc b/libqpdf/FileInputSource.cc index 2b1ee1ab..7c4d6d42 100644 --- a/libqpdf/FileInputSource.cc +++ b/libqpdf/FileInputSource.cc @@ -105,8 +105,7 @@ FileInputSource::seek(qpdf_offset_t offset, int whence) if (QUtil::seek(this->file, offset, whence) == -1) { QUtil::throw_system_error( std::string("seek to ") + this->filename + ", offset " + - QUtil::int_to_string(offset) + " (" + QUtil::int_to_string(whence) + - ")"); + std::to_string(offset) + " (" + std::to_string(whence) + ")"); } } @@ -128,8 +127,7 @@ FileInputSource::read(char* buffer, size_t length) this->filename, "", this->last_offset, - (std::string("read ") + QUtil::uint_to_string(length) + - " bytes")); + (std::string("read ") + std::to_string(length) + " bytes")); } else if (length > 0) { this->seek(0, SEEK_END); this->last_offset = this->tell(); diff --git a/libqpdf/JSON.cc b/libqpdf/JSON.cc index 07180cf5..fba60267 100644 --- a/libqpdf/JSON.cc +++ b/libqpdf/JSON.cc @@ -148,7 +148,7 @@ JSON::JSON_string::write(Pipeline* p, size_t) const } JSON::JSON_number::JSON_number(long long value) : - encoded(QUtil::int_to_string(value)) + encoded(std::to_string(value)) { } @@ -554,7 +554,7 @@ JSON::checkSchemaInternal( sch_arr->elements.at(0).get(), flags, errors, - prefix + "." + QUtil::int_to_string(i)); + prefix + "." + std::to_string(i)); ++i; } } else { @@ -570,7 +570,7 @@ JSON::checkSchemaInternal( QTC::TC("libtests", "JSON schema array length mismatch"); errors.push_back( err_prefix + " is supposed to be an array of length " + - QUtil::uint_to_string(n_elements)); + std::to_string(n_elements)); return false; } else { // A multi-element array in the schema must correspond to @@ -584,7 +584,7 @@ JSON::checkSchemaInternal( sch_arr->elements.at(i).get(), flags, errors, - prefix + "." + QUtil::uint_to_string(i)); + prefix + "." + std::to_string(i)); ++i; } } @@ -703,10 +703,10 @@ JSONParser::handle_u_code( if (high_offset) { QTC::TC("libtests", "JSON 16 high high"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(new_high_offset) + + "JSON: offset " + std::to_string(new_high_offset) + ": UTF-16 high surrogate found after previous high surrogate" " at offset " + - QUtil::int_to_string(high_offset)); + std::to_string(high_offset)); } high_offset = new_high_offset; high_surrogate = codepoint; @@ -715,7 +715,7 @@ JSONParser::handle_u_code( if (offset + i != (high_offset + 6)) { QTC::TC("libtests", "JSON 16 low not after high"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset + i) + + "JSON: offset " + std::to_string(offset + i) + ": UTF-16 low surrogate found not immediately after high" " surrogate"); } @@ -797,7 +797,7 @@ JSONParser::decode_string(std::string const& str, qpdf_offset_t offset) if (high_offset) { QTC::TC("libtests", "JSON 16 dangling high"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(high_offset) + + "JSON: offset " + std::to_string(high_offset) + ": UTF-16 high surrogate not followed by low surrogate"); } return result; @@ -822,8 +822,7 @@ JSONParser::getToken() if (*p == 0) { QTC::TC("libtests", "JSON parse null character"); throw std::runtime_error( - "JSON: null character at offset " + - QUtil::int_to_string(offset)); + "JSON: null character at offset " + std::to_string(offset)); } action = append; switch (lex_state) { @@ -860,7 +859,7 @@ JSONParser::getToken() } else { QTC::TC("libtests", "JSON parse bad character"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": unexpected character " + std::string(p, 1)); } break; @@ -878,12 +877,12 @@ JSONParser::getToken() if (number_saw_e) { QTC::TC("libtests", "JSON parse point after e"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": numeric literal: decimal point after e"); } else if (number_saw_point) { QTC::TC("libtests", "JSON parse duplicate point"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": numeric literal: decimal point already seen"); } else { number_saw_point = true; @@ -892,7 +891,7 @@ JSONParser::getToken() if (number_saw_e) { QTC::TC("libtests", "JSON parse duplicate e"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": numeric literal: e already seen"); } else { number_saw_e = true; @@ -903,7 +902,7 @@ JSONParser::getToken() } else { QTC::TC("libtests", "JSON parse unexpected sign"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": numeric literal: unexpected sign"); } } else if (QUtil::is_space(*p)) { @@ -915,7 +914,7 @@ JSONParser::getToken() } else { QTC::TC("libtests", "JSON parse numeric bad character"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": numeric literal: unexpected character " + std::string(p, 1)); } @@ -933,7 +932,7 @@ JSONParser::getToken() } else { QTC::TC("libtests", "JSON parse keyword bad character"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": keyword: unexpected character " + std::string(p, 1)); } break; @@ -956,7 +955,7 @@ JSONParser::getToken() } else { QTC::TC("libtests", "JSON parse backslash bad character"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": invalid character after backslash: " + std::string(p, 1)); } @@ -966,8 +965,7 @@ JSONParser::getToken() if (!QUtil::is_hex_digit(*p)) { QTC::TC("libtests", "JSON parse bad hex after u"); throw std::runtime_error( - "JSON: offset " + - QUtil::int_to_string(offset - u_count - 1) + + "JSON: offset " + std::to_string(offset - u_count - 1) + ": \\u must be followed by four hex digits"); } if (++u_count == 4) { @@ -1006,15 +1004,14 @@ JSONParser::getToken() case ls_u4: QTC::TC("libtests", "JSON parse premature end of u"); throw std::runtime_error( - "JSON: offset " + - QUtil::int_to_string(offset - u_count - 1) + + "JSON: offset " + std::to_string(offset - u_count - 1) + ": \\u must be followed by four characters"); case ls_string: case ls_backslash: QTC::TC("libtests", "JSON parse unterminated string"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": unterminated string"); break; } @@ -1032,7 +1029,7 @@ JSONParser::handleToken() if (parser_state == ps_done) { QTC::TC("libtests", "JSON parse junk after object"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": material follows end of object: " + token); } @@ -1076,7 +1073,7 @@ JSONParser::handleToken() if (number_saw_point && (number_after_point == 0)) { QTC::TC("libtests", "JSON parse decimal with no digits"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": decimal point with no digits"); } if ((number_before_point > 1) && @@ -1084,13 +1081,13 @@ JSONParser::handleToken() ((first_char == '-') && (token.at(1) == '0')))) { QTC::TC("libtests", "JSON parse leading zero"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": number with leading zero"); } if ((number_before_point == 0) && (number_after_point == 0)) { QTC::TC("libtests", "JSON parse number no digits"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": number with no digits"); } item = std::make_shared<JSON>(JSON::makeNumber(token)); @@ -1106,7 +1103,7 @@ JSONParser::handleToken() } else { QTC::TC("libtests", "JSON parse invalid keyword"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": invalid keyword " + token); } break; @@ -1139,21 +1136,20 @@ JSONParser::handleToken() case ps_dict_after_key: QTC::TC("libtests", "JSON parse expected colon"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + - ": expected ':'"); + "JSON: offset " + std::to_string(offset) + ": expected ':'"); break; case ps_dict_after_item: QTC::TC("libtests", "JSON parse expected , or }"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": expected ',' or '}'"); break; case ps_array_after_item: QTC::TC("libtests", "JSON parse expected, or ]"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": expected ',' or ']'"); break; @@ -1162,7 +1158,7 @@ JSONParser::handleToken() if (lex_state != ls_string) { QTC::TC("libtests", "JSON parse string as dict key"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": expect string as dictionary key"); } break; @@ -1181,7 +1177,7 @@ JSONParser::handleToken() { QTC::TC("libtests", "JSON parse unexpected }"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": unexpected dictionary end delimiter"); } } else if (delimiter == ']') { @@ -1191,14 +1187,14 @@ JSONParser::handleToken() { QTC::TC("libtests", "JSON parse unexpected ]"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": unexpected array end delimiter"); } } else if (delimiter == ':') { if (parser_state != ps_dict_after_key) { QTC::TC("libtests", "JSON parse unexpected :"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": unexpected colon"); } } else if (delimiter == ',') { @@ -1206,7 +1202,7 @@ JSONParser::handleToken() (parser_state == ps_array_after_item))) { QTC::TC("libtests", "JSON parse unexpected ,"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": unexpected comma"); } } else if (delimiter != '\0') { @@ -1265,7 +1261,7 @@ JSONParser::handleToken() if (tos->checkDictionaryKeySeen(dict_key)) { QTC::TC("libtests", "JSON parse duplicate key"); throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(dict_key_offset) + + "JSON: offset " + std::to_string(dict_key_offset) + ": duplicated dictionary key"); } if (!reactor || !reactor->dictionaryItem(dict_key, *item)) { @@ -1326,7 +1322,7 @@ JSONParser::handleToken() } if (ps_stack.size() > 500) { throw std::runtime_error( - "JSON: offset " + QUtil::int_to_string(offset) + + "JSON: offset " + std::to_string(offset) + ": maximum object depth exceeded"); } parser_state = next_state; diff --git a/libqpdf/JSONHandler.cc b/libqpdf/JSONHandler.cc index 909aa7db..a7503401 100644 --- a/libqpdf/JSONHandler.cc +++ b/libqpdf/JSONHandler.cc @@ -132,7 +132,7 @@ JSONHandler::handle(std::string const& path, JSON j) size_t i = 0; j.forEachArrayItem([&i, &path, this](JSON v) { this->m->h.array_item_handler->handle( - path + "[" + QUtil::uint_to_string(i) + "]", v); + path + "[" + std::to_string(i) + "]", v); ++i; }); this->m->h.array_end_handler(path); diff --git a/libqpdf/NNTree.cc b/libqpdf/NNTree.cc index 94464468..777bd553 100644 --- a/libqpdf/NNTree.cc +++ b/libqpdf/NNTree.cc @@ -10,7 +10,7 @@ get_description(QPDFObjectHandle& node) { std::string result("Name/Number tree node"); if (node.isIndirect()) { - result += " (object " + QUtil::int_to_string(node.getObjectID()) + ")"; + result += " (object " + std::to_string(node.getObjectID()) + ")"; } return result; } @@ -103,7 +103,7 @@ NNTreeIterator::getNextKid(PathElement& pe, bool backward) impl.qpdf, pe.node, ("skipping over invalid kid at index " + - QUtil::int_to_string(pe.kid_number))); + std::to_string(pe.kid_number))); } } else { result = QPDFObjectHandle::newNull(); @@ -159,7 +159,7 @@ NNTreeIterator::increment(bool backward) warn( impl.qpdf, this->node, - ("item " + QUtil::int_to_string(this->item_number) + + ("item " + std::to_string(this->item_number) + " has the wrong type")); } else { found_valid_key = true; @@ -685,8 +685,7 @@ NNTreeIterator::deepen(QPDFObjectHandle node, bool first, bool allow_empty) warn( impl.qpdf, node, - ("converting kid number " + - QUtil::int_to_string(kid_number) + + ("converting kid number " + std::to_string(kid_number) + " to an indirect object")); next = impl.qpdf.makeIndirectObject(next); kids.setArrayItem(kid_number, next); @@ -695,7 +694,7 @@ NNTreeIterator::deepen(QPDFObjectHandle node, bool first, bool allow_empty) warn( impl.qpdf, node, - ("kid number " + QUtil::int_to_string(kid_number) + + ("kid number " + std::to_string(kid_number) + " is not an indirect object")); } } @@ -853,7 +852,7 @@ NNTreeImpl::compareKeyItem( error( qpdf, this->oh, - ("item at index " + QUtil::int_to_string(2 * idx) + + ("item at index " + std::to_string(2 * idx) + " is not the right type")); } return details.compareKeys(key, items.getArrayItem(2 * idx)); @@ -866,10 +865,7 @@ NNTreeImpl::compareKeyKid( if (!(kids.isArray() && (idx < kids.getArrayNItems()) && kids.getArrayItem(idx).isDictionary())) { QTC::TC("qpdf", "NNTree kid is invalid"); - error( - qpdf, - this->oh, - "invalid kid at index " + QUtil::int_to_string(idx)); + error(qpdf, this->oh, "invalid kid at index " + std::to_string(idx)); } return withinLimits(key, kids.getArrayItem(idx)); } diff --git a/libqpdf/PDFVersion.cc b/libqpdf/PDFVersion.cc index e30a3d45..a2b807c6 100644 --- a/libqpdf/PDFVersion.cc +++ b/libqpdf/PDFVersion.cc @@ -48,8 +48,8 @@ void PDFVersion::getVersion(std::string& version, int& extension_level) const { extension_level = this->extension_level; - version = QUtil::int_to_string(this->major_version) + "." + - QUtil::int_to_string(this->minor_version); + version = std::to_string(this->major_version) + "." + + std::to_string(this->minor_version); } int diff --git a/libqpdf/Pipeline.cc b/libqpdf/Pipeline.cc index 6f3f33db..3223ac7e 100644 --- a/libqpdf/Pipeline.cc +++ b/libqpdf/Pipeline.cc @@ -57,56 +57,56 @@ Pipeline::operator<<(std::string const& str) Pipeline& Pipeline::operator<<(short i) { - this->writeString(QUtil::int_to_string(i)); + this->writeString(std::to_string(i)); return *this; } Pipeline& Pipeline::operator<<(int i) { - this->writeString(QUtil::int_to_string(i)); + this->writeString(std::to_string(i)); return *this; } Pipeline& Pipeline::operator<<(long i) { - this->writeString(QUtil::int_to_string(i)); + this->writeString(std::to_string(i)); return *this; } Pipeline& Pipeline::operator<<(long long i) { - this->writeString(QUtil::int_to_string(i)); + this->writeString(std::to_string(i)); return *this; } Pipeline& Pipeline::operator<<(unsigned short i) { - this->writeString(QUtil::uint_to_string(i)); + this->writeString(std::to_string(i)); return *this; } Pipeline& Pipeline::operator<<(unsigned int i) { - this->writeString(QUtil::uint_to_string(i)); + this->writeString(std::to_string(i)); return *this; } Pipeline& Pipeline::operator<<(unsigned long i) { - this->writeString(QUtil::uint_to_string(i)); + this->writeString(std::to_string(i)); return *this; } Pipeline& Pipeline::operator<<(unsigned long long i) { - this->writeString(QUtil::uint_to_string(i)); + this->writeString(std::to_string(i)); return *this; } diff --git a/libqpdf/Pl_AES_PDF.cc b/libqpdf/Pl_AES_PDF.cc index fa42f539..acb6b3f6 100644 --- a/libqpdf/Pl_AES_PDF.cc +++ b/libqpdf/Pl_AES_PDF.cc @@ -53,7 +53,7 @@ Pl_AES_PDF::setIV(unsigned char const* iv, size_t bytes) throw std::logic_error( "Pl_AES_PDF: specified initialization vector" " size in bytes must be " + - QUtil::uint_to_string(bytes)); + std::to_string(bytes)); } this->use_specified_iv = true; memcpy(this->specified_iv, iv, bytes); diff --git a/libqpdf/Pl_DCT.cc b/libqpdf/Pl_DCT.cc index 9c33b6e1..f7cc4b75 100644 --- a/libqpdf/Pl_DCT.cc +++ b/libqpdf/Pl_DCT.cc @@ -302,9 +302,8 @@ Pl_DCT::compress(void* cinfo_p, Buffer* b) QIntC::to_size(cinfo->input_components); if (b->getSize() != expected_size) { throw std::runtime_error( - "Pl_DCT: image buffer size = " + - QUtil::uint_to_string(b->getSize()) + - "; expected size = " + QUtil::uint_to_string(expected_size)); + "Pl_DCT: image buffer size = " + std::to_string(b->getSize()) + + "; expected size = " + std::to_string(expected_size)); } JSAMPROW row_pointer[1]; unsigned char* buffer = b->getBuffer(); diff --git a/libqpdf/Pl_Flate.cc b/libqpdf/Pl_Flate.cc index 7f2fa4a6..61873ffa 100644 --- a/libqpdf/Pl_Flate.cc +++ b/libqpdf/Pl_Flate.cc @@ -286,7 +286,7 @@ Pl_Flate::checkError(char const* prefix, int error_code) default: msg += std::string("zlib unknown error (") + - QUtil::int_to_string(error_code) + ")"; + std::to_string(error_code) + ")"; break; } } diff --git a/libqpdf/Pl_Function.cc b/libqpdf/Pl_Function.cc index 5f2dc042..853b4212 100644 --- a/libqpdf/Pl_Function.cc +++ b/libqpdf/Pl_Function.cc @@ -25,7 +25,7 @@ Pl_Function::Pl_Function( if (code != 0) { throw std::runtime_error( std::string(identifier) + " function returned code " + - QUtil::int_to_string(code)); + std::to_string(code)); } }; } @@ -40,7 +40,7 @@ Pl_Function::Pl_Function( if (code != 0) { throw std::runtime_error( std::string(identifier) + " function returned code " + - QUtil::int_to_string(code)); + std::to_string(code)); } }; } diff --git a/libqpdf/Pl_LZWDecoder.cc b/libqpdf/Pl_LZWDecoder.cc index 7d02f291..000fb64b 100644 --- a/libqpdf/Pl_LZWDecoder.cc +++ b/libqpdf/Pl_LZWDecoder.cc @@ -98,7 +98,7 @@ Pl_LZWDecoder::getFirstChar(unsigned int code) } else { throw std::runtime_error( "Pl_LZWDecoder::getFirstChar called with invalid code (" + - QUtil::int_to_string(code) + ")"); + std::to_string(code) + ")"); } return result; } @@ -126,7 +126,7 @@ Pl_LZWDecoder::addToTable(unsigned char next) } else { throw std::runtime_error( "Pl_LZWDecoder::addToTable called with invalid code (" + - QUtil::int_to_string(this->last_code) + ")"); + std::to_string(this->last_code) + ")"); } Buffer entry(1 + last_size); diff --git a/libqpdf/Pl_QPDFTokenizer.cc b/libqpdf/Pl_QPDFTokenizer.cc index 9082538d..135d8318 100644 --- a/libqpdf/Pl_QPDFTokenizer.cc +++ b/libqpdf/Pl_QPDFTokenizer.cc @@ -49,7 +49,7 @@ Pl_QPDFTokenizer::finish() while (true) { QPDFTokenizer::Token token = this->m->tokenizer.readToken( - input, "offset " + QUtil::int_to_string(input->tell()), true); + input, "offset " + std::to_string(input->tell()), true); this->m->filter->handleToken(token); if (token.getType() == QPDFTokenizer::tt_eof) { break; diff --git a/libqpdf/QPDF.cc b/libqpdf/QPDF.cc index dd6037c1..91006f13 100644 --- a/libqpdf/QPDF.cc +++ b/libqpdf/QPDF.cc @@ -773,9 +773,9 @@ QPDF::read_xref(qpdf_offset_t xref_offset) "", 0, (std::string("reported number of objects (") + - QUtil::int_to_string(size) + + std::to_string(size) + ") is not one plus the highest object number (" + - QUtil::int_to_string(max_obj) + ")")); + std::to_string(max_obj) + ")")); } // We no longer need the deleted_objects table, so go ahead and @@ -954,7 +954,7 @@ QPDF::read_xrefTable(qpdf_offset_t xref_offset) this->m->file->getName(), "xref table", this->m->file->getLastOffset(), - "invalid xref entry (obj=" + QUtil::int_to_string(i) + ")"); + "invalid xref entry (obj=" + std::to_string(i) + ")"); } if (type == 'f') { // Save deleted items until after we've checked the @@ -1160,7 +1160,7 @@ QPDF::processXRefStream(qpdf_offset_t xref_offset, QPDFObjectHandle& xref_obj) "xref stream", xref_offset, ("Cross-reference stream's /Index's item " + - QUtil::int_to_string(i) + " is not an integer")); + std::to_string(i) + " is not an integer")); } } QTC::TC("qpdf", "QPDF xref /Index is array", n_index == 2 ? 0 : 1); @@ -1181,9 +1181,9 @@ QPDF::processXRefStream(qpdf_offset_t xref_offset, QPDFObjectHandle& xref_obj) xref_offset, ("Cross-reference stream claims to contain" " too many entries: " + - QUtil::int_to_string(indx.at(i)) + " " + - QUtil::uint_to_string(max_num_entries) + " " + - QUtil::uint_to_string(num_entries))); + std::to_string(indx.at(i)) + " " + + std::to_string(max_num_entries) + " " + + std::to_string(num_entries))); } num_entries += toS(indx.at(i)); } @@ -1203,8 +1203,8 @@ QPDF::processXRefStream(qpdf_offset_t xref_offset, QPDFObjectHandle& xref_obj) xref_offset, ("Cross-reference stream data has the wrong size;" " expected = " + - QUtil::uint_to_string(expected_size) + - "; actual = " + QUtil::uint_to_string(actual_size))); + std::to_string(expected_size) + + "; actual = " + std::to_string(actual_size))); if (expected_size > actual_size) { throw x; } else { @@ -1356,7 +1356,7 @@ QPDF::insertXrefEntry(int obj, int f0, qpdf_offset_t f1, int f2, bool overwrite) this->m->file->getName(), "xref stream", this->m->file->getLastOffset(), - "unknown xref stream entry type " + QUtil::int_to_string(f0)); + "unknown xref stream entry type " + std::to_string(f0)); break; } } @@ -1747,7 +1747,7 @@ QPDF::recoverStreamLength( input->getName(), this->m->last_object_description, stream_offset, - "recovered stream length: " + QUtil::uint_to_string(length))); + "recovered stream length: " + std::to_string(length))); } QTC::TC("qpdf", "QPDF recovered stream length"); @@ -2026,8 +2026,8 @@ QPDF::resolveObjectsInStream(int obj_stream_number) this->m->file->getName(), this->m->last_object_description, this->m->file->getLastOffset(), - ("supposed object stream " + - QUtil::int_to_string(obj_stream_number) + " is not a stream")); + ("supposed object stream " + std::to_string(obj_stream_number) + + " is not a stream")); } // For linearization data in the object, use the data from the @@ -2045,8 +2045,8 @@ QPDF::resolveObjectsInStream(int obj_stream_number) qpdf_e_damaged_pdf, this->m->last_object_description, this->m->file->getLastOffset(), - ("supposed object stream " + - QUtil::int_to_string(obj_stream_number) + " has wrong type")); + ("supposed object stream " + std::to_string(obj_stream_number) + + " has wrong type")); } if (!(dict.getKey("/N").isInteger() && dict.getKey("/First").isInteger())) { @@ -2055,7 +2055,7 @@ QPDF::resolveObjectsInStream(int obj_stream_number) this->m->file->getName(), this->m->last_object_description, this->m->file->getLastOffset(), - ("object stream " + QUtil::int_to_string(obj_stream_number) + + ("object stream " + std::to_string(obj_stream_number) + " has incorrect keys")); } @@ -2069,7 +2069,7 @@ QPDF::resolveObjectsInStream(int obj_stream_number) // line-break new BufferInputSource( (this->m->file->getName() + " object stream " + - QUtil::int_to_string(obj_stream_number)), + std::to_string(obj_stream_number)), bp.get())); for (int i = 0; i < n; ++i) { diff --git a/libqpdf/QPDFAcroFormDocumentHelper.cc b/libqpdf/QPDFAcroFormDocumentHelper.cc index 6fec0587..70e1b9c9 100644 --- a/libqpdf/QPDFAcroFormDocumentHelper.cc +++ b/libqpdf/QPDFAcroFormDocumentHelper.cc @@ -104,7 +104,7 @@ QPDFAcroFormDocumentHelper::addAndRenameFormFields( std::string append; while (!getFieldsWithQualifiedName(new_name).empty()) { ++suffix; - append = "+" + QUtil::int_to_string(suffix); + append = "+" + std::to_string(suffix); new_name = old_name + append; } renames[old_name] = append; diff --git a/libqpdf/QPDFCrypto_gnutls.cc b/libqpdf/QPDFCrypto_gnutls.cc index dabf912d..d9d14bee 100644 --- a/libqpdf/QPDFCrypto_gnutls.cc +++ b/libqpdf/QPDFCrypto_gnutls.cc @@ -135,7 +135,7 @@ QPDFCrypto_gnutls::SHA2_init(int bits) if (code < 0) { this->hash_ctx = nullptr; throw std::runtime_error( - std::string("gnutls: SHA") + QUtil::int_to_string(bits) + + std::string("gnutls: SHA") + std::to_string(bits) + " error: " + std::string(gnutls_strerror(code))); } } diff --git a/libqpdf/QPDFExc.cc b/libqpdf/QPDFExc.cc index 6c270c82..6f1ef1a0 100644 --- a/libqpdf/QPDFExc.cc +++ b/libqpdf/QPDFExc.cc @@ -39,7 +39,7 @@ QPDFExc::createWhat( } } if (offset > 0) { - result += "offset " + QUtil::int_to_string(offset); + result += "offset " + std::to_string(offset); } if (!filename.empty()) { result += ")"; diff --git a/libqpdf/QPDFJob.cc b/libqpdf/QPDFJob.cc index 384af854..e34cfc53 100644 --- a/libqpdf/QPDFJob.cc +++ b/libqpdf/QPDFJob.cc @@ -2472,7 +2472,7 @@ QPDFJob::handleTransformations(QPDF& pdf) std::shared_ptr<QPDFObjectHandle::StreamDataProvider> sdp(io); if (io->evaluate( "image " + name + " on page " + - QUtil::int_to_string(pageno))) { + std::to_string(pageno))) { QPDFObjectHandle new_image = QPDFObjectHandle::newStream(&pdf); new_image.replaceDict(image.getDict().shallowCopy()); @@ -3318,7 +3318,7 @@ QPDFJob::doSplitPages(QPDF& pdf, bool& warnings) QPDFPageLabelDocumentHelper pldh(pdf); QPDFAcroFormDocumentHelper afdh(pdf); std::vector<QPDFObjectHandle> const& pages = pdf.getAllPages(); - size_t pageno_len = QUtil::uint_to_string(pages.size()).length(); + size_t pageno_len = std::to_string(pages.size()).length(); size_t num_pages = pages.size(); for (size_t i = 0; i < num_pages; i += QIntC::to_size(m->split_pages)) { size_t first = i + 1; diff --git a/libqpdf/QPDFObjGen.cc b/libqpdf/QPDFObjGen.cc index e372555d..7cce84d8 100644 --- a/libqpdf/QPDFObjGen.cc +++ b/libqpdf/QPDFObjGen.cc @@ -12,6 +12,5 @@ operator<<(std::ostream& os, const QPDFObjGen& og) std::string QPDFObjGen::unparse(char separator) const { - return QUtil::int_to_string(this->obj) + separator + - QUtil::int_to_string(this->gen); + return std::to_string(this->obj) + separator + std::to_string(this->gen); } diff --git a/libqpdf/QPDFObjectHandle.cc b/libqpdf/QPDFObjectHandle.cc index c52ac2fc..fe37813c 100644 --- a/libqpdf/QPDFObjectHandle.cc +++ b/libqpdf/QPDFObjectHandle.cc @@ -1257,7 +1257,7 @@ QPDFObjectHandle::getUniqueResourceName( std::set<std::string> names = (namesp ? *namesp : getResourceNames()); int max_suffix = min_suffix + QIntC::to_int(names.size()); while (min_suffix <= max_suffix) { - std::string candidate = prefix + QUtil::int_to_string(min_suffix); + std::string candidate = prefix + std::to_string(min_suffix); if (names.count(candidate) == 0) { return candidate; } @@ -1554,8 +1554,8 @@ QPDFObjectHandle::arrayOrStreamToStreamArray( QPDFExc( qpdf_e_damaged_pdf, "", - description + ": item index " + - QUtil::int_to_string(i) + " (from 0)", + description + ": item index " + std::to_string(i) + + " (from 0)", 0, "ignoring non-stream in an array of streams")); } diff --git a/libqpdf/QPDFParser.cc b/libqpdf/QPDFParser.cc index 9aa1f426..452e741b 100644 --- a/libqpdf/QPDFParser.cc +++ b/libqpdf/QPDFParser.cc @@ -335,8 +335,8 @@ QPDFParser::parse(bool& empty, bool content_stream) bool found_fake = false; std::string candidate; while (!found_fake) { - candidate = "/QPDFFake" + - QUtil::int_to_string(next_fake_key++); + candidate = + "/QPDFFake" + std::to_string(next_fake_key++); found_fake = (names.count(candidate) == 0); QTC::TC( "qpdf", @@ -416,7 +416,7 @@ QPDFParser::setDescriptionFromInput( oh.setObjectDescription( context, (input->getName() + ", " + object_description + " at offset " + - QUtil::int_to_string(offset))); + std::to_string(offset))); } void diff --git a/libqpdf/QPDFWriter.cc b/libqpdf/QPDFWriter.cc index aad536b0..b29f75b9 100644 --- a/libqpdf/QPDFWriter.cc +++ b/libqpdf/QPDFWriter.cc @@ -842,8 +842,7 @@ QPDFWriter::parseVersion( if ((p != std::string::npos) && (version.length() > p)) { minor = QUtil::string_to_int(version.substr(p + 1).c_str()); } - std::string tmp = - QUtil::int_to_string(major) + "." + QUtil::int_to_string(minor); + std::string tmp = std::to_string(major) + "." + std::to_string(minor); if (tmp != version) { // The version number in the input is probably invalid. This // happens with some files that are designed to exercise bugs, @@ -888,11 +887,10 @@ QPDFWriter::setEncryptionParametersInternal( this->m->encryption_V = V; this->m->encryption_R = R; this->m->encryption_dictionary["/Filter"] = "/Standard"; - this->m->encryption_dictionary["/V"] = QUtil::int_to_string(V); - this->m->encryption_dictionary["/Length"] = - QUtil::int_to_string(key_len * 8); - this->m->encryption_dictionary["/R"] = QUtil::int_to_string(R); - this->m->encryption_dictionary["/P"] = QUtil::int_to_string(P); + this->m->encryption_dictionary["/V"] = std::to_string(V); + this->m->encryption_dictionary["/Length"] = std::to_string(key_len * 8); + this->m->encryption_dictionary["/R"] = std::to_string(R); + this->m->encryption_dictionary["/P"] = std::to_string(P); this->m->encryption_dictionary["/O"] = QPDF_String(O).unparse(true); this->m->encryption_dictionary["/U"] = QPDF_String(U).unparse(true); if (V >= 5) { @@ -1037,8 +1035,7 @@ QPDFWriter::initializePipelineStack(Pipeline* p) void QPDFWriter::activatePipelineStack(PipelinePopper& pp) { - std::string stack_id( - "stack " + QUtil::uint_to_string(this->m->next_stack_id)); + std::string stack_id("stack " + std::to_string(this->m->next_stack_id)); Pl_Count* c = new Pl_Count(stack_id.c_str(), this->m->pipeline_stack.back()); ++this->m->next_stack_id; @@ -1161,7 +1158,7 @@ QPDFWriter::openObject(int objid) objid = this->m->next_objid++; } this->m->xref[objid] = QPDFXRefEntry(1, this->m->pipeline->getCount(), 0); - writeString(QUtil::int_to_string(objid)); + writeString(std::to_string(objid)); writeString(" 0 obj\n"); return objid; } @@ -1286,7 +1283,7 @@ QPDFWriter::unparseChild(QPDFObjectHandle child, int level, int flags) if (child.isIndirect()) { QPDFObjGen old_og = child.getObjGen(); int new_id = this->m->obj_renumber[old_og]; - writeString(QUtil::int_to_string(new_id)); + writeString(std::to_string(new_id)); writeString(" 0 R"); } else { unparseObject(child, level, flags); @@ -1310,7 +1307,7 @@ QPDFWriter::writeTrailer( writeStringQDF("\n"); if (which == t_lin_second) { writeString(" /Size "); - writeString(QUtil::int_to_string(size)); + writeString(std::to_string(size)); } else { for (auto const& key: trailer.getKeys()) { writeStringQDF(" "); @@ -1318,11 +1315,11 @@ QPDFWriter::writeTrailer( writeString(QPDF_Name::normalizeName(key)); writeString(" "); if (key == "/Size") { - writeString(QUtil::int_to_string(size)); + writeString(std::to_string(size)); if (which == t_lin_first) { writeString(" /Prev "); qpdf_offset_t pos = this->m->pipeline->getCount(); - writeString(QUtil::int_to_string(prev)); + writeString(std::to_string(prev)); int nspaces = QIntC::to_int(pos - this->m->pipeline->getCount() + 21); if (nspaces < 0) { @@ -1374,7 +1371,7 @@ QPDFWriter::writeTrailer( // Write reference to encryption dictionary if (this->m->encrypted) { writeString(" /Encrypt "); - writeString(QUtil::int_to_string(this->m->encryption_dict_objid)); + writeString(std::to_string(this->m->encryption_dict_objid)); writeString(" 0 R"); } } @@ -1607,8 +1604,7 @@ QPDFWriter::unparseObject( QPDFObjectHandle::parse( "<< /BaseVersion /" + this->m->final_pdf_version + " /ExtensionLevel " + - QUtil::int_to_string( - this->m->final_extension_level) + + std::to_string(this->m->final_extension_level) + " >>")); } else { QTC::TC("qpdf", "QPDFWriter remove ADBE"); @@ -1697,10 +1693,9 @@ QPDFWriter::unparseObject( writeString(" /Length "); if (this->m->direct_stream_lengths) { - writeString(QUtil::uint_to_string(stream_length)); + writeString(std::to_string(stream_length)); } else { - writeString( - QUtil::int_to_string(this->m->cur_stream_length_id)); + writeString(std::to_string(this->m->cur_stream_length_id)); writeString(" 0 R"); } writeStringQDF("\n"); @@ -1808,9 +1803,9 @@ QPDFWriter::writeObjectStreamOffsets( writeStringQDF("\n"); writeStringNoQDF(" "); } - writeString(QUtil::uint_to_string(i + QIntC::to_size(first_obj))); + writeString(std::to_string(i + QIntC::to_size(first_obj))); writeString(" "); - writeString(QUtil::int_to_string(offsets.at(i))); + writeString(std::to_string(offsets.at(i))); } writeString("\n"); } @@ -1877,13 +1872,12 @@ QPDFWriter::writeObjectStream(QPDFObjectHandle object) } if (this->m->qdf_mode) { writeString( - "%% Object stream: object " + - QUtil::int_to_string(new_obj) + ", index " + - QUtil::int_to_string(count)); + "%% Object stream: object " + std::to_string(new_obj) + + ", index " + std::to_string(count)); if (!this->m->suppress_original_object_ids) { writeString( "; original object ID: " + - QUtil::int_to_string(obj.getObj())); + std::to_string(obj.getObj())); // For compatibility, only write the generation if // non-zero. While object streams only allow // objects with generation 0, if we are generating @@ -1891,7 +1885,7 @@ QPDFWriter::writeObjectStream(QPDFObjectHandle object) // non-zero generation. if (obj.getGen() != 0) { QTC::TC("qpdf", "QPDFWriter original obj non-zero gen"); - writeString(" " + QUtil::int_to_string(obj.getGen())); + writeString(" " + std::to_string(obj.getGen())); } } writeString("\n"); @@ -1928,14 +1922,14 @@ QPDFWriter::writeObjectStream(QPDFObjectHandle object) writeStringQDF("\n "); size_t length = stream_buffer->getSize(); adjustAESStreamLength(length); - writeString(" /Length " + QUtil::uint_to_string(length)); + writeString(" /Length " + std::to_string(length)); writeStringQDF("\n "); if (compressed) { writeString(" /Filter /FlateDecode"); } - writeString(" /N " + QUtil::uint_to_string(offsets.size())); + writeString(" /N " + std::to_string(offsets.size())); writeStringQDF("\n "); - writeString(" /First " + QUtil::int_to_string(first)); + writeString(" /First " + std::to_string(first)); if (!object.isNull()) { // If the original object has an /Extends key, preserve it. QPDFObjectHandle dict = object.getDict(); @@ -1982,14 +1976,12 @@ QPDFWriter::writeObject(QPDFObjectHandle object, int object_stream_index) if (this->m->qdf_mode) { if (this->m->page_object_to_seq.count(old_og)) { writeString("%% Page "); - writeString( - QUtil::int_to_string(this->m->page_object_to_seq[old_og])); + writeString(std::to_string(this->m->page_object_to_seq[old_og])); writeString("\n"); } if (this->m->contents_to_page_seq.count(old_og)) { writeString("%% Contents for page "); - writeString( - QUtil::int_to_string(this->m->contents_to_page_seq[old_og])); + writeString(std::to_string(this->m->contents_to_page_seq[old_og])); writeString("\n"); } } @@ -2016,7 +2008,7 @@ QPDFWriter::writeObject(QPDFObjectHandle object, int object_stream_index) } } openObject(new_id + 1); - writeString(QUtil::uint_to_string(this->m->cur_stream_length)); + writeString(std::to_string(this->m->cur_stream_length)); closeObject(new_id + 1); } } @@ -2093,7 +2085,7 @@ QPDFWriter::generateID() } seed += this->m->deterministic_id_data; } else { - seed += QUtil::int_to_string(QUtil::get_current_time()); + seed += std::to_string(QUtil::get_current_time()); seed += this->m->filename; seed += " "; } @@ -2562,14 +2554,14 @@ QPDFWriter::writeHintStream(int hint_id) size_t hlen = hint_buffer->getSize(); writeString("<< /Filter /FlateDecode /S "); - writeString(QUtil::int_to_string(S)); + writeString(std::to_string(S)); if (O) { writeString(" /O "); - writeString(QUtil::int_to_string(O)); + writeString(std::to_string(O)); } writeString(" /Length "); adjustAESStreamLength(hlen); - writeString(QUtil::uint_to_string(hlen)); + writeString(std::to_string(hlen)); writeString(" >>\nstream\n"); if (this->m->encrypted) { @@ -2613,9 +2605,9 @@ QPDFWriter::writeXRefTable( int linearization_pass) { writeString("xref\n"); - writeString(QUtil::int_to_string(first)); + writeString(std::to_string(first)); writeString(" "); - writeString(QUtil::int_to_string(last - first + 1)); + writeString(std::to_string(last - first + 1)); qpdf_offset_t space_before_zero = this->m->pipeline->getCount(); writeString("\n"); for (int i = first; i <= last; ++i) { @@ -2762,23 +2754,23 @@ QPDFWriter::writeXRefStream( writeStringQDF("\n "); writeString(" /Type /XRef"); writeStringQDF("\n "); - writeString(" /Length " + QUtil::uint_to_string(xref_data->getSize())); + writeString(" /Length " + std::to_string(xref_data->getSize())); if (compressed) { writeStringQDF("\n "); writeString(" /Filter /FlateDecode"); writeStringQDF("\n "); writeString( - " /DecodeParms << /Columns " + QUtil::int_to_string(esize) + + " /DecodeParms << /Columns " + std::to_string(esize) + " /Predictor 12 >>"); } writeStringQDF("\n "); writeString( - " /W [ 1 " + QUtil::int_to_string(f1_size) + " " + - QUtil::int_to_string(f2_size) + " ]"); + " /W [ 1 " + std::to_string(f1_size) + " " + std::to_string(f2_size) + + " ]"); if (!((first == 0) && (last == size - 1))) { writeString( - " /Index [ " + QUtil::int_to_string(first) + " " + - QUtil::int_to_string(last - first + 1) + " ]"); + " /Index [ " + std::to_string(first) + " " + + std::to_string(last - first + 1) + " ]"); } writeTrailer(which, size, true, prev, linearization_pass); writeString("\nstream\n"); @@ -3015,22 +3007,21 @@ QPDFWriter::writeLinearized() int npages = QIntC::to_int(pages.size()); writeString(" /Linearized 1 /L "); - writeString(QUtil::int_to_string(file_size + hint_length)); + writeString(std::to_string(file_size + hint_length)); // Implementation note 121 states that a space is // mandatory after this open bracket. writeString(" /H [ "); - writeString( - QUtil::int_to_string(this->m->xref[hint_id].getOffset())); + writeString(std::to_string(this->m->xref[hint_id].getOffset())); writeString(" "); - writeString(QUtil::int_to_string(hint_length)); + writeString(std::to_string(hint_length)); writeString(" ] /O "); - writeString(QUtil::int_to_string(first_page_object)); + writeString(std::to_string(first_page_object)); writeString(" /E "); - writeString(QUtil::int_to_string(part6_end_offset + hint_length)); + writeString(std::to_string(part6_end_offset + hint_length)); writeString(" /N "); - writeString(QUtil::int_to_string(npages)); + writeString(std::to_string(npages)); writeString(" /T "); - writeString(QUtil::int_to_string(space_before_zero + hint_length)); + writeString(std::to_string(space_before_zero + hint_length)); } writeString(" >>"); closeObject(lindict_id); @@ -3094,8 +3085,8 @@ QPDFWriter::writeLinearized() throw std::logic_error( "insufficient padding for first pass xref stream; " "first_xref_end=" + - QUtil::int_to_string(first_xref_end) + - "; endpos=" + QUtil::int_to_string(endpos)); + std::to_string(first_xref_end) + + "; endpos=" + std::to_string(endpos)); } } writeString("\n"); @@ -3197,7 +3188,7 @@ QPDFWriter::writeLinearized() pass); } writeString("startxref\n"); - writeString(QUtil::int_to_string(first_xref_offset)); + writeString(std::to_string(first_xref_offset)); writeString("\n%%EOF\n"); discardGeneration(this->m->obj_renumber, this->m->obj_renumber_no_gen); @@ -3237,19 +3228,19 @@ QPDFWriter::writeLinearized() fprintf( lin_pass1_file, "%% hint_offset=%s\n", - QUtil::int_to_string(hint_offset1).c_str()); + std::to_string(hint_offset1).c_str()); fprintf( lin_pass1_file, "%% hint_length=%s\n", - QUtil::int_to_string(hint_length).c_str()); + std::to_string(hint_length).c_str()); fprintf( lin_pass1_file, "%% second_xref_offset=%s\n", - QUtil::int_to_string(second_xref_offset).c_str()); + std::to_string(second_xref_offset).c_str()); fprintf( lin_pass1_file, "%% second_xref_end=%s\n", - QUtil::int_to_string(second_xref_end).c_str()); + std::to_string(second_xref_end).c_str()); fclose(lin_pass1_file); lin_pass1_file = nullptr; } @@ -3399,7 +3390,7 @@ QPDFWriter::writeStandard() this->m->next_objid); } writeString("startxref\n"); - writeString(QUtil::int_to_string(xref_offset)); + writeString(std::to_string(xref_offset)); writeString("\n%%EOF\n"); if (this->m->deterministic_id) { diff --git a/libqpdf/QPDFXRefEntry.cc b/libqpdf/QPDFXRefEntry.cc index 8c8ada5e..3137ab53 100644 --- a/libqpdf/QPDFXRefEntry.cc +++ b/libqpdf/QPDFXRefEntry.cc @@ -17,8 +17,7 @@ QPDFXRefEntry::QPDFXRefEntry(int type, qpdf_offset_t field1, int field2) : field2(field2) { if ((type < 1) || (type > 2)) { - throw std::logic_error( - "invalid xref type " + QUtil::int_to_string(type)); + throw std::logic_error("invalid xref type " + std::to_string(type)); } } diff --git a/libqpdf/QPDF_Integer.cc b/libqpdf/QPDF_Integer.cc index 24812573..2bcdfef1 100644 --- a/libqpdf/QPDF_Integer.cc +++ b/libqpdf/QPDF_Integer.cc @@ -23,7 +23,7 @@ QPDF_Integer::shallowCopy() std::string QPDF_Integer::unparse() { - return QUtil::int_to_string(this->val); + return std::to_string(this->val); } JSON diff --git a/libqpdf/QPDF_Stream.cc b/libqpdf/QPDF_Stream.cc index e2878904..3f2e2d35 100644 --- a/libqpdf/QPDF_Stream.cc +++ b/libqpdf/QPDF_Stream.cc @@ -618,9 +618,9 @@ QPDF_Stream::pipeStreamData( // part of a library user, not by invalid input data. throw std::runtime_error( "stream data provider for " + og.unparse(' ') + - " provided " + QUtil::int_to_string(actual_length) + + " provided " + std::to_string(actual_length) + " bytes instead of expected " + - QUtil::int_to_string(desired_length) + " bytes"); + std::to_string(desired_length) + " bytes"); } } else if (success) { QTC::TC("qpdf", "QPDF_Stream provider length not provided"); diff --git a/libqpdf/QPDF_encryption.cc b/libqpdf/QPDF_encryption.cc index 266907a8..21cb66f2 100644 --- a/libqpdf/QPDF_encryption.cc +++ b/libqpdf/QPDF_encryption.cc @@ -869,8 +869,8 @@ QPDF::initializeEncryption() "encryption dictionary", this->m->file->getLastOffset(), "Unsupported /R or /V in encryption dictionary; R = " + - QUtil::int_to_string(R) + - " (max 6), V = " + QUtil::int_to_string(V) + " (max 5)"); + std::to_string(R) + " (max 6), V = " + std::to_string(V) + + " (max 5)"); } this->m->encp->encryption_V = V; diff --git a/libqpdf/QPDF_json.cc b/libqpdf/QPDF_json.cc index 131e7dee..02dc57e8 100644 --- a/libqpdf/QPDF_json.cc +++ b/libqpdf/QPDF_json.cc @@ -641,7 +641,7 @@ QPDF::JSONReactor::dictionaryItem(std::string const& key, JSON const& value) } } else { throw std::logic_error( - "QPDF_json: unknown state " + QUtil::int_to_string(state)); + "QPDF_json: unknown state " + std::to_string(state)); } return true; } @@ -679,7 +679,7 @@ QPDF::JSONReactor::setObjectDescription(QPDFObjectHandle& oh, JSON const& value) if (!this->cur_object.empty()) { description += ", " + this->cur_object; } - description += " at offset " + QUtil::int_to_string(value.getStart()); + description += " at offset " + std::to_string(value.getStart()); oh.setObjectDescription(&this->pdf, description); } @@ -790,7 +790,7 @@ QPDF::writeJSONStream( std::shared_ptr<Pl_StdioFile> f_pl; std::string filename; if (json_stream_data == qpdf_sj_file) { - filename = file_prefix + "-" + QUtil::int_to_string(obj.getObjectID()); + filename = file_prefix + "-" + std::to_string(obj.getObjectID()); f = QUtil::safe_fopen(filename.c_str(), "wb"); f_pl = std::make_shared<Pl_StdioFile>("stream data", f); stream_p = f_pl.get(); diff --git a/libqpdf/QPDF_linearization.cc b/libqpdf/QPDF_linearization.cc index e09f7b68..dc428c3a 100644 --- a/libqpdf/QPDF_linearization.cc +++ b/libqpdf/QPDF_linearization.cc @@ -534,7 +534,7 @@ QPDF::checkLinearizationInternal() QPDFObjGen og(page.getObjGen()); if (this->m->xref_table[og].getType() == 2) { errors.push_back( - "page dictionary for page " + QUtil::uint_to_string(i) + + "page dictionary for page " + std::to_string(i) + " is compressed"); } } @@ -554,8 +554,8 @@ QPDF::checkLinearizationInternal() errors.push_back( "space before first xref item (/T) mismatch " "(computed = " + - QUtil::int_to_string(this->m->first_xref_item_offset) + - "; file = " + QUtil::int_to_string(this->m->file->tell())); + std::to_string(this->m->first_xref_item_offset) + + "; file = " + std::to_string(this->m->file->tell())); } // P: first page number -- Implementation note 124 says Acrobat @@ -619,8 +619,8 @@ QPDF::checkLinearizationInternal() QTC::TC("qpdf", "QPDF warn /E mismatch"); warnings.push_back( "end of first page section (/E) mismatch: /E = " + - QUtil::int_to_string(p.first_page_end) + "; computed = " + - QUtil::int_to_string(min_E) + ".." + QUtil::int_to_string(max_E)); + std::to_string(p.first_page_end) + "; computed = " + + std::to_string(min_E) + ".." + std::to_string(max_E)); } // Check hint tables @@ -717,8 +717,8 @@ QPDF::lengthNextN(int first_object, int n, std::list<std::string>& errors) QPDFObjGen og(first_object + i, 0); if (this->m->xref_table.count(og) == 0) { errors.push_back( - "no xref table entry for " + - QUtil::int_to_string(first_object + i) + " 0"); + "no xref table entry for " + std::to_string(first_object + i) + + " 0"); } else { if (this->m->obj_cache.count(og) == 0) { stopOnError("found unknown object while" @@ -785,10 +785,9 @@ QPDF::checkHPageOffset( if (h_nobjects != ce.nobjects) { // This happens with pdlin when there are thumbnails. warnings.push_back( - "object count mismatch for page " + - QUtil::int_to_string(pageno) + - ": hint table = " + QUtil::int_to_string(h_nobjects) + - "; computed = " + QUtil::int_to_string(ce.nobjects)); + "object count mismatch for page " + std::to_string(pageno) + + ": hint table = " + std::to_string(h_nobjects) + + "; computed = " + std::to_string(ce.nobjects)); } // Use value for number of objects in hint table rather than @@ -800,11 +799,10 @@ QPDF::checkHPageOffset( // This condition almost certainly indicates a bad hint // table or a bug in this code. errors.push_back( - "page length mismatch for page " + - QUtil::int_to_string(pageno) + - ": hint table = " + QUtil::int_to_string(h_length) + - "; computed length = " + QUtil::int_to_string(length) + - " (offset = " + QUtil::int_to_string(offset) + ")"); + "page length mismatch for page " + std::to_string(pageno) + + ": hint table = " + std::to_string(h_length) + + "; computed length = " + std::to_string(length) + + " (offset = " + std::to_string(offset) + ")"); } offset += h_length; @@ -841,8 +839,8 @@ QPDF::checkHPageOffset( if (!computed_shared.count(iter)) { // pdlin puts thumbnails here even though it shouldn't warnings.push_back( - "page " + QUtil::int_to_string(pageno) + - ": shared object " + QUtil::int_to_string(iter) + + "page " + std::to_string(pageno) + ": shared object " + + std::to_string(iter) + ": in hint table but not computed list"); } } @@ -853,8 +851,8 @@ QPDF::checkHPageOffset( // built-in fonts and procsets here, at least in some // cases. warnings.push_back( - "page " + QUtil::int_to_string(pageno) + - ": shared object " + QUtil::int_to_string(iter) + + "page " + std::to_string(pageno) + ": shared object " + + std::to_string(iter) + ": in computed list but not hint table"); } } @@ -906,8 +904,8 @@ QPDF::checkHSharedObject( errors.push_back( "first shared object number mismatch: " "hint table = " + - QUtil::int_to_string(so.first_shared_obj) + - "; computed = " + QUtil::int_to_string(obj)); + std::to_string(so.first_shared_obj) + + "; computed = " + std::to_string(obj)); } } @@ -923,8 +921,8 @@ QPDF::checkHSharedObject( if (offset != h_offset) { errors.push_back( "first shared object offset mismatch: hint table = " + - QUtil::int_to_string(h_offset) + - "; computed = " + QUtil::int_to_string(offset)); + std::to_string(h_offset) + + "; computed = " + std::to_string(offset)); } } @@ -935,10 +933,10 @@ QPDF::checkHSharedObject( int h_length = so.min_group_length + se.delta_group_length; if (length != h_length) { errors.push_back( - "shared object " + QUtil::int_to_string(i) + + "shared object " + std::to_string(i) + " length mismatch: hint table = " + - QUtil::int_to_string(h_length) + - "; computed = " + QUtil::int_to_string(length)); + std::to_string(h_length) + + "; computed = " + std::to_string(length)); } cur_object += nobjects; } @@ -985,15 +983,15 @@ QPDF::checkHOutlines(std::list<std::string>& warnings) if (offset != table_offset) { warnings.push_back( "incorrect offset in outlines table: hint table = " + - QUtil::int_to_string(table_offset) + - "; computed = " + QUtil::int_to_string(offset)); + std::to_string(table_offset) + + "; computed = " + std::to_string(offset)); } int table_length = this->m->outline_hints.group_length; if (length != table_length) { warnings.push_back( "incorrect length in outlines table: hint table = " + - QUtil::int_to_string(table_length) + - "; computed = " + QUtil::int_to_string(length)); + std::to_string(table_length) + + "; computed = " + std::to_string(length)); } } else { warnings.push_back("incorrect first object number in outline " @@ -1443,7 +1441,7 @@ QPDF::calculateLinearizationData(std::map<int, int> const& object_stream_data) stopOnError( "INTERNAL ERROR: " "QPDF::calculateLinearizationData: page object for page " + - QUtil::uint_to_string(i) + " not in lc_other_page_private"); + std::to_string(i) + " not in lc_other_page_private"); } lc_other_page_private.erase(page_og); this->m->part7.push_back(pages.at(i)); @@ -1565,8 +1563,8 @@ QPDF::calculateLinearizationData(std::map<int, int> const& object_stream_data) stopOnError( "INTERNAL ERROR: QPDF::calculateLinearizationData: wrong " "number of objects placed (num_placed = " + - QUtil::uint_to_string(num_placed) + - "; number of objects: " + QUtil::uint_to_string(num_wanted)); + std::to_string(num_placed) + + "; number of objects: " + std::to_string(num_wanted)); } // Calculate shared object hint table information including diff --git a/libqpdf/QPDF_pages.cc b/libqpdf/QPDF_pages.cc index 0dad3b53..cd05366e 100644 --- a/libqpdf/QPDF_pages.cc +++ b/libqpdf/QPDF_pages.cc @@ -121,7 +121,7 @@ QPDF::getAllPagesInternal( if (!kid.isIndirect()) { QTC::TC("qpdf", "QPDF handle direct page object"); cur_node.warnIfPossible( - "kid " + QUtil::int_to_string(i) + + "kid " + std::to_string(i) + " (from 0) is direct; converting to indirect"); kid = makeIndirectObject(kid); kids.setArrayItem(i, kid); @@ -130,7 +130,7 @@ QPDF::getAllPagesInternal( // shallowCopyPage in QPDFPageObjectHelper. QTC::TC("qpdf", "QPDF resolve duplicated page object"); cur_node.warnIfPossible( - "kid " + QUtil::int_to_string(i) + + "kid " + std::to_string(i) + " (from 0) appears more than once in the pages tree;" " creating a new page object as a copy"); kid = makeIndirectObject(QPDFObjectHandle(kid).shallowCopy()); @@ -205,8 +205,7 @@ QPDF::insertPageobjToPage( // The library never calls insertPageobjToPage in a way // that causes this to happen. setLastObjectDescription( - "page " + QUtil::int_to_string(pos) + " (numbered from zero)", - og); + "page " + std::to_string(pos) + " (numbered from zero)", og); throw QPDFExc( qpdf_e_pages, this->m->file->getName(), diff --git a/libqpdf/SecureRandomDataProvider.cc b/libqpdf/SecureRandomDataProvider.cc index c96d31f7..f6ee559f 100644 --- a/libqpdf/SecureRandomDataProvider.cc +++ b/libqpdf/SecureRandomDataProvider.cc @@ -107,7 +107,7 @@ SecureRandomDataProvider::provideRandomData(unsigned char* data, size_t len) fclose(f); if (fr != len) { throw std::runtime_error( - "unable to read " + QUtil::uint_to_string(len) + " bytes from " + + "unable to read " + std::to_string(len) + " bytes from " + std::string(RANDOM_DEVICE)); } diff --git a/libqpdf/qpdf-c.cc b/libqpdf/qpdf-c.cc index b183c8fb..e819e3ff 100644 --- a/libqpdf/qpdf-c.cc +++ b/libqpdf/qpdf-c.cc @@ -994,7 +994,7 @@ do_with_oh( throw QPDFExc( qpdf_e_internal, q->qpdf->getFilename(), - std::string("C API object handle ") + QUtil::uint_to_string(oh), + std::string("C API object handle ") + std::to_string(oh), 0, "attempted access to unknown object handle"); } diff --git a/libqpdf/qpdf/bits_functions.hh b/libqpdf/qpdf/bits_functions.hh index f6e385f6..632136f4 100644 --- a/libqpdf/qpdf/bits_functions.hh +++ b/libqpdf/qpdf/bits_functions.hh @@ -33,8 +33,8 @@ read_bits( 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)); + std::to_string(bits_wanted) + + "; available = " + std::to_string(bits_available)); } if (bits_wanted > 32) { throw std::out_of_range("read_bits: too many bits requested"); |