pp

lib/html5rw/dom/dom.mli

···
   system_id : string option;  (** System identifier (legacy, rarely used) *)
 }
 
+val pp_doctype_data : Format.formatter -> doctype_data -> unit
+(** Pretty-print DOCTYPE data. *)
+
 (** Quirks mode setting for the document.
 
     {i Quirks mode} is a browser rendering mode that emulates bugs and
···
          WHATWG: How the parser determines quirks mode
 *)
 type quirks_mode = Dom_node.quirks_mode = No_quirks | Quirks | Limited_quirks
+
+val pp_quirks_mode : Format.formatter -> quirks_mode -> unit
+(** Pretty-print quirks mode. *)
 
 (** A DOM node in the parsed document tree.
 
···
 
       Only doctype nodes use this field; for all other nodes it is [None]. *)
 }
+
+val pp : Format.formatter -> node -> unit
+(** Pretty-print a DOM node. Prints a summary representation showing the
+    node type and key attributes. Does not recursively print children. *)
 
 (** {1 Node Name Constants}
 

lib/html5rw/dom/dom_node.ml

···
     ) node.template_content
   end;
   new_node
+
+(* Pretty printers *)
+let pp_doctype_data fmt (d : doctype_data) =
+  Format.fprintf fmt "<!DOCTYPE %s%s%s>"
+    (Option.value ~default:"" d.name)
+    (match d.public_id with Some p -> " PUBLIC \"" ^ p ^ "\"" | None -> "")
+    (match d.system_id with Some s -> " \"" ^ s ^ "\"" | None -> "")
+
+let pp_quirks_mode fmt = function
+  | No_quirks -> Format.pp_print_string fmt "no-quirks"
+  | Quirks -> Format.pp_print_string fmt "quirks"
+  | Limited_quirks -> Format.pp_print_string fmt "limited-quirks"
+
+let pp fmt node =
+  if is_text node then
+    Format.fprintf fmt "#text %S" node.data
+  else if is_comment node then
+    Format.fprintf fmt "<!-- %s -->" node.data
+  else if is_document node then
+    Format.pp_print_string fmt "#document"
+  else if is_document_fragment node then
+    Format.pp_print_string fmt "#document-fragment"
+  else if is_doctype node then
+    (match node.doctype with
+     | Some d -> pp_doctype_data fmt d
+     | None -> Format.pp_print_string fmt "<!DOCTYPE>")
+  else begin
+    Format.fprintf fmt "<%s" node.name;
+    List.iter (fun (k, v) -> Format.fprintf fmt " %s=%S" k v) node.attrs;
+    Format.pp_print_char fmt '>'
+  end

lib/html5rw/dom/dom_node.mli

···
   system_id : string option;  (** System identifier (legacy, rarely used) *)
 }
 
+val pp_doctype_data : Format.formatter -> doctype_data -> unit
+(** Pretty-print DOCTYPE data. *)
+
 (** Quirks mode setting for the document.
 
     {i Quirks mode} is a browser rendering mode that emulates bugs and
···
          WHATWG: How the parser determines quirks mode
 *)
 type quirks_mode = No_quirks | Quirks | Limited_quirks
+
+val pp_quirks_mode : Format.formatter -> quirks_mode -> unit
+(** Pretty-print quirks mode. *)
 
 (** A DOM node in the parsed document tree.
 
···
 
       Only doctype nodes use this field; for all other nodes it is [None]. *)
 }
+
+val pp : Format.formatter -> node -> unit
+(** Pretty-print a DOM node. Prints a summary representation showing the
+    node type and key attributes. Does not recursively print children. *)
 
 (** {1 Node Name Constants}
 

lib/html5rw/encoding/encoding.ml

···
     ]}
 *)
 let decode = Encoding_decode.decode
+
+let pp fmt enc = Format.pp_print_string fmt (encoding_to_string enc)

lib/html5rw/encoding/encoding.mli

···
   | Iso_8859_2   (** ISO-8859-2 (Central European) *)
   | Euc_jp       (** EUC-JP (Japanese) *)
 
+val pp : Format.formatter -> encoding -> unit
+(** Pretty-print an encoding using its canonical label. *)
+
 (** {1 Encoding Utilities} *)
 
 val encoding_to_string : encoding -> string

lib/html5rw/html5rw.ml

···
 (** DOM node type. See {!Dom} for manipulation functions. *)
 type node = Dom.node
 
+let pp_node = Dom.pp
+
 (** Doctype information *)
 type doctype_data = Dom.doctype_data = {
   name : string option;
···
   system_id : string option;
 }
 
+let pp_doctype_data = Dom.pp_doctype_data
+
 (** Quirks mode as determined during parsing *)
 type quirks_mode = Dom.quirks_mode = No_quirks | Quirks | Limited_quirks
 
+let pp_quirks_mode = Dom.pp_quirks_mode
+
 (** Character encoding detected or specified *)
 type encoding = Encoding.encoding =
   | Utf8
···
   | Windows_1252
   | Iso_8859_2
   | Euc_jp
+
+let pp_encoding = Encoding.pp
 
 (** Parse error record *)
 type parse_error = Parser.parse_error
···
 (** Get the namespace from a fragment context *)
 let fragment_context_namespace = Parser.fragment_context_namespace
 
+let pp_fragment_context = Parser.pp_fragment_context
+
 (** Get the error code *)
 let error_code = Parser.error_code
 
···
 
 (** Get the column number of an error (1-indexed) *)
 let error_column = Parser.error_column
+
+let pp_parse_error = Parser.pp_parse_error
 
 (** Result of parsing an HTML document *)
 type t = {
···
   errors : parse_error list;
   encoding : encoding option;
 }
+
+let pp fmt t =
+  Format.fprintf fmt "{root=%a; errors=%d; encoding=%a}"
+    pp_node t.root
+    (List.length t.errors)
+    (Format.pp_print_option pp_encoding) t.encoding
 
 (* Internal: convert Parser.t to our t *)
 let of_parser_result (p : Parser.t) : t =

lib/html5rw/html5rw.mli

···
          WHATWG: The DOM *)
 type node = Dom.node
 
+val pp_node : Format.formatter -> node -> unit
+(** Pretty-print a DOM node. Prints a summary representation showing the
+    node type and key attributes. Does not recursively print children. *)
+
 (** DOCTYPE information.
 
     The DOCTYPE declaration ([<!DOCTYPE html>]) appears at the start of HTML
···
   (** System identifier (URL) for legacy DOCTYPEs *)
 }
 
+val pp_doctype_data : Format.formatter -> doctype_data -> unit
+(** Pretty-print DOCTYPE data. *)
+
 (** Quirks mode as determined during parsing.
 
     {i Quirks mode} controls how browsers render CSS and compute layouts.
···
     @see <https://html.spec.whatwg.org/multipage/parsing.html#the-initial-insertion-mode>
          WHATWG: How quirks mode is determined *)
 type quirks_mode = Dom.quirks_mode = No_quirks | Quirks | Limited_quirks
+
+val pp_quirks_mode : Format.formatter -> quirks_mode -> unit
+(** Pretty-print quirks mode. *)
 
 (** Character encoding detected or specified.
 
···
   | Euc_jp
   (** EUC-JP: Extended Unix Code for Japanese *)
 
+val pp_encoding : Format.formatter -> encoding -> unit
+(** Pretty-print an encoding using its canonical label. *)
+
 (** A parse error encountered during HTML5 parsing.
 
     HTML5 parsing {b never fails} - the specification defines error recovery
···
 
     Column numbers count from 1 and reset at each newline. *)
 val error_column : parse_error -> int
+
+val pp_parse_error : Format.formatter -> parse_error -> unit
+(** Pretty-print a parse error with location information. *)
 
 (** {1 Error Handling} *)
 
···
 (** Get the namespace of a fragment context. *)
 val fragment_context_namespace : fragment_context -> string option
 
+val pp_fragment_context : Format.formatter -> fragment_context -> unit
+(** Pretty-print a fragment context. *)
+
 (** Result of parsing an HTML document.
 
     This record contains everything produced by parsing:
···
       encoding detection, and [None] when using {!parse} (which expects
       pre-decoded UTF-8 input). *)
 }
+
+val pp : Format.formatter -> t -> unit
+(** Pretty-print a parse result summary. *)
 
 (** {1 Parsing Functions} *)
 

lib/html5rw/parse_error_code.ml

···
 let is_whatwg_standard = function
   | Tree_construction_error _ -> false
   | _ -> true
+
+let pp fmt t = Format.pp_print_string fmt (to_string t)

lib/html5rw/parse_error_code.mli

···
 (** Check if an error code is defined in the WHATWG specification.
 
     Returns [false] for [Tree_construction_error _], [true] for all others. *)
+
+val pp : Format.formatter -> t -> unit
+(** Pretty-print an error code using the WHATWG specification string format. *)

lib/html5rw/parser/parser.ml

···
 let root t = t.Parser_impl.root
 let errors t = t.Parser_impl.errors
 let encoding t = t.Parser_impl.encoding
+
+(* Pretty printers *)
+let pp_parse_error fmt (e : parse_error) =
+  Format.fprintf fmt "(%d,%d): %a" e.line e.column Parse_error_code.pp e.code
+
+let pp_fragment_context fmt (ctx : fragment_context) =
+  Format.fprintf fmt "<%s%s>"
+    ctx.tag_name
+    (match ctx.namespace with Some ns -> " xmlns=" ^ ns | None -> "")
+
+let pp fmt t =
+  Format.fprintf fmt "{root=%a; errors=%d; encoding=%a}"
+    Dom.pp t.Parser_impl.root
+    (List.length t.Parser_impl.errors)
+    (Format.pp_print_option Encoding.pp) t.Parser_impl.encoding

lib/html5rw/parser/parser.mli

···
     not bytes or grapheme clusters. *)
 val error_column : parse_error -> int
 
+val pp_parse_error : Format.formatter -> parse_error -> unit
+(** Pretty-print a parse error with location information. *)
+
 (** Context element for HTML fragment parsing.
 
     When parsing HTML fragments (the content that would be assigned to
···
 
 (** Get the namespace of a fragment context ([None] for HTML). *)
 val fragment_context_namespace : fragment_context -> string option
+
+val pp_fragment_context : Format.formatter -> fragment_context -> unit
+(** Pretty-print a fragment context. *)
 
 (** Result of parsing an HTML document or fragment.
 
···
     @see <https://html.spec.whatwg.org/multipage/parsing.html#determining-the-character-encoding>
          WHATWG: Determining the character encoding *)
 val encoding : t -> Encoding.encoding option
+
+val pp : Format.formatter -> t -> unit
+(** Pretty-print a parse result summary. *)
 
 (** {1 Querying} *)
 

lib/html5rw/selector/selector.mli

···
 
   val to_human_string : t -> string
   (** Convert to a human-readable error message. *)
+
+  val pp : Format.formatter -> t -> unit
+  (** Pretty-print a selector error code. *)
 end
 
 (** {1 Exceptions} *)
···
   val make_compound : simple_selector list -> compound_selector
   val make_complex : (string option * compound_selector) list -> complex_selector
   val make_list : complex_selector list -> selector_list
+
+  val pp_simple_selector_type : Format.formatter -> simple_selector_type -> unit
+  (** Pretty-print a simple selector type. *)
+
+  val pp_simple_selector : Format.formatter -> simple_selector -> unit
+  (** Pretty-print a simple selector. *)
+
+  val pp_compound_selector : Format.formatter -> compound_selector -> unit
+  (** Pretty-print a compound selector. *)
+
+  val pp_complex_selector : Format.formatter -> complex_selector -> unit
+  (** Pretty-print a complex selector. *)
+
+  val pp_selector_list : Format.formatter -> selector_list -> unit
+  (** Pretty-print a selector list. *)
+
+  val pp : Format.formatter -> selector -> unit
+  (** Pretty-print a selector. *)
 end
 
 (** Token types for the selector lexer. *)

lib/html5rw/selector/selector_ast.ml

···
 let make_complex parts : complex_selector = { parts }
 
 let make_list (selectors : complex_selector list) : selector_list = { selectors }
+
+(* Pretty printers *)
+let pp_simple_selector_type fmt = function
+  | Type_tag -> Format.pp_print_string fmt "tag"
+  | Type_id -> Format.pp_print_string fmt "id"
+  | Type_class -> Format.pp_print_string fmt "class"
+  | Type_universal -> Format.pp_print_string fmt "universal"
+  | Type_attr -> Format.pp_print_string fmt "attr"
+  | Type_pseudo -> Format.pp_print_string fmt "pseudo"
+
+let pp_simple_selector fmt s =
+  Format.fprintf fmt "%a" pp_simple_selector_type s.selector_type;
+  Option.iter (Format.fprintf fmt "(%s)") s.name;
+  Option.iter (Format.fprintf fmt "[%s]") s.operator;
+  Option.iter (Format.fprintf fmt "=%S") s.value;
+  Option.iter (Format.fprintf fmt "(%s)") s.arg
+
+let pp_compound_selector fmt (c : compound_selector) =
+  Format.pp_print_list ~pp_sep:(fun fmt () -> Format.pp_print_char fmt ' ')
+    pp_simple_selector fmt c.selectors
+
+let pp_complex_selector fmt c =
+  let pp_part fmt (comb, compound) =
+    Option.iter (Format.fprintf fmt " %s ") comb;
+    pp_compound_selector fmt compound
+  in
+  List.iter (pp_part fmt) c.parts
+
+let pp_selector_list fmt l =
+  Format.pp_print_list ~pp_sep:(fun fmt () -> Format.pp_print_string fmt ", ")
+    pp_complex_selector fmt l.selectors
+
+let pp fmt = function
+  | Simple s -> pp_simple_selector fmt s
+  | Compound c -> pp_compound_selector fmt c
+  | Complex c -> pp_complex_selector fmt c
+  | List l -> pp_selector_list fmt l

lib/html5rw/selector/selector_error_code.ml

···
   | Expected_selector_after_combinator -> "Expected selector after combinator"
   | Unexpected_token -> "Unexpected token"
   | Expected_end_of_selector -> "Expected end of selector"
+
+let pp fmt t = Format.pp_print_string fmt (to_string t)

lib/html5rw/selector/selector_error_code.mli

···
     - [to_human_string Empty_selector] returns ["Empty selector"]
     - [to_human_string Expected_closing_bracket] returns ["Expected \]"]
 *)
+
+val pp : Format.formatter -> t -> unit
+(** Pretty-print a selector error code using its kebab-case string form. *)

lib/html5rw/tokenizer/tokenizer.mli

···
   val make_comment : string -> t
   val make_character : string -> t
   val eof : t
+
+  val pp_tag_kind : Format.formatter -> tag_kind -> unit
+  (** Pretty-print a tag kind (Start or End). *)
+
+  val pp_doctype : Format.formatter -> doctype -> unit
+  (** Pretty-print a DOCTYPE token. *)
+
+  val pp_tag : Format.formatter -> tag -> unit
+  (** Pretty-print a tag token. *)
+
+  val pp : Format.formatter -> t -> unit
+  (** Pretty-print a token. *)
 end
 
 (** Tokenizer states. *)
···
     | Hexadecimal_character_reference
     | Decimal_character_reference
     | Numeric_character_reference_end
+
+  val pp : Format.formatter -> t -> unit
+  (** Pretty-print a tokenizer state. *)
 end
 
 (** Parse error types. *)
···
   (** Create an error with a typed error code. *)
 
   val to_string : t -> string
+
+  val pp : Format.formatter -> t -> unit
+  (** Pretty-print a tokenizer error. *)
 end
 
 (** Input stream with position tracking. *)

lib/html5rw/tokenizer/tokenizer_errors.ml

···
 let to_string err =
   Printf.sprintf "(%d,%d): %s" err.line err.column
     (Parse_error_code.to_string err.code)
+
+let pp fmt err =
+  Format.fprintf fmt "(%d,%d): %a" err.line err.column
+    Parse_error_code.pp err.code

lib/html5rw/tokenizer/tokenizer_state.ml

···
   | Hexadecimal_character_reference
   | Decimal_character_reference
   | Numeric_character_reference_end
+
+let pp fmt t =
+  let s = match t with
+    | Data -> "Data"
+    | Rcdata -> "Rcdata"
+    | Rawtext -> "Rawtext"
+    | Script_data -> "Script_data"
+    | Plaintext -> "Plaintext"
+    | Tag_open -> "Tag_open"
+    | End_tag_open -> "End_tag_open"
+    | Tag_name -> "Tag_name"
+    | Rcdata_less_than_sign -> "Rcdata_less_than_sign"
+    | Rcdata_end_tag_open -> "Rcdata_end_tag_open"
+    | Rcdata_end_tag_name -> "Rcdata_end_tag_name"
+    | Rawtext_less_than_sign -> "Rawtext_less_than_sign"
+    | Rawtext_end_tag_open -> "Rawtext_end_tag_open"
+    | Rawtext_end_tag_name -> "Rawtext_end_tag_name"
+    | Script_data_less_than_sign -> "Script_data_less_than_sign"
+    | Script_data_end_tag_open -> "Script_data_end_tag_open"
+    | Script_data_end_tag_name -> "Script_data_end_tag_name"
+    | Script_data_escape_start -> "Script_data_escape_start"
+    | Script_data_escape_start_dash -> "Script_data_escape_start_dash"
+    | Script_data_escaped -> "Script_data_escaped"
+    | Script_data_escaped_dash -> "Script_data_escaped_dash"
+    | Script_data_escaped_dash_dash -> "Script_data_escaped_dash_dash"
+    | Script_data_escaped_less_than_sign -> "Script_data_escaped_less_than_sign"
+    | Script_data_escaped_end_tag_open -> "Script_data_escaped_end_tag_open"
+    | Script_data_escaped_end_tag_name -> "Script_data_escaped_end_tag_name"
+    | Script_data_double_escape_start -> "Script_data_double_escape_start"
+    | Script_data_double_escaped -> "Script_data_double_escaped"
+    | Script_data_double_escaped_dash -> "Script_data_double_escaped_dash"
+    | Script_data_double_escaped_dash_dash -> "Script_data_double_escaped_dash_dash"
+    | Script_data_double_escaped_less_than_sign -> "Script_data_double_escaped_less_than_sign"
+    | Script_data_double_escape_end -> "Script_data_double_escape_end"
+    | Before_attribute_name -> "Before_attribute_name"
+    | Attribute_name -> "Attribute_name"
+    | After_attribute_name -> "After_attribute_name"
+    | Before_attribute_value -> "Before_attribute_value"
+    | Attribute_value_double_quoted -> "Attribute_value_double_quoted"
+    | Attribute_value_single_quoted -> "Attribute_value_single_quoted"
+    | Attribute_value_unquoted -> "Attribute_value_unquoted"
+    | After_attribute_value_quoted -> "After_attribute_value_quoted"
+    | Self_closing_start_tag -> "Self_closing_start_tag"
+    | Bogus_comment -> "Bogus_comment"
+    | Markup_declaration_open -> "Markup_declaration_open"
+    | Comment_start -> "Comment_start"
+    | Comment_start_dash -> "Comment_start_dash"
+    | Comment -> "Comment"
+    | Comment_less_than_sign -> "Comment_less_than_sign"
+    | Comment_less_than_sign_bang -> "Comment_less_than_sign_bang"
+    | Comment_less_than_sign_bang_dash -> "Comment_less_than_sign_bang_dash"
+    | Comment_less_than_sign_bang_dash_dash -> "Comment_less_than_sign_bang_dash_dash"
+    | Comment_end_dash -> "Comment_end_dash"
+    | Comment_end -> "Comment_end"
+    | Comment_end_bang -> "Comment_end_bang"
+    | Doctype -> "Doctype"
+    | Before_doctype_name -> "Before_doctype_name"
+    | Doctype_name -> "Doctype_name"
+    | After_doctype_name -> "After_doctype_name"
+    | After_doctype_public_keyword -> "After_doctype_public_keyword"
+    | Before_doctype_public_identifier -> "Before_doctype_public_identifier"
+    | Doctype_public_identifier_double_quoted -> "Doctype_public_identifier_double_quoted"
+    | Doctype_public_identifier_single_quoted -> "Doctype_public_identifier_single_quoted"
+    | After_doctype_public_identifier -> "After_doctype_public_identifier"
+    | Between_doctype_public_and_system_identifiers -> "Between_doctype_public_and_system_identifiers"
+    | After_doctype_system_keyword -> "After_doctype_system_keyword"
+    | Before_doctype_system_identifier -> "Before_doctype_system_identifier"
+    | Doctype_system_identifier_double_quoted -> "Doctype_system_identifier_double_quoted"
+    | Doctype_system_identifier_single_quoted -> "Doctype_system_identifier_single_quoted"
+    | After_doctype_system_identifier -> "After_doctype_system_identifier"
+    | Bogus_doctype -> "Bogus_doctype"
+    | Cdata_section -> "Cdata_section"
+    | Cdata_section_bracket -> "Cdata_section_bracket"
+    | Cdata_section_end -> "Cdata_section_end"
+    | Character_reference -> "Character_reference"
+    | Named_character_reference -> "Named_character_reference"
+    | Ambiguous_ampersand -> "Ambiguous_ampersand"
+    | Numeric_character_reference -> "Numeric_character_reference"
+    | Hexadecimal_character_reference_start -> "Hexadecimal_character_reference_start"
+    | Decimal_character_reference_start -> "Decimal_character_reference_start"
+    | Hexadecimal_character_reference -> "Hexadecimal_character_reference"
+    | Decimal_character_reference -> "Decimal_character_reference"
+    | Numeric_character_reference_end -> "Numeric_character_reference_end"
+  in
+  Format.pp_print_string fmt s

lib/html5rw/tokenizer/tokenizer_token.ml

···
 let make_character data = Character data
 
 let eof = EOF
+
+(* Pretty printers *)
+let pp_tag_kind fmt = function
+  | Start -> Format.pp_print_string fmt "Start"
+  | End -> Format.pp_print_string fmt "End"
+
+let pp_doctype fmt (d : doctype) =
+  Format.fprintf fmt "DOCTYPE{name=%a; public_id=%a; system_id=%a; force_quirks=%b}"
+    (Format.pp_print_option Format.pp_print_string) d.name
+    (Format.pp_print_option Format.pp_print_string) d.public_id
+    (Format.pp_print_option Format.pp_print_string) d.system_id
+    d.force_quirks
+
+let pp_tag fmt (t : tag) =
+  Format.fprintf fmt "<%s%s"
+    (match t.kind with Start -> "" | End -> "/")
+    t.name;
+  List.iter (fun (k, v) -> Format.fprintf fmt " %s=%S" k v) t.attrs;
+  if t.self_closing then Format.pp_print_string fmt " /";
+  Format.pp_print_char fmt '>'
+
+let pp fmt = function
+  | Tag t -> pp_tag fmt t
+  | Character s -> Format.fprintf fmt "Character %S" s
+  | Comment s -> Format.fprintf fmt "Comment %S" s
+  | Doctype d -> pp_doctype fmt d
+  | EOF -> Format.pp_print_string fmt "EOF"