docs: HTML validity fixes

Also minor wording fixes.

1 files changed, 19 insertions, 19 deletions

diff --git a/docs/manual.adoc b/docs/manual.adoc
index 30cb3ab..f968135 100644
--- a/docs/manual.adoc
+++ b/docs/manual.adoc
@@ -728,7 +728,7 @@ These flags control the resulting tree contents:
 
 * [[parse_ws_pcdata]]`parse_ws_pcdata` determines if PCDATA nodes (nodes with type <<node_pcdata,node_pcdata>>) that consist only of whitespace characters are to be put in DOM tree. Often whitespace-only data is not significant for the application, and the cost of allocating and storing such nodes (both memory and speed-wise) can be significant. For example, after parsing XML string `<node> <a/> </node>`, `<node>` element will have three children when `parse_ws_pcdata` is set (child with type <<node_pcdata,node_pcdata>> and value `" "`, child with type <<node_element,node_element>> and name `"a"`, and another child with type <<node_pcdata,node_pcdata>> and value `" "`), and only one child when `parse_ws_pcdata` is not set. This flag is *off* by default.
 
-* [[parse_ws_pcdata_single]]`parse_ws_pcdata_single` determines if whitespace-only PCDATA nodes that have no sibling nodes are to be put in DOM tree. In some cases application needs to parse the whitespace-only contents of nodes, i.e. `<node>  </node>`, but is not interested in whitespace markup elsewhere. It is possible to use <<parse_ws_pcdata,parse_ws_pcdata>> flag in this case, but it results in excessive allocations and complicates document processing in some cases; this flag is intended to avoid that. As an example, after parsing XML string `<node> <a>  </a> </node>` with `parse_ws_pcdata_single` flag set, `<node>` element will have one child `<a>`, and `<a>` element will have one child with type <<node_pcdata,node_pcdata>> and value `"  "`. This flag has no effect if <<parse_ws_pcdata,parse_ws_pcdata>> is enabled. This flag is *off* by default.
+* [[parse_ws_pcdata_single]]`parse_ws_pcdata_single` determines if whitespace-only PCDATA nodes that have no sibling nodes are to be put in DOM tree. In some cases application needs to parse the whitespace-only contents of nodes, i.e. `<node>  </node>`, but is not interested in whitespace markup elsewhere. It is possible to use <<parse_ws_pcdata,parse_ws_pcdata>> flag in this case, but it results in excessive allocations and complicates document processing; this flag can be used to avoid that. As an example, after parsing XML string `<node> <a>  </a> </node>` with `parse_ws_pcdata_single` flag set, `<node>` element will have one child `<a>`, and `<a>` element will have one child with type <<node_pcdata,node_pcdata>> and value `"  "`. This flag has no effect if <<parse_ws_pcdata,parse_ws_pcdata>> is enabled. This flag is *off* by default.
 
 * [[parse_fragment]]`parse_fragment` determines if document should be treated as a fragment of a valid XML. Parsing document as a fragment leads to top-level PCDATA content (i.e. text that is not located inside a node) to be added to a tree, and additionally treats documents without element nodes as valid. This flag is *off* by default.
 
@@ -738,7 +738,7 @@ These flags control the transformation of tree element contents:
 
 * [[parse_escapes]]`parse_escapes` determines if character and entity references are to be expanded during the parsing process. Character references have the form `&#...;` or `&#x...;` (`...` is Unicode numeric representation of character in either decimal (`&#...;`) or hexadecimal (`&#x...;`) form), entity references are `&lt;`, `&gt;`, `&amp;`, `&apos;` and `&quot;` (note that as pugixml does not handle DTD, the only allowed entities are predefined ones). If character/entity reference can not be expanded, it is left as is, so you can do additional processing later. Reference expansion is performed on attribute values and PCDATA content. This flag is *on* by default.
 
-* [[parse_eol]]`parse_eol` determines if EOL handling (that is, replacing sequences `0x0d 0x0a` by a single `0x0a` character, and replacing all standalone `0x0d` characters by `0x0a`) is to be performed on input data (that is, comments contents, PCDATA/CDATA contents and attribute values). This flag is *on* by default.
+* [[parse_eol]]`parse_eol` determines if EOL handling (that is, replacing sequences `\r\n` by a single `\n` character, and replacing all standalone `\r` characters by `\n`) is to be performed on input data (that is, comment contents, PCDATA/CDATA contents and attribute values). This flag is *on* by default.
 
 * [[parse_wconv_attribute]]`parse_wconv_attribute` determines if attribute value normalization should be performed for all attributes. This means, that whitespace characters (new line, tab and space) are replaced with space (`' '`). New line characters are always treated as if <<parse_eol,parse_eol>> is set, i.e. `\r\n` is converted to a single space.  This flag is *on* by default.
 
@@ -984,9 +984,9 @@ If your C{plus}{plus} compiler supports range-based for-loop (this is a C{plus}{
 
 [source,subs="+quotes"]
 ----
-_implementation-defined-type_ xml_node::children() const;
-_implementation-defined-type_ xml_node::children(const char_t* name) const;
-_implementation-defined-type_ xml_node::attributes() const;
+_implementation_-_defined_-_type_ xml_node::children() const;
+_implementation_-_defined_-_type_ xml_node::children(const char_t* name) const;
+_implementation_-_defined_-_type_ xml_node::attributes() const;
 ----
 
 `children` function allows you to enumerate all child nodes; `children` function with `name` argument allows you to enumerate all child nodes with a specific name; `attributes` function allows you to enumerate all attributes of the node. Note that you can also use node object itself in a range-based for construct, which is equivalent to using `children()`.
@@ -2474,10 +2474,10 @@ Macros:
 
 Types:
 
-[source,subs="+macros,+quotes"]
+[source,subs="+macros"]
 ----
-typedef _configuration-defined-type_ +++<a href="#char_t">char_t</a>+++;
-typedef _configuration-defined-type_ +++<a href="#string_t">string_t</a>+++;
+typedef configuration-defined-type +++<a href="#char_t">char_t</a>+++;
+typedef configuration-defined-type +++<a href="#string_t">string_t</a>+++;
 typedef void* (*+++<a href="#allocation_function">allocation_function</a>+++)(size_t size);
 typedef void (*+++<a href="#deallocation_function">deallocation_function</a>+++)(void* ptr);
 ----
@@ -2580,10 +2580,10 @@ class +++<a href="#xml_attribute">xml_attribute</a>+++
 
     bool +++<a href="#xml_attribute::comparison">operator==</a>+++(const xml_attribute& r) const;
     bool +++<a href="#xml_attribute::comparison">operator!=</a>+++(const xml_attribute& r) const;
-    bool +++<a href="#xml_attribute::comparison">operator<</a>+++(const xml_attribute& r) const;
-    bool +++<a href="#xml_attribute::comparison">operator></a>+++(const xml_attribute& r) const;
-    bool +++<a href="#xml_attribute::comparison">operator<=</a>+++(const xml_attribute& r) const;
-    bool +++<a href="#xml_attribute::comparison">operator>=</a>+++(const xml_attribute& r) const;
+    bool +++<a href="#xml_attribute::comparison">operator&lt;</a>+++(const xml_attribute& r) const;
+    bool +++<a href="#xml_attribute::comparison">operator&gt;</a>+++(const xml_attribute& r) const;
+    bool +++<a href="#xml_attribute::comparison">operator&lt;=</a>+++(const xml_attribute& r) const;
+    bool +++<a href="#xml_attribute::comparison">operator&gt;=</a>+++(const xml_attribute& r) const;
 
     size_t +++<a href="#xml_attribute::hash_value">hash_value</a>+++() const;
 
@@ -2629,10 +2629,10 @@ class +++<a href="#xml_node">xml_node</a>+++
 
     bool +++<a href="#xml_node::comparison">operator==</a>+++(const xml_node& r) const;
     bool +++<a href="#xml_node::comparison">operator!=</a>+++(const xml_node& r) const;
-    bool +++<a href="#xml_node::comparison">operator<</a>+++(const xml_node& r) const;
-    bool +++<a href="#xml_node::comparison">operator></a>+++(const xml_node& r) const;
-    bool +++<a href="#xml_node::comparison">operator<=</a>+++(const xml_node& r) const;
-    bool +++<a href="#xml_node::comparison">operator>=</a>+++(const xml_node& r) const;
+    bool +++<a href="#xml_node::comparison">operator&lt;</a>+++(const xml_node& r) const;
+    bool +++<a href="#xml_node::comparison">operator&gt;</a>+++(const xml_node& r) const;
+    bool +++<a href="#xml_node::comparison">operator&lt;=</a>+++(const xml_node& r) const;
+    bool +++<a href="#xml_node::comparison">operator&gt;=</a>+++(const xml_node& r) const;
 
     size_t +++<a href="#xml_node::hash_value">hash_value</a>+++() const;
 
@@ -2650,9 +2650,9 @@ class +++<a href="#xml_node">xml_node</a>+++
     xml_attribute +++<a href="#xml_node::first_attribute">first_attribute</a>+++() const;
     xml_attribute +++<a href="#xml_node::last_attribute">last_attribute</a>+++() const;
 
-    /implementation-defined type/ +++<a href="#xml_node::children">children</a>+++() const;
-    /implementation-defined type/ +++<a href="#xml_node::children">children</a>+++(const char_t* name) const;
-    /implementation-defined type/ +++<a href="#xml_node::attributes">attributes</a>+++() const;
+    implementation-defined-type +++<a href="#xml_node::children">children</a>+++() const;
+    implementation-defined-type +++<a href="#xml_node::children">children</a>+++(const char_t* name) const;
+    implementation-defined-type +++<a href="#xml_node::attributes">attributes</a>+++() const;
 
     xml_node +++<a href="#xml_node::child">child</a>+++(const char_t* name) const;
     xml_attribute +++<a href="#xml_node::attribute">attribute</a>+++(const char_t* name) const;