Rename `objects_*` limits to `parser_*` for clarity and consistency. Update rela…

…ted tests, documentation, and references across the codebase.

Rename `objects_` limits to `parser_` for clarity and consistency. Update rela…
…ted tests, documentation, and references across the codebase.
m-holger
1 parent 2774ac30
Showing 7 changed files with 87 additions and 87 deletions
include/qpdf/Constants.h
include/qpdf/global.hh
libqpdf/QPDFParser.cc
libqpdf/global.cc
libqpdf/qpdf/QPDFParser.hh
libqpdf/qpdf/global_private.hh
libtests/objects.cc
@@ -281,10 +281,10 @@ enum qpdf_param_e {
     /* global limits */
  
     /* object - parser limits */
-    qpdf_p_objects_max_nesting = 0x12000,
-    qpdf_p_objects_max_errors,
-    qpdf_p_objects_max_container_size,
-    qpdf_p_objects_max_container_size_damaged,
+    qpdf_p_parser_max_nesting = 0x13000,
+    qpdf_p_parser_max_errors,
+    qpdf_p_parser_max_container_size,
+    qpdf_p_parser_max_container_size_damaged,
  
     /* next section = 0x20000 */
     qpdf_enum_max = 0x7fffffff,
@@ -104,9 +104,9 @@ namespace qpdf::global
         /// @note The maximum nesting level cannot be disabled by calling `default_limit(false)`.
         ///
         /// @since 12.3
-        uint32_t inline objects_max_nesting()
+        uint32_t inline parser_max_nesting()
         {
-            return get_uint32(qpdf_p_objects_max_nesting);
+            return get_uint32(qpdf_p_parser_max_nesting);
         }
  
         /// @brief Sets the maximum nesting level while parsing objects.
@@ -116,9 +116,9 @@ namespace qpdf::global
         /// @note The maximum nesting level cannot be disabled by calling `default_limit(false)`.
         ///
         /// @since 12.3
-        void inline objects_max_nesting(uint32_t value)
+        void inline parser_max_nesting(uint32_t value)
         {
-            set_uint32(qpdf_p_objects_max_nesting, value);
+            set_uint32(qpdf_p_parser_max_nesting, value);
         }
  
         /// @brief Retrieves the maximum number of errors allowed while parsing objects.
@@ -128,9 +128,9 @@ namespace qpdf::global
         /// @return The maximum number of errors allowed while parsing objects.
         ///
         /// @since 12.3
-        uint32_t inline objects_max_errors()
+        uint32_t inline parser_max_errors()
         {
-            return get_uint32(qpdf_p_objects_max_errors);
+            return get_uint32(qpdf_p_parser_max_errors);
         }
  
         /// Sets the maximum number of errors allowed while parsing objects.
@@ -140,9 +140,9 @@ namespace qpdf::global
         /// @param value The maximum number of errors allowed while parsing objects to set.
         ///
         /// @since 12.3
-        void inline objects_max_errors(uint32_t value)
+        void inline parser_max_errors(uint32_t value)
         {
-            set_uint32(qpdf_p_objects_max_errors, value);
+            set_uint32(qpdf_p_parser_max_errors, value);
         }
  
         /// @brief Retrieves the maximum number of objectstop-level allowed in a container while
@@ -155,9 +155,9 @@ namespace qpdf::global
         ///         objects.
         ///
         /// @since 12.3
-        uint32_t inline objects_max_container_size()
+        uint32_t inline parser_max_container_size()
         {
-            return get_uint32(qpdf_p_objects_max_container_size);
+            return get_uint32(qpdf_p_parser_max_container_size);
         }
  
         /// @brief Sets the maximum number oftop-level objects allowed in a container while parsing.
@@ -169,9 +169,9 @@ namespace qpdf::global
         ///               parsing objects to set.
         ///
         /// @since 12.3
-        void inline objects_max_container_size(uint32_t value)
+        void inline parser_max_container_size(uint32_t value)
         {
-            set_uint32(qpdf_p_objects_max_container_size, value);
+            set_uint32(qpdf_p_parser_max_container_size, value);
         }
  
         /// @brief Retrieves the maximum number of top-level objects allowed in a container while
@@ -185,9 +185,9 @@ namespace qpdf::global
         ///         objects.
         ///
         /// @since 12.3
-        uint32_t inline objects_max_container_size_damaged()
+        uint32_t inline parser_max_container_size_damaged()
         {
-            return get_uint32(qpdf_p_objects_max_container_size_damaged);
+            return get_uint32(qpdf_p_parser_max_container_size_damaged);
         }
  
         /// @brief Sets the maximum number of top-level objects allowed in a container while
@@ -201,9 +201,9 @@ namespace qpdf::global
         ///               parsing objects to set.
         ///
         /// @since 12.3
-        void inline objects_max_container_size_damaged(uint32_t value)
+        void inline parser_max_container_size_damaged(uint32_t value)
         {
-            set_uint32(qpdf_p_objects_max_container_size_damaged, value);
+            set_uint32(qpdf_p_parser_max_container_size_damaged, value);
         }
     } // namespace limits
  
@@ -15,7 +15,7 @@ using namespace qpdf;
  
 using ObjectPtr = std::shared_ptr<QPDFObject>;
  
-static uint32_t const& max_nesting{global::Limits::objects_max_nesting()};
+static uint32_t const& max_nesting{global::Limits::parser_max_nesting()};
  
 // The ParseGuard class allows QPDFParser to detect re-entrant parsing. It also provides
 // special access to allow the parser to create unresolved objects and dangling references.
@@ -587,7 +587,7 @@ template &lt;typename T, typename... Args&gt;
 void
 QPDFParser::addScalar(Args&&... args)
 {
-    auto limit = Limits::objects_max_container_size(bad_count || sanity_checks);
+    auto limit = Limits::parser_max_container_size(bad_count || sanity_checks);
     if (frame->olist.size() > limit || frame->dict.size() > limit) {
         // Stop adding scalars. We are going to abort when the close token or a bad token is
         // encountered.
@@ -645,7 +645,7 @@ QPDFParser::fixMissingKeys()
 void
 QPDFParser::check_too_many_bad_tokens()
 {
-    auto limit = Limits::objects_max_container_size(bad_count || sanity_checks);
+    auto limit = Limits::parser_max_container_size(bad_count || sanity_checks);
     if (frame->olist.size() > limit || frame->dict.size() > limit) {
         if (bad_count) {
             Limits::error();
@@ -9,24 +9,24 @@ Limits Limits::l;
 Options Options::o;
  
 void
-Limits::objects_max_container_size(bool damaged, uint32_t value)
+Limits::parser_max_container_size(bool damaged, uint32_t value)
 {
     if (damaged) {
-        l.objects_max_container_size_damaged_set_ = true;
-        l.objects_max_container_size_damaged_ = value;
+        l.parser_max_container_size_damaged_set_ = true;
+        l.parser_max_container_size_damaged_ = value;
     } else {
-        l.objects_max_container_size_ = value;
+        l.parser_max_container_size_ = value;
     }
 }
  
 void
 Limits::disable_defaults()
 {
-    if (!l.objects_max_errors_set_) {
-        l.objects_max_errors_ = 0;
+    if (!l.parser_max_errors_set_) {
+        l.parser_max_errors_ = 0;
     }
-    if (!l.objects_max_container_size_damaged_set_) {
-        l.objects_max_container_size_damaged_ = std::numeric_limits<uint32_t>::max();
+    if (!l.parser_max_container_size_damaged_set_) {
+        l.parser_max_container_size_damaged_ = std::numeric_limits<uint32_t>::max();
     }
 }
  
@@ -41,17 +41,17 @@ qpdf_global_get_uint32(qpdf_param_e param, uint32_t* value)
     case qpdf_p_limit_errors:
         *value = Limits::errors();
         return qpdf_r_ok;
-    case qpdf_p_objects_max_nesting:
-        *value = Limits::objects_max_nesting();
+    case qpdf_p_parser_max_nesting:
+        *value = Limits::parser_max_nesting();
         return qpdf_r_ok;
-    case qpdf_p_objects_max_errors:
-        *value = Limits::objects_max_errors();
+    case qpdf_p_parser_max_errors:
+        *value = Limits::parser_max_errors();
         return qpdf_r_ok;
-    case qpdf_p_objects_max_container_size:
-        *value = Limits::objects_max_container_size(false);
+    case qpdf_p_parser_max_container_size:
+        *value = Limits::parser_max_container_size(false);
         return qpdf_r_ok;
-    case qpdf_p_objects_max_container_size_damaged:
-        *value = Limits::objects_max_container_size(true);
+    case qpdf_p_parser_max_container_size_damaged:
+        *value = Limits::parser_max_container_size(true);
         return qpdf_r_ok;
     default:
         return qpdf_r_bad_parameter;
@@ -65,17 +65,17 @@ qpdf_global_set_uint32(qpdf_param_e param, uint32_t value)
     case qpdf_p_default_limits:
         Options::default_limits(value);
         return qpdf_r_ok;
-    case qpdf_p_objects_max_nesting:
-        Limits::objects_max_nesting(value);
+    case qpdf_p_parser_max_nesting:
+        Limits::parser_max_nesting(value);
         return qpdf_r_ok;
-    case qpdf_p_objects_max_errors:
-        Limits::objects_max_errors(value);
+    case qpdf_p_parser_max_errors:
+        Limits::parser_max_errors(value);
         return qpdf_r_ok;
-    case qpdf_p_objects_max_container_size:
-        Limits::objects_max_container_size(false, value);
+    case qpdf_p_parser_max_container_size:
+        Limits::parser_max_container_size(false, value);
         return qpdf_r_ok;
-    case qpdf_p_objects_max_container_size_damaged:
-        Limits::objects_max_container_size(true, value);
+    case qpdf_p_parser_max_container_size_damaged:
+        Limits::parser_max_container_size(true, value);
         return qpdf_r_ok;
     default:
         return qpdf_r_bad_parameter;
@@ -149,7 +149,7 @@ class QPDFParser
     // it only gets incremented or reset when a bad token is encountered.
     int bad_count{0};
     // Number of bad tokens (remaining) before giving up.
-    uint32_t max_bad_count{Limits::objects_max_errors()};
+    uint32_t max_bad_count{Limits::parser_max_errors()};
     // Number of good tokens since last bad token. Irrelevant if bad_count == 0.
     int good_count{0};
     // Start offset including any leading whitespace.
@@ -16,37 +16,37 @@ namespace qpdf::global
         Limits& operator=(Limits&&) = delete;
  
         static uint32_t const&
-        objects_max_nesting()
+        parser_max_nesting()
         {
-            return l.objects_max_nesting_;
+            return l.parser_max_nesting_;
         }
  
         static void
-        objects_max_nesting(uint32_t value)
+        parser_max_nesting(uint32_t value)
         {
-            l.objects_max_nesting_ = value;
+            l.parser_max_nesting_ = value;
         }
  
         static uint32_t const&
-        objects_max_errors()
+        parser_max_errors()
         {
-            return l.objects_max_errors_;
+            return l.parser_max_errors_;
         }
  
         static void
-        objects_max_errors(uint32_t value)
+        parser_max_errors(uint32_t value)
         {
-            l.objects_max_errors_set_ = true;
-            l.objects_max_errors_ = value;
+            l.parser_max_errors_set_ = true;
+            l.parser_max_errors_ = value;
         }
  
         static uint32_t const&
-        objects_max_container_size(bool damaged)
+        parser_max_container_size(bool damaged)
         {
-            return damaged ? l.objects_max_container_size_damaged_ : l.objects_max_container_size_;
+            return damaged ? l.parser_max_container_size_damaged_ : l.parser_max_container_size_;
         }
  
-        static void objects_max_container_size(bool damaged, uint32_t value);
+        static void parser_max_container_size(bool damaged, uint32_t value);
  
         /// Record a limit error.
         static void
@@ -73,12 +73,12 @@ namespace qpdf::global
  
         uint32_t errors_{0};
  
-        uint32_t objects_max_nesting_{499};
-        uint32_t objects_max_errors_{15};
-        bool objects_max_errors_set_{false};
-        uint32_t objects_max_container_size_{std::numeric_limits<uint32_t>::max()};
-        uint32_t objects_max_container_size_damaged_{5'000};
-        bool objects_max_container_size_damaged_set_{false};
+        uint32_t parser_max_nesting_{499};
+        uint32_t parser_max_errors_{15};
+        bool parser_max_errors_set_{false};
+        uint32_t parser_max_container_size_{std::numeric_limits<uint32_t>::max()};
+        uint32_t parser_max_container_size_damaged_{5'000};
+        bool parser_max_container_size_damaged_set_{false};
     };
  
     class Options
@@ -162,18 +162,18 @@ test_2(QPDF&amp; pdf, char const* arg2)
     using namespace qpdf::global::limits;
  
     // Check default values
-    assert(objects_max_nesting() == 499);
-    assert(objects_max_errors() == 15);
-    assert(objects_max_container_size() == std::numeric_limits<uint32_t>::max());
-    assert(objects_max_container_size_damaged() == 5'000);
+    assert(parser_max_nesting() == 499);
+    assert(parser_max_errors() == 15);
+    assert(parser_max_container_size() == std::numeric_limits<uint32_t>::max());
+    assert(parser_max_container_size_damaged() == 5'000);
     assert(default_limits());
  
     // Test disabling optional default limits
     default_limits(false);
-    assert(objects_max_nesting() == 499);
-    assert(objects_max_errors() == 0);
-    assert(objects_max_container_size() == std::numeric_limits<uint32_t>::max());
-    assert(objects_max_container_size_damaged() == std::numeric_limits<uint32_t>::max());
+    assert(parser_max_nesting() == 499);
+    assert(parser_max_errors() == 0);
+    assert(parser_max_container_size() == std::numeric_limits<uint32_t>::max());
+    assert(parser_max_container_size_damaged() == std::numeric_limits<uint32_t>::max());
     assert(!default_limits());
  
     // Check disabling default limits is irreversible
@@ -181,22 +181,22 @@ test_2(QPDF&amp; pdf, char const* arg2)
     assert(!default_limits());
  
     // Test setting limits
-    objects_max_nesting(11);
-    objects_max_errors(12);
-    objects_max_container_size(13);
-    objects_max_container_size_damaged(14);
+    parser_max_nesting(11);
+    parser_max_errors(12);
+    parser_max_container_size(13);
+    parser_max_container_size_damaged(14);
  
-    assert(objects_max_nesting() == 11);
-    assert(objects_max_errors() == 12);
-    assert(objects_max_container_size() == 13);
-    assert(objects_max_container_size_damaged() == 14);
+    assert(parser_max_nesting() == 11);
+    assert(parser_max_errors() == 12);
+    assert(parser_max_container_size() == 13);
+    assert(parser_max_container_size_damaged() == 14);
  
     // Check disabling default limits does not override explicit limits
     default_limits(false);
-    assert(objects_max_nesting() == 11);
-    assert(objects_max_errors() == 12);
-    assert(objects_max_container_size() == 13);
-    assert(objects_max_container_size_damaged() == 14);
+    assert(parser_max_nesting() == 11);
+    assert(parser_max_errors() == 12);
+    assert(parser_max_container_size() == 13);
+    assert(parser_max_container_size_damaged() == 14);
  
     // Test parameter checking
     QUtil::handle_result_code(qpdf_r_ok, "");
@@ -226,7 +226,7 @@ test_2(QPDF&amp; pdf, char const* arg2)
     assert(qpdf::global::limit_errors() == 0);
     QPDFObjectHandle::parse("[[[[]]]]");
     assert(qpdf::global::limit_errors() == 0);
-    objects_max_nesting(3);
+    parser_max_nesting(3);
     try {
         QPDFObjectHandle::parse("[[[[[]]]]]");
     } catch (std::exception&) {