more

lib/htmlrw_check/datatype/dt_language.ml

···
 (** Helper functions for language tag validation *)
 
+let q = Error_code.q
+
 let is_lower_alpha c = c >= 'a' && c <= 'z'
 let is_upper_alpha c = c >= 'A' && c <= 'Z'
 let is_alpha c = is_lower_alpha c || is_upper_alpha c
···
                     if is_valid_extlang first_lower second_lower then
                       Ok ()
                     else
-                      Error (Printf.sprintf "Bad extlang subtag \xe2\x80\x9c%s\xe2\x80\x9d" second_lower)
+                      Error (Printf.sprintf "Bad extlang subtag %s" (q second_lower))
                   else
                     Ok ()  (* Not an extlang pattern, continue *)
               | [] -> Ok ())

lib/htmlrw_check/parse_error_bridge.ml

···
   SPDX-License-Identifier: MIT
  ---------------------------------------------------------------------------*)
 
+let q = Error_code.q
+
 (** Generate human-readable message for a parse error code *)
 let message_of_parse_error code =
   let code_str = Html5rw.Parse_error_code.to_string code in
···
           let cp = int_of_string ("0x" ^ cp_str) in
           Printf.sprintf "Character reference expands to a surrogate (U+%04x)." cp
         else if s = "no-p-element-in-scope" then
-          "No \xe2\x80\x9cp\xe2\x80\x9d element in scope but a \xe2\x80\x9cp\xe2\x80\x9d end tag seen."
+          Printf.sprintf "No %s element in scope but a %s end tag seen." (q "p") (q "p")
         else if s = "end-tag-p-implied-but-open-elements" then
-          "End tag \xe2\x80\x9cp\xe2\x80\x9d implied, but there were open elements."
+          Printf.sprintf "End tag %s implied, but there were open elements." (q "p")
         else if s = "end-tag-br" then
-          "End tag \xe2\x80\x9cbr\xe2\x80\x9d."
+          Printf.sprintf "End tag %s." (q "br")
         else if s = "expected-closing-tag-but-got-eof" then
           "End of file seen and there were open elements."
         else if String.starts_with ~prefix:"bad-start-tag-in-head-noscri" s then
           let colon_pos = String.index s ':' in
           let element = String.sub s (colon_pos + 1) (String.length s - colon_pos - 1) in
-          Printf.sprintf "Bad start tag in \xe2\x80\x9c%s\xe2\x80\x9d in \xe2\x80\x9cnoscript\xe2\x80\x9d in \xe2\x80\x9chead\xe2\x80\x9d." element
+          Printf.sprintf "Bad start tag in %s in %s in %s." (q element) (q "noscript") (q "head")
         else if String.starts_with ~prefix:"unexpected-end-tag:" s then
           let element = String.sub s 19 (String.length s - 19) in
-          Printf.sprintf "Stray end tag \xe2\x80\x9c%s\xe2\x80\x9d." element
+          Printf.sprintf "Stray end tag %s." (q element)
         else if String.starts_with ~prefix:"start-tag-in-table:" s then
           let tag = String.sub s 19 (String.length s - 19) in
-          Printf.sprintf "Start tag \xe2\x80\x9c%s\xe2\x80\x9d seen in \xe2\x80\x9ctable\xe2\x80\x9d." tag
+          Printf.sprintf "Start tag %s seen in %s." (q tag) (q "table")
         else
           Printf.sprintf "Parse error: %s" s
       with _ -> Printf.sprintf "Parse error: %s" s)

lib/htmlrw_check/semantic/obsolete_checker.ml

···
+let q = Error_code.q
+
 (** Obsolete elements map: element name -> suggestion message *)
 let obsolete_elements =
   let tbl = Hashtbl.create 32 in
···
     "Use the HTTP OPTIONS feature instead.";
 
   register "name" ["a"]
-    "Consider putting an \xe2\x80\x9cid\xe2\x80\x9d attribute on the nearest container instead.";
+    (Printf.sprintf "Consider putting an %s attribute on the nearest container instead." (q "id"));
 
   register "name" ["embed"; "img"; "option"]
-    "Use the \xe2\x80\x9cid\xe2\x80\x9d attribute instead.";
+    (Printf.sprintf "Use the %s attribute instead." (q "id"));
 
   register "nohref" ["area"]
     "Omitting the \"href\" attribute is sufficient.";

lib/htmlrw_check/semantic/required_attr_checker.ml

···
 (** Required attribute checker implementation. *)
 
+let q = Error_code.q
+
 type state = {
   mutable _in_figure : bool;
   (** Track if we're inside a <figure> element (alt is more critical there) *)
···
   in
 
   if not valid then
-    let q s = "\xe2\x80\x9c" ^ s ^ "\xe2\x80\x9d" in
     Message_collector.add_typed collector
       (`Generic (Printf.sprintf "A %s element must have either a %s attribute, a %s attribute with a %s attribute, or an %s attribute with a %s attribute."
           (q "meta") (q "charset") (q "name")
···
     let value_lower = String.lowercase_ascii value in
     (* Valid values: empty string, auto, manual, hint *)
     if value_lower <> "" && value_lower <> "auto" && value_lower <> "manual" && value_lower <> "hint" then
-      let q s = "\xe2\x80\x9c" ^ s ^ "\xe2\x80\x9d" in
       Message_collector.add_typed collector
         (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s."
             (q value) (q "popover") (q element_name)))))
···
           let value = float_of_string value_str in
           let min_val = float_of_string min_str in
           if min_val > value then
-            let q s = "\xe2\x80\x9c" ^ s ^ "\xe2\x80\x9d" in
             Message_collector.add_typed collector
               (`Generic (Printf.sprintf "The value of the %s attribute must be less than or equal to the value of the %s attribute."
                   (q "min") (q "value")))
···
           | Some max_str -> (try float_of_string max_str with _ -> 1.0)
         in
         if value > max_val then
-          let q s = "\xe2\x80\x9c" ^ s ^ "\xe2\x80\x9d" in
           (* Check which message to use based on whether max is present *)
           if Attr_utils.has_attr "max" attrs then
             Message_collector.add_typed collector

lib/htmlrw_check/specialized/aria_checker.ml

···
           if aria_checked <> None then
             Message_collector.add_typed collector
               (`Aria (`Must_not_use (`Attr "aria-checked", `Elem "input",
-                `Condition "a \xe2\x80\x9ctype\xe2\x80\x9d attribute whose value is \xe2\x80\x9ccheckbox\xe2\x80\x9d")))
+                `Condition (Printf.sprintf "a %s attribute whose value is %s" (q "type") (q "checkbox")))))
         | _ -> ()
       end;
 

lib/htmlrw_check/specialized/attr_restrictions_checker.ml

···
 (** Attribute restrictions checker - validates that certain attributes
     are not used on elements where they're not allowed. *)
 
+let q = Error_code.q
+
 (** List of (element, [disallowed attributes]) pairs for HTML elements. *)
 let disallowed_attrs_html = [
   (* Elements that cannot have href attribute (RDFa misuses) *)
···
           if attr_value = "#" then
             Message_collector.add_typed collector
               (`Attr (`Bad_value_generic (`Message (Printf.sprintf
-                "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad hash-name reference: A hash-name reference must have at least one character after \xe2\x80\x9c#\xe2\x80\x9d."
-                attr_value attr_name name))))
+                "Bad value %s for attribute %s on element %s: Bad hash-name reference: A hash-name reference must have at least one character after %s."
+                (q attr_value) (q attr_name) (q name) (q "#")))))
         end
       ) attrs
     end;
···
           | Error msg ->
             Message_collector.add_typed collector
               (`Attr (`Bad_value_generic (`Message (Printf.sprintf
-                "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: %s"
-                attr_value attr_name name msg))))
+                "Bad value %s for attribute %s on element %s: Bad MIME type: %s"
+                (q attr_value) (q attr_name) (q name) msg))))
         end
       ) attrs
     end;
···
             (* Determine specific error message *)
             let error_msg =
               if String.length attr_value = 0 then
-                Printf.sprintf "Bad value \xe2\x80\x9c\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: The empty string is not a valid non-negative integer."
-                  attr_name name
+                Printf.sprintf "Bad value %s for attribute %s on element %s: The empty string is not a valid non-negative integer."
+                  (q "") (q attr_name) (q name)
               else if String.contains attr_value '%' then
-                Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad non-negative integer: Expected a digit but saw \xe2\x80\x9c%%\xe2\x80\x9d instead."
-                  attr_value attr_name name
+                Printf.sprintf "Bad value %s for attribute %s on element %s: Bad non-negative integer: Expected a digit but saw %s instead."
+                  (q attr_value) (q attr_name) (q name) (q "%")
               else if String.length attr_value > 0 && attr_value.[0] = '-' then
-                Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad non-negative integer: Expected a digit but saw \xe2\x80\x9c-\xe2\x80\x9d instead."
-                  attr_value attr_name name
+                Printf.sprintf "Bad value %s for attribute %s on element %s: Bad non-negative integer: Expected a digit but saw %s instead."
+                  (q attr_value) (q attr_name) (q name) (q "-")
               else
                 (* Find first non-digit character *)
                 let bad_char =
···
                 in
                 match bad_char with
                 | Some c ->
-                  Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad non-negative integer: Expected a digit but saw \xe2\x80\x9c%c\xe2\x80\x9d instead."
-                    attr_value attr_name name c
+                  Printf.sprintf "Bad value %s for attribute %s on element %s: Bad non-negative integer: Expected a digit but saw %s instead."
+                    (q attr_value) (q attr_name) (q name) (q (String.make 1 c))
                 | None ->
-                  Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad non-negative integer: Expected a digit."
-                    attr_value attr_name name
+                  Printf.sprintf "Bad value %s for attribute %s on element %s: Bad non-negative integer: Expected a digit."
+                    (q attr_value) (q attr_name) (q name)
             in
             Message_collector.add_typed collector
               (`Attr (`Bad_value_generic (`Message error_msg)))
···
           if count_codepoints key > 1 then
             Message_collector.add_typed collector
               (`Attr (`Bad_value_generic (`Message (Printf.sprintf
-                "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad key label list: Key label has multiple characters. Each key label must be a single character."
-                attr_value attr_name name))))
+                "Bad value %s for attribute %s on element %s: Bad key label list: Key label has multiple characters. Each key label must be a single character."
+                (q attr_value) (q attr_name) (q name)))))
         ) keys;
         (* Check for duplicate keys *)
         let rec find_duplicates seen = function
···
             if List.mem k seen then
               Message_collector.add_typed collector
                 (`Attr (`Bad_value_generic (`Message (Printf.sprintf
-                  "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad key label list: Duplicate key label. Each key label must be unique."
-                  attr_value attr_name name))))
+                  "Bad value %s for attribute %s on element %s: Bad key label list: Duplicate key label. Each key label must be unique."
+                  (q attr_value) (q attr_name) (q name)))))
             else
               find_duplicates (k :: seen) rest
         in
···
       if has_command && has_aria_expanded then
         Message_collector.add_typed collector
           (`Attr (`Not_allowed_when (`Attr "aria-expanded", `Elem name,
-            `Condition "a \xe2\x80\x9ccommand\xe2\x80\x9d attribute")));
+            `Condition (Printf.sprintf "a %s attribute" (q "command")))));
 
       if has_popovertarget && has_aria_expanded then
         Message_collector.add_typed collector
           (`Attr (`Not_allowed_when (`Attr "aria-expanded", `Elem name,
-            `Condition "a \xe2\x80\x9cpopovertarget\xe2\x80\x9d attribute")))
+            `Condition (Printf.sprintf "a %s attribute" (q "popovertarget")))))
     end;
 
     (* Note: data-* uppercase check requires XML parsing which preserves case.
···
             | Error msg ->
               Message_collector.add_typed collector
                 (`Attr (`Bad_value_generic (`Message (Printf.sprintf
-                  "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad media query: %s"
-                  attr_value attr_name name msg))))
+                  "Bad value %s for attribute %s on element %s: Bad media query: %s"
+                  (q attr_value) (q attr_name) (q name) msg))))
           end
         end
       ) attrs

lib/htmlrw_check/specialized/datetime_checker.ml

···
 (** Datetime attribute validation checker *)
 
+let q = Error_code.q
+
 (** Elements that have datetime attribute *)
 let datetime_elements = ["del"; "ins"; "time"]
 
···
   if value <> String.trim value then begin
     let tz_msg = "Bad datetime with timezone: The literal did not satisfy the datetime with timezone format." in
     let date_msg = "Bad date: The literal did not satisfy the date format." in
-    Error (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: %s %s"
-      value attr_name element_name tz_msg date_msg)
+    Error (Printf.sprintf "Bad value %s for attribute %s on element %s: %s %s"
+      (q value) (q attr_name) (q element_name) tz_msg date_msg)
   end
   else
   (* Try datetime with timezone first *)
···
   | DtOk -> Ok  (* Valid datetime with timezone *)
   | DtWarning w ->
     (* Valid but with warning - format matches Nu validator *)
-    Warning (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad datetime with timezone: %s Bad date: The literal did not satisfy the date format."
-      value attr_name element_name w)
+    Warning (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad datetime with timezone: %s Bad date: The literal did not satisfy the date format."
+      (q value) (q attr_name) (q element_name) w)
   | DtError tz_error ->
     (* Try just date - valid for all elements *)
     match validate_date value with
···
       if has_suspicious_year value || has_old_year value then begin
         let date_msg = "Bad date: Year may be mistyped." in
         let tz_msg = Printf.sprintf "Bad datetime with timezone: %s." tz_error in
-        Warning (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: %s %s"
-          value attr_name element_name date_msg tz_msg)
+        Warning (Printf.sprintf "Bad value %s for attribute %s on element %s: %s %s"
+          (q value) (q attr_name) (q element_name) date_msg tz_msg)
       end else
         Ok  (* Valid date with normal year *)
     | (false, date_error) ->
···
                     | (true, _) -> Ok  (* Valid duration P... *)
                     | (false, _) ->
                       (* Use simplified message for time element matching Nu validator format *)
-                      Error (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad time-datetime: The literal did not satisfy the time-datetime format."
-                        value attr_name element_name)
+                      Error (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad time-datetime: The literal did not satisfy the time-datetime format."
+                        (q value) (q attr_name) (q element_name))
       end
       else begin
         (* del/ins only allow date or datetime-with-timezone *)
···
         (* Datetime first for: generic tz, tz hours error, time minute/hour errors, year errors
            Date first for: "Month cannot be less than" date error, tz minutes error, fraction error *)
         if is_month_less_than_error then
-          Error (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: %s %s"
-            value attr_name element_name date_msg tz_msg)
+          Error (Printf.sprintf "Bad value %s for attribute %s on element %s: %s %s"
+            (q value) (q attr_name) (q element_name) date_msg tz_msg)
         else if is_tz_minutes_error || is_fraction_error then
-          Error (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: %s %s"
-            value attr_name element_name date_msg tz_msg)
+          Error (Printf.sprintf "Bad value %s for attribute %s on element %s: %s %s"
+            (q value) (q attr_name) (q element_name) date_msg tz_msg)
         else if is_tz_hours_error || is_time_minute_or_hour_error || is_generic_tz then
-          Error (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: %s %s"
-            value attr_name element_name tz_msg date_msg)
+          Error (Printf.sprintf "Bad value %s for attribute %s on element %s: %s %s"
+            (q value) (q attr_name) (q element_name) tz_msg date_msg)
         else
-          Error (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: %s %s"
-            value attr_name element_name tz_msg date_msg)
+          Error (Printf.sprintf "Bad value %s for attribute %s on element %s: %s %s"
+            (q value) (q attr_name) (q element_name) tz_msg date_msg)
       end
 
 (** Checker state *)

lib/htmlrw_check/specialized/microdata_checker.ml

···
 
     Validates HTML5 microdata attributes. *)
 
+(** Quote helper for consistent message formatting. *)
+let q = Error_code.q
+
 (** Information about an itemscope. *)
 type item_scope = {
   element : string;
···
   let url_trimmed = String.trim url in
   if String.length url_trimmed = 0 then
     Some (Printf.sprintf
-      "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad absolute URL: Must be non-empty."
-      original_value attr_name element)
+      "Bad value %s for attribute %s on element %s: Bad absolute URL: Must be non-empty."
+      (q original_value) (q attr_name) (q element))
   else
     (* First check if it has a scheme (required for absolute URL) *)
     match Url_checker.extract_scheme url_trimmed with
     | None ->
       Some (Printf.sprintf
-        "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad absolute URL: The string \xe2\x80\x9c%s\xe2\x80\x9d is not an absolute URL."
-        original_value attr_name element url)
+        "Bad value %s for attribute %s on element %s: Bad absolute URL: The string %s is not an absolute URL."
+        (q original_value) (q attr_name) (q element) (q url))
     | Some _ ->
       (* Has a scheme - do comprehensive URL validation *)
       match Url_checker.validate_url url element attr_name with
···
         (* Escape backslashes in replacement string for Str.global_replace *)
         let escaped_original = Str.global_replace (Str.regexp "\\\\") "\\\\\\\\" original_value in
         let error_msg = Str.global_replace
-          (Str.regexp_string (Printf.sprintf "\xe2\x80\x9c%s\xe2\x80\x9d for attribute" url))
-          (Printf.sprintf "\xe2\x80\x9c%s\xe2\x80\x9d for attribute" escaped_original)
+          (Str.regexp_string (Printf.sprintf "%s for attribute" (q url)))
+          (Printf.sprintf "%s for attribute" (q escaped_original))
           error_msg in
         Some error_msg
 

lib/htmlrw_check/specialized/mime_type_checker.ml

···
 
     Validates MIME type values in type attributes. *)
 
+let q = Error_code.q
+
 (** Validate a MIME type value. Returns error message or None. *)
 let validate_mime_type value element attr_name =
   let len = String.length value in
   if len = 0 then
     Some (Printf.sprintf
-      "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Empty value."
-      value attr_name element)
+      "Bad value %s for attribute %s on element %s: Bad MIME type: Empty value."
+      (q value) (q attr_name) (q element))
   else if value.[len - 1] = ' ' || value.[len - 1] = '\t' then begin
     (* Check if this is a semicolon followed by only whitespace *)
     let semicolon_pos = try Some (String.index value ';') with Not_found -> None in
···
       let params_trimmed = String.trim params in
       if params_trimmed = "" then
         Some (Printf.sprintf
-          "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Semicolon seen but there was no parameter following it."
-          value attr_name element)
+          "Bad value %s for attribute %s on element %s: Bad MIME type: Semicolon seen but there was no parameter following it."
+          (q value) (q attr_name) (q element))
       else
         Some (Printf.sprintf
-          "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Extraneous trailing whitespace."
-          value attr_name element)
+          "Bad value %s for attribute %s on element %s: Bad MIME type: Extraneous trailing whitespace."
+          (q value) (q attr_name) (q element))
     | None ->
       Some (Printf.sprintf
-        "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Extraneous trailing whitespace."
-        value attr_name element)
+        "Bad value %s for attribute %s on element %s: Bad MIME type: Extraneous trailing whitespace."
+        (q value) (q attr_name) (q element))
   end
   else if len > 0 && (value.[0] = ' ' || value.[0] = '\t') then
     Some (Printf.sprintf
-      "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Expected a token character but saw \xe2\x80\x9c \xe2\x80\x9d instead."
-      value attr_name element)
+      "Bad value %s for attribute %s on element %s: Bad MIME type: Expected a token character but saw %s instead."
+      (q value) (q attr_name) (q element) (q " "))
   else
     (* Parse type/subtype *)
     let slash_pos = try Some (String.index value '/') with Not_found -> None in
···
       (match semicolon_pos with
       | Some _ ->
         Some (Printf.sprintf
-          "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Subtype missing."
-          value attr_name element)
+          "Bad value %s for attribute %s on element %s: Bad MIME type: Subtype missing."
+          (q value) (q attr_name) (q element))
       | None ->
         Some (Printf.sprintf
-          "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Subtype missing."
-          value attr_name element))
+          "Bad value %s for attribute %s on element %s: Bad MIME type: Subtype missing."
+          (q value) (q attr_name) (q element)))
     | Some slash_pos ->
       (* Check for empty subtype *)
       let after_slash = String.sub value (slash_pos + 1) (len - slash_pos - 1) in
···
       let subtype_trimmed = String.trim subtype in
       if subtype_trimmed = "" then
         Some (Printf.sprintf
-          "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Subtype missing."
-          value attr_name element)
+          "Bad value %s for attribute %s on element %s: Bad MIME type: Subtype missing."
+          (q value) (q attr_name) (q element))
       else if String.length subtype > 0 && subtype.[String.length subtype - 1] = ' ' then
         (* Space before semicolon - also check parameter format *)
         let semicolon_pos = try Some (String.index value ';') with Not_found -> None in
···
           let params_trimmed = String.trim params in
           if params_trimmed = "" then
             Some (Printf.sprintf
-              "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Semicolon seen but there was no parameter following it."
-              value attr_name element)
+              "Bad value %s for attribute %s on element %s: Bad MIME type: Semicolon seen but there was no parameter following it."
+              (q value) (q attr_name) (q element))
           else
             (* Check for param_name=value format *)
             let eq_pos = try Some (String.index params '=') with Not_found -> None in
             (match eq_pos with
             | None ->
               Some (Printf.sprintf
-                "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Parameter value missing."
-                value attr_name element)
+                "Bad value %s for attribute %s on element %s: Bad MIME type: Parameter value missing."
+                (q value) (q attr_name) (q element))
             | Some _ -> None)
         | None -> None)
       else
···
           let params_trimmed = String.trim params in
           if params_trimmed = "" then
             Some (Printf.sprintf
-              "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Semicolon seen but there was no parameter following it."
-              value attr_name element)
+              "Bad value %s for attribute %s on element %s: Bad MIME type: Semicolon seen but there was no parameter following it."
+              (q value) (q attr_name) (q element))
           else
             (* Check for param_name=value format *)
             let eq_pos = try Some (String.index params '=') with Not_found -> None in
             (match eq_pos with
             | None ->
               Some (Printf.sprintf
-                "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Parameter value missing."
-                value attr_name element)
+                "Bad value %s for attribute %s on element %s: Bad MIME type: Parameter value missing."
+                (q value) (q attr_name) (q element))
             | Some eq_pos ->
               let param_value = String.sub params (eq_pos + 1) (String.length params - eq_pos - 1) in
               let param_value_trimmed = String.trim param_value in
               if param_value_trimmed = "" then
                 Some (Printf.sprintf
-                  "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Parameter value missing."
-                  value attr_name element)
+                  "Bad value %s for attribute %s on element %s: Bad MIME type: Parameter value missing."
+                  (q value) (q attr_name) (q element))
               else if param_value_trimmed.[0] = '"' then
                 (* Quoted string - check for closing quote *)
                 let quote_end = try Some (String.index_from param_value_trimmed 1 '"') with
···
                   in
                   if has_backslash_at_end then
                     Some (Printf.sprintf
-                      "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Unfinished quoted string."
-                      value attr_name element)
+                      "Bad value %s for attribute %s on element %s: Bad MIME type: Unfinished quoted string."
+                      (q value) (q attr_name) (q element))
                   else
                     Some (Printf.sprintf
-                      "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Unfinished quoted string."
-                      value attr_name element))
+                      "Bad value %s for attribute %s on element %s: Bad MIME type: Unfinished quoted string."
+                      (q value) (q attr_name) (q element)))
               else
                 None))
 

lib/htmlrw_check/specialized/svg_checker.ml

···
 
     Validates SVG elements and attributes according to SVG 1.1/2 specifications. *)
 
+let q = Error_code.q
+
 type font_state = {
   mutable has_missing_glyph : bool;
 }
···
       if value <> svg_ns_url then
         Message_collector.add_typed collector
           (`Attr (`Bad_value_generic (`Message (Printf.sprintf
-            "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for the attribute \xe2\x80\x9cxmlns\xe2\x80\x9d (only \xe2\x80\x9c%s\xe2\x80\x9d permitted here)."
-            value svg_ns_url))))
+            "Bad value %s for the attribute %s (only %s permitted here)."
+            (q value) (q "xmlns") (q svg_ns_url)))))
   | "xmlns:xlink" ->
       if value <> "http://www.w3.org/1999/xlink" then
         Message_collector.add_typed collector
           (`Attr (`Bad_value_generic (`Message (Printf.sprintf
-            "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for the attribute \xe2\x80\x9cxmlns:link\xe2\x80\x9d (only \xe2\x80\x9chttp://www.w3.org/1999/xlink\xe2\x80\x9d permitted here)."
-            value))))
+            "Bad value %s for the attribute %s (only %s permitted here)."
+            (q value) (q "xmlns:link") (q "http://www.w3.org/1999/xlink")))))
   | _ when String.starts_with ~prefix:"xmlns:" attr && attr <> "xmlns:xlink" ->
       (* Other xmlns declarations are not allowed in HTML-embedded SVG *)
       Message_collector.add_typed collector
···
         let context = String.sub d !context_start (ctx_end - !context_start) in
         Message_collector.add_typed collector
           (`Attr (`Bad_value_generic (`Message (Printf.sprintf
-            "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9cd\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad SVG path data: Expected command but found \xe2\x80\x9c#\xe2\x80\x9d (context: \xe2\x80\x9c%s\xe2\x80\x9d)."
-            d element context))));
+            "Bad value %s for attribute %s on element %s: Bad SVG path data: Expected command but found %s (context: %s)."
+            (q d) (q "d") (q element) (q "#") (q context)))));
         i := len (* Stop processing *)
     | _ ->
         incr i
···
       let context = String.sub d ctx_start (flag_end - ctx_start) in
       Message_collector.add_typed collector
         (`Attr (`Bad_value_generic (`Message (Printf.sprintf
-          "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9cd\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad SVG path data: Expected \xe2\x80\x9c0\xe2\x80\x9d or \xe2\x80\x9c1\xe2\x80\x9d for large-arc-flag for \xe2\x80\x9ca\xe2\x80\x9d command but found \xe2\x80\x9c%s\xe2\x80\x9d instead (context: \xe2\x80\x9c%s\xe2\x80\x9d)."
-          d element flag context))))
+          "Bad value %s for attribute %s on element %s: Bad SVG path data: Expected %s or %s for large-arc-flag for %s command but found %s instead (context: %s)."
+          (q d) (q "d") (q element) (q "0") (q "1") (q "a") (q flag) (q context)))))
     end
   with Not_found -> ()
 

lib/htmlrw_check/specialized/url_checker.ml

···
 (** URL validation checker for href, src, action, and other URL attributes. *)
 
+(** Quote helper for consistent message formatting. *)
+let q = Error_code.q
+
 (** Attributes that contain URLs and should be validated.
     Note: srcset uses special microsyntax, not validated as URL here.
     Note: input[value] is only checked for type="url", handled specially below. *)
···
 let validate_ipv6_host host url attr_name element_name =
   (* Host should be in format [xxxx:...] *)
   if String.length host < 3 then
-    Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Invalid host: Illegal character."
-      url attr_name element_name)
+    Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Invalid host: Illegal character."
+      (q url) (q attr_name) (q element_name))
   else begin
     (* Check if all characters are valid IPv6 chars *)
     let invalid_char = String.exists (fun c -> not (is_valid_ipv6_char c)) host in
     if invalid_char then
-      Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Invalid host: Illegal character."
-        url attr_name element_name)
+      Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Invalid host: Illegal character."
+        (q url) (q attr_name) (q element_name))
     else
       None
   end
···
     let _ = contains_invalid_unicode decoded in
     None
   with Exit ->
-    Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Invalid host: A label or domain name contains disallowed characters.."
-      url attr_name element_name)
+    Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Invalid host: A label or domain name contains disallowed characters.."
+      (q url) (q attr_name) (q element_name))
 
 (** Check if string contains a character (checking both ASCII and UTF-8 fullwidth variants). *)
 let contains_percent_char s =
···
   let decoded = percent_decode host in
   (* Check for % character in decoded host - this catches fullwidth percent signs etc. *)
   if contains_percent_char decoded then
-    Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Invalid host: Illegal character in domain: \xe2\x80\x9c%%\xe2\x80\x9d is not allowed."
-      url attr_name element_name)
+    Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Invalid host: Illegal character in domain: %s is not allowed."
+      (q url) (q attr_name) (q element_name) (q "%"))
   else
     None
 
···
     ) port;
     match !invalid_char with
     | Some c ->
-      Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Illegal character in port: \xe2\x80\x9c%c\xe2\x80\x9d is not allowed."
-        url attr_name element_name c)
+      Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Illegal character in port: %s is not allowed."
+        (q url) (q attr_name) (q element_name) (q (String.make 1 c)))
     | None ->
       (* Check port range *)
       try
         let port_num = int_of_string port in
         if port_num >= 65536 then
-          Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Port number must be less than 65536."
-            url attr_name element_name)
+          Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Port number must be less than 65536."
+            (q url) (q attr_name) (q element_name))
         else
           None
       with _ -> None
···
     (* Check for empty host *)
     let requires_host = List.mem scheme special_schemes in
     if host = "" && requires_host && scheme <> "file" then
-      Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Invalid host: empty host."
-        url attr_name element_name)
+      Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Invalid host: empty host."
+        (q url) (q attr_name) (q element_name))
     else
       (* Check for invalid chars *)
       let invalid_char =
···
       in
       match invalid_char with
       | Some c ->
-        Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Invalid host: Illegal character in domain: \xe2\x80\x9c%c\xe2\x80\x9d is not allowed."
-          url attr_name element_name c)
+        Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Invalid host: Illegal character in domain: %s is not allowed."
+          (q url) (q attr_name) (q element_name) (q (String.make 1 c)))
       | None ->
         (* Check for | *)
         if String.contains host '|' && not (is_pipe_allowed_in_host url host) then
-          Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Invalid host: Illegal character in domain: \xe2\x80\x9c|\xe2\x80\x9d is not allowed."
-            url attr_name element_name)
+          Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Invalid host: Illegal character in domain: %s is not allowed."
+            (q url) (q attr_name) (q element_name) (q "|"))
         (* Check for backslash in host *)
         else if String.contains host '\\' then
-          Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Invalid host: Illegal character in domain: \xe2\x80\x9c\\\xe2\x80\x9d is not allowed."
-            url attr_name element_name)
+          Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Invalid host: Illegal character in domain: %s is not allowed."
+            (q url) (q attr_name) (q element_name) (q "\\"))
         (* Check for space in host *)
         else if String.contains host ' ' then
-          Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Invalid host: Illegal character in domain: space is not allowed."
-            url attr_name element_name)
+          Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Invalid host: Illegal character in domain: space is not allowed."
+            (q url) (q attr_name) (q element_name))
         (* Check for invalid percent-encoded Unicode in host *)
         else begin
           match check_invalid_percent_encoded_unicode host url attr_name element_name with
···
       let colon_pos = String.index url ':' in
       let after_colon = String.sub url (colon_pos + 1) (String.length url - colon_pos - 1) in
       if String.length after_colon < 2 || after_colon.[0] <> '/' || after_colon.[1] <> '/' then
-        Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Expected a slash (\"/\")."
-          url attr_name element_name)
+        Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Expected a slash (\"/\")."
+          (q url) (q attr_name) (q element_name))
       else
         None
     end else
···
   | Some scheme ->
     if scheme = "data" && String.contains url '#' then
       let url_type = if is_absolute_url then "Bad absolute URL:" else "Bad URL:" in
-      Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: %s Fragment is not allowed for data: URIs according to RFC 2397."
-        url attr_name element_name url_type)
+      Some (Printf.sprintf "Bad value %s for attribute %s on element %s: %s Fragment is not allowed for data: URIs according to RFC 2397."
+        (q url) (q attr_name) (q element_name) url_type)
     else
       None
 
···
       let after_colon = String.sub url (colon_pos + 1) (String.length url - colon_pos - 1) in
       (* data: URLs should NOT start with / - format is data:[mediatype][;base64],data *)
       if String.length after_colon > 0 && after_colon.[0] = '/' then
-        Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Expected a token character or a semicolon but saw \xe2\x80\x9c/\xe2\x80\x9d instead."
-          url attr_name element_name)
+        Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Expected a token character or a semicolon but saw %s instead."
+          (q url) (q attr_name) (q element_name) (q "/"))
       else
         None
     end else
···
       let scheme_data = String.sub url (colon_pos + 1) (String.length url - colon_pos - 1) in
       (* Check for tab in scheme data *)
       if String.contains scheme_data '\t' then
-        Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Illegal character in scheme data: tab is not allowed."
-          url attr_name element_name)
+        Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Illegal character in scheme data: tab is not allowed."
+          (q url) (q attr_name) (q element_name))
       (* Check for newline in scheme data *)
       else if String.contains scheme_data '\n' then
-        Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Illegal character in scheme data: line break is not allowed."
-          url attr_name element_name)
+        Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Illegal character in scheme data: line break is not allowed."
+          (q url) (q attr_name) (q element_name))
       (* Check for carriage return in scheme data *)
       else if String.contains scheme_data '\r' then
-        Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Illegal character in scheme data: line break is not allowed."
-          url attr_name element_name)
+        Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Illegal character in scheme data: line break is not allowed."
+          (q url) (q attr_name) (q element_name))
       (* Check for space in scheme data *)
       else if String.contains scheme_data ' ' then
-        Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Illegal character in scheme data: space is not allowed."
-          url attr_name element_name)
+        Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Illegal character in scheme data: space is not allowed."
+          (q url) (q attr_name) (q element_name))
       else
         None
     end else
···
   let path = remove_query_fragment raw_path in
   (* Check for space in path (not allowed) *)
   if String.contains path ' ' then
-    Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Illegal character in path segment: space is not allowed."
-      url attr_name element_name)
+    Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Illegal character in path segment: space is not allowed."
+      (q url) (q attr_name) (q element_name))
   (* Check for pipe in path (not allowed except in file:// authority) *)
   else if String.contains path '|' then
-    Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Illegal character in path segment: \xe2\x80\x9c|\xe2\x80\x9d is not allowed."
-      url attr_name element_name)
+    Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Illegal character in path segment: %s is not allowed."
+      (q url) (q attr_name) (q element_name) (q "|"))
   (* Check for unescaped square brackets in path *)
   else if String.contains path '[' then
-    Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Illegal character in path segment: \xe2\x80\x9c[\xe2\x80\x9d is not allowed."
-      url attr_name element_name)
+    Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Illegal character in path segment: %s is not allowed."
+      (q url) (q attr_name) (q element_name) (q "["))
   else
     None
 
···
   | None ->
     (* Check for square brackets at start (not IPv6 - that requires scheme) *)
     if String.length url > 0 && url.[0] = '[' then
-      Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Illegal character in path segment: \xe2\x80\x9c[\xe2\x80\x9d is not allowed."
-        url attr_name element_name)
+      Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Illegal character in path segment: %s is not allowed."
+        (q url) (q attr_name) (q element_name) (q "["))
     else
       None
 
···
       if i + 2 < len && is_hex_digit url.[i + 1] && is_hex_digit url.[i + 2] then
         find_bare_percent (i + 3)  (* Valid percent encoding, continue *)
       else
-        Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Percentage (\xe2\x80\x9c%%\xe2\x80\x9d) is not followed by two hexadecimal digits."
-          url attr_name element_name)
+        Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Percentage (%s) is not followed by two hexadecimal digits."
+          (q url) (q attr_name) (q element_name) (q "%"))
     end else
       find_bare_percent (i + 1)
   in
···
     let query = String.sub url (query_start + 1) (query_end - query_start - 1) in
     (* Check for unescaped space in query *)
     if String.contains query ' ' then
-      Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Illegal character in query: space is not allowed."
-        url attr_name element_name)
+      Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Illegal character in query: space is not allowed."
+        (q url) (q attr_name) (q element_name))
     else
       None
   with Not_found -> None  (* No query string *)
···
     let fragment = String.sub url (fragment_start + 1) (String.length url - fragment_start - 1) in
     (* Check for backslash in fragment *)
     if String.contains fragment '\\' then
-      Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Illegal character in fragment: \xe2\x80\x9c\\\xe2\x80\x9d is not allowed."
-        url attr_name element_name)
+      Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Illegal character in fragment: %s is not allowed."
+        (q url) (q attr_name) (q element_name) (q "\\"))
     (* Check for second hash in fragment *)
     else if String.contains fragment '#' then
-      Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Illegal character in fragment: \xe2\x80\x9c#\xe2\x80\x9d is not allowed."
-        url attr_name element_name)
+      Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Illegal character in fragment: %s is not allowed."
+        (q url) (q attr_name) (q element_name) (q "#"))
     (* Check for space in fragment *)
     else if String.contains fragment ' ' then
-      Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Illegal character in fragment: space is not allowed."
-        url attr_name element_name)
+      Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Illegal character in fragment: space is not allowed."
+        (q url) (q attr_name) (q element_name))
     else
       None
   with Not_found -> None  (* No fragment *)
···
       let userinfo = String.sub authority 0 at in
       (* Check for @ in userinfo (should be percent-encoded) *)
       if String.contains userinfo '@' then
-        Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: User or password contains an at symbol (\xe2\x80\x9c@\xe2\x80\x9d) not percent-encoded."
-          url attr_name element_name)
+        Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: User or password contains an at symbol (%s) not percent-encoded."
+          (q url) (q attr_name) (q element_name) (q "@"))
       (* Check for space *)
       else if String.contains userinfo ' ' then
-        Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Illegal character in user or password: space is not allowed."
-          url attr_name element_name)
+        Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Illegal character in user or password: space is not allowed."
+          (q url) (q attr_name) (q element_name))
       else begin
         (* Check for non-ASCII characters (like emoji) using UTF-8 decoding *)
         let find_non_ascii_char userinfo =
···
         in
         match find_non_ascii_char userinfo with
         | Some bad_char ->
-          Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Illegal character in user or password: \xe2\x80\x9c%s\xe2\x80\x9d is not allowed."
-            url attr_name element_name bad_char)
+          Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Illegal character in user or password: %s is not allowed."
+            (q url) (q attr_name) (q element_name) (q bad_char))
         | None ->
           (* Check for other invalid chars *)
           let invalid = List.find_opt (fun c -> String.contains userinfo c) invalid_userinfo_chars in
           match invalid with
           | Some c ->
-            Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Illegal character in user or password: \xe2\x80\x9c%c\xe2\x80\x9d is not allowed."
-              url attr_name element_name c)
+            Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Illegal character in user or password: %s is not allowed."
+              (q url) (q attr_name) (q element_name) (q (String.make 1 c)))
           | None -> None
       end
   with _ -> None
···
     let attr_lower = String.lowercase_ascii attr_name in
     if List.mem attr_lower must_be_non_empty ||
        List.mem (name_lower, attr_lower) must_be_non_empty_combinations then
-      Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Must be non-empty."
-        original_url attr_name element_name)
+      Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Must be non-empty."
+        (q original_url) (q attr_name) (q element_name))
     else
       None
   end
···
         let last = original_url.[String.length original_url - 1] in
         last = ' ' || last = '\t' in
       if has_leading || has_trailing then
-        Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Illegal character: leading/trailing ASCII whitespace."
-          original_url attr_name element_name)
+        Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Illegal character: leading/trailing ASCII whitespace."
+          (q original_url) (q attr_name) (q element_name))
       else None
     (* Check scheme data for non-special schemes FIRST - handles tab/newline/CR in scheme data *)
     else begin
···
       | None ->
       (* Check for newlines/tabs in special scheme URLs *)
       if String.contains url '\n' || String.contains url '\r' || String.contains url '\t' then
-        Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Tab, new line or carriage return found."
-          url attr_name element_name)
+        Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Tab, new line or carriage return found."
+          (q url) (q attr_name) (q element_name))
       else begin
       (* Check for relative URL issues first *)
       match check_relative_url url attr_name element_name with
···
 
       (* Check for backslash AFTER special scheme check *)
       if String.contains url '\\' then
-        Some (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad URL: Backslash (\"\\\") used as path segment delimiter."
-          url attr_name element_name)
+        Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Backslash (\"\\\") used as path segment delimiter."
+          (q url) (q attr_name) (q element_name))
       else
 
       (* Check path segment for illegal characters *)