Remove constant conditionals (dead-code).
[asterisk/asterisk.git] / main / xmldoc.c
index 7a48c87..105bee0 100644 (file)
@@ -29,8 +29,6 @@
 
 #include "asterisk.h"
 
-ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
-
 #include "asterisk/_private.h"
 #include "asterisk/paths.h"
 #include "asterisk/linkedlists.h"
@@ -45,18 +43,9 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 /*! \brief Default documentation language. */
 static const char default_documentation_language[] = "en_US";
 
-/*!
- * \brief Number of columns to print when showing the XML documentation with a
- *         'core show application/function *' CLI command. Used in text wrapping.
- */
-static const int xmldoc_text_columns = 74;
-
-/*!
- * \brief This is a value that we will use to let the wrapping mechanism move the cursor
- *         backward and forward xmldoc_max_diff positions before cutting the middle of a
- *         word, trying to find a space or a \n.
- */
-static const int xmldoc_max_diff = 5;
+/*! \brief Number of columns to print when showing the XML documentation with a
+ *         'core show application/function *' CLI command. Used in text wrapping.*/
+static const int xmldoc_text_columns = 79;
 
 /*! \brief XML documentation language. */
 static char documentation_language[6];
@@ -104,7 +93,9 @@ static const struct strcolorized_tags {
 
        /* Special tags */
        { "", "", COLOR_YELLOW, "<note>",   "</note>" },
-       { "", "", COLOR_RED,   "<warning>", "</warning>" }
+       { "", "", COLOR_RED,   "<warning>", "</warning>" },
+       { "", "", COLOR_WHITE, "<example>", "</example>" },
+       { "", "", COLOR_GRAY, "<exampletext>", "</exampletext>"},
 };
 
 static const struct strspecial_tags {
@@ -113,7 +104,8 @@ static const struct strspecial_tags {
        const char *end;                /*!< Print this at the end. */
 } special_tags[] = {
        { "note",    "<note>NOTE:</note> ",             "" },
-       { "warning", "<warning>WARNING!!!:</warning> ", "" }
+       { "warning", "<warning>WARNING!!!:</warning> ", "" },
+       { "example", "<example>Example:</example> ", "" },
 };
 
 /*!
@@ -173,100 +165,22 @@ static void xmldoc_setpostbr(char *postbr, size_t len, const char *text)
 
 /*!
  * \internal
- * \brief Try to find a space or a break in text starting at currentpost
- *         and moving at most maxdiff positions.
- *         Helper for xmldoc_string_wrap().
- *
- * \param text Input string where it will search.
- * \param currentpos Current position within text.
- * \param maxdiff Not move more than maxdiff inside text.
- *
- * \retval 1 if a space or break is found inside text while moving.
- * \retval 0 if no space or break is found.
- */
-static int xmldoc_wait_nextspace(const char *text, int currentpos, int maxdiff)
-{
-       int i, textlen;
-
-       if (!text) {
-               return 0;
-       }
-
-       textlen = strlen(text);
-       for (i = currentpos; i < textlen; i++) {
-               if (text[i] == ESC) {
-                       /* Move to the end of the escape sequence */
-                       while (i < textlen && text[i] != 'm') {
-                               i++;
-                       }
-               } else if (text[i] == ' ' || text[i] == '\n') {
-                       /* Found the next space or linefeed */
-                       return 1;
-               } else if (i - currentpos > maxdiff) {
-                       /* We have looked the max distance and didn't find it */
-                       return 0;
-               }
-       }
-
-       /* Reached the end and did not find it */
-
-       return 0;
-}
-
-/*!
- * \internal
- * \brief Helper function for xmldoc_string_wrap().
- *    Try to found a space or a break inside text moving backward
- *    not more than maxdiff positions.
- *
- * \param text The input string where to search for a space.
- * \param currentpos The current cursor position.
- * \param maxdiff The max number of positions to move within text.
- *
- * \retval 0 If no space is found (Notice that text[currentpos] is not a space or a break)
- * \retval > 0 If a space or a break is found, and the result is the position relative to
- *  currentpos.
- */
-static int xmldoc_foundspace_backward(const char *text, int currentpos, int maxdiff)
-{
-       int i;
-
-       for (i = currentpos; i > 0; i--) {
-               if (text[i] == ' ' || text[i] == '\n') {
-                       return (currentpos - i);
-               } else if (text[i] == 'm' && (text[i - 1] >= '0' || text[i - 1] <= '9')) {
-                       /* give up, we found the end of a possible ESC sequence. */
-                       return 0;
-               } else if (currentpos - i > maxdiff) {
-                       /* give up, we can't move anymore. */
-                       return 0;
-               }
-       }
-
-       /* we found the beginning of the text */
-
-       return 0;
-}
-
-/*!
- * \internal
  * \brief Justify a text to a number of columns.
  *
  * \param text Input text to be justified.
  * \param columns Number of columns to preserve in the text.
- * \param maxdiff Try to not cut a word when goinf down.
  *
  * \retval NULL on error.
  * \retval The wrapped text.
  */
-static char *xmldoc_string_wrap(const char *text, int columns, int maxdiff)
+static char *xmldoc_string_wrap(const char *text, int columns)
 {
        struct ast_str *tmp;
        char *ret, postbr[160];
-       int count = 1, i, backspace, needtobreak = 0, colmax, textlen;
+       int count, i, textlen, postbrlen, lastbreak;
 
        /* sanity check */
-       if (!text || columns <= 0 || maxdiff < 0) {
+       if (!text || columns <= 0) {
                ast_log(LOG_WARNING, "Passing wrong arguments while trying to wrap the text\n");
                return NULL;
        }
@@ -279,55 +193,44 @@ static char *xmldoc_string_wrap(const char *text, int columns, int maxdiff)
 
        /* Check for blanks and tabs and put them in postbr. */
        xmldoc_setpostbr(postbr, sizeof(postbr), text);
-       colmax = columns - xmldoc_postbrlen(postbr);
+       postbrlen = xmldoc_postbrlen(postbr);
+
+       count = 0;
+       lastbreak = 0;
 
        textlen = strlen(text);
        for (i = 0; i < textlen; i++) {
-               if (needtobreak || !(count % colmax)) {
-                       if (text[i] == ' ') {
-                               ast_str_append(&tmp, 0, "\n%s", postbr);
-                               needtobreak = 0;
-                               count = 1;
-                       } else if (text[i] != '\n') {
-                               needtobreak = 1;
-                               if (xmldoc_wait_nextspace(text, i, maxdiff)) {
-                                       /* wait for the next space */
-                                       ast_str_append(&tmp, 0, "%c", text[i]);
-                                       continue;
-                               }
-                               /* Try to look backwards */
-                               backspace = xmldoc_foundspace_backward(text, i, maxdiff);
-                               if (backspace) {
-                                       needtobreak = 1;
-                                       ast_str_truncate(tmp, -backspace);
-                                       i -= backspace + 1;
-                                       continue;
-                               }
-                               ast_str_append(&tmp, 0, "\n%s", postbr);
-                               needtobreak = 0;
-                               count = 1;
-                       }
-                       /* skip blanks after a \n */
-                       while (text[i] == ' ') {
-                               i++;
-                       }
-               }
                if (text[i] == '\n') {
                        xmldoc_setpostbr(postbr, sizeof(postbr), &text[i] + 1);
-                       colmax = columns - xmldoc_postbrlen(postbr);
-                       needtobreak = 0;
-                       count = 1;
-               }
-               if (text[i] == ESC) {
-                       /* Ignore Escape sequences. */
+                       postbrlen = xmldoc_postbrlen(postbr);
+                       count = 0;
+                       lastbreak = 0;
+               } else if (text[i] == ESC) {
+                       /* Walk over escape sequences without counting them. */
                        do {
                                ast_str_append(&tmp, 0, "%c", text[i]);
                                i++;
                        } while (i < textlen && text[i] != 'm');
                } else {
+                       if (text[i] == ' ') {
+                               lastbreak = i;
+                       }
                        count++;
                }
-               ast_str_append(&tmp, 0, "%c", text[i]);
+
+               if (count > columns) {
+                       /* Seek backwards if it was at most 30 characters ago. */
+                       int back = i - lastbreak;
+                       if (lastbreak && back > 0 && back < 30) {
+                               ast_str_truncate(tmp, -back);
+                               i = lastbreak; /* go back a bit */
+                       }
+                       ast_str_append(&tmp, 0, "\n%s", postbr);
+                       count = postbrlen;
+                       lastbreak = 0;
+               } else {
+                       ast_str_append(&tmp, 0, "%c", text[i]);
+               }
        }
 
        ret = ast_strdup(ast_str_buffer(tmp));
@@ -432,14 +335,14 @@ char *ast_xmldoc_printable(const char *bwinput, int withcolors)
        }
 
        if (withcolors) {
-               ast_str_append(&colorized, 0, "%s", term_end());
+               ast_str_append(&colorized, 0, "%s", ast_term_reset());
                if (!colorized) {
                        return NULL;
                }
        }
 
        /* Wrap the text, notice that string wrap will avoid cutting an ESC sequence. */
-       wrapped = xmldoc_string_wrap(ast_str_buffer(colorized), xmldoc_text_columns, xmldoc_max_diff);
+       wrapped = xmldoc_string_wrap(ast_str_buffer(colorized), xmldoc_text_columns);
 
        ast_free(colorized);
 
@@ -453,8 +356,9 @@ char *ast_xmldoc_printable(const char *bwinput, int withcolors)
  * \param text String to be cleaned up.
  * \param output buffer (not already allocated).
  * \param lastspaces Remove last spaces in the string.
+ * \param maintain_newlines Preserve new line characters (\n \r) discovered in the string
  */
-static void xmldoc_string_cleanup(const char *text, struct ast_str **output, int lastspaces)
+static void xmldoc_string_cleanup(const char *text, struct ast_str **output, int lastspaces, int maintain_newlines)
 {
        int i;
        size_t textlen;
@@ -474,6 +378,9 @@ static void xmldoc_string_cleanup(const char *text, struct ast_str **output, int
 
        for (i = 0; i < textlen; i++) {
                if (text[i] == '\n' || text[i] == '\r') {
+                       if (maintain_newlines) {
+                               ast_str_append(output, 0, "%c", text[i]);
+                       }
                        /* remove spaces/tabs/\n after a \n. */
                        while (text[i + 1] == '\t' || text[i + 1] == '\r' || text[i + 1] == '\n') {
                                i++;
@@ -1232,7 +1139,7 @@ static char *xmldoc_get_syntax_config_option(struct ast_xml_node *fixnode, const
        regex = ast_xml_get_attribute(fixnode, "regex");
        ast_str_set(&syntax, 0, "%s = [%s] (Default: %s) (Regex: %s)\n",
                name,
-               type,
+               type ?: "",
                default_value ?: "n/a",
                regex ?: "False");
 
@@ -1417,7 +1324,7 @@ static int xmldoc_parse_para(struct ast_xml_node *node, const char *tabs, const
                tmptext = ast_xml_get_text(tmp);
                if (tmptext) {
                        /* Strip \n etc. */
-                       xmldoc_string_cleanup(tmptext, &tmpstr, 0);
+                       xmldoc_string_cleanup(tmptext, &tmpstr, 0, 0);
                        ast_xml_free_text(tmptext);
                        if (tmpstr) {
                                if (strcasecmp(ast_xml_node_get_name(tmp), "text")) {
@@ -1439,6 +1346,57 @@ static int xmldoc_parse_para(struct ast_xml_node *node, const char *tabs, const
 
 /*!
  * \internal
+ * \brief Parse an <example> node.
+ * \since 13.0.0
+ *
+ * \param fixnode An ast xml pointer to the <example> node.
+ * \param buffer The output buffer.
+ *
+ * \retval 0 if no example node is parsed.
+ * \retval 1 if an example node is parsed.
+ */
+static int xmldoc_parse_example(struct ast_xml_node *fixnode, struct ast_str **buffer)
+{
+       struct ast_xml_node *node = fixnode;
+       const char *tmptext;
+       const char *title;
+       struct ast_str *stripped_text;
+       int ret = 0;
+
+       if (!node || !ast_xml_node_get_children(node)) {
+               return ret;
+       }
+
+       if (strcasecmp(ast_xml_node_get_name(node), "example")) {
+               return ret;
+       }
+
+       ret = 1;
+
+       title = ast_xml_get_attribute(node, "title");
+       if (title) {
+               ast_str_append(buffer, 0, "%s", title);
+               ast_xml_free_attr(title);
+       }
+       ast_str_append(buffer, 0, "\n");
+
+       for (node = ast_xml_node_get_children(node); node; node = ast_xml_node_get_next(node)) {
+               tmptext = ast_xml_get_text(node);
+               if (tmptext) {
+                       xmldoc_string_cleanup(tmptext, &stripped_text, 0, 1);
+                       if (stripped_text) {
+                               ast_str_append(buffer, 0, "<exampletext>%s</exampletext>\n", ast_str_buffer(stripped_text));
+                               ast_xml_free_text(tmptext);
+                               ast_free(stripped_text);
+                       }
+               }
+       }
+
+       return ret;
+}
+
+/*!
+ * \internal
  * \brief Parse special elements defined in 'struct special_tags' special elements must have a <para> element inside them.
  *
  * \param fixnode special tag node pointer.
@@ -1453,7 +1411,7 @@ static int xmldoc_parse_para(struct ast_xml_node *node, const char *tabs, const
 static int xmldoc_parse_specialtags(struct ast_xml_node *fixnode, const char *tabs, const char *posttabs, struct ast_str **buffer)
 {
        struct ast_xml_node *node = fixnode;
-       int ret = 0, i, count = 0;
+       int ret = 0, i;
 
        if (!node || !ast_xml_node_get_children(node)) {
                return ret;
@@ -1472,11 +1430,16 @@ static int xmldoc_parse_specialtags(struct ast_xml_node *fixnode, const char *ta
                        ast_str_append(buffer, 0, "%s%s", tabs, special_tags[i].init);
                }
 
+               if (xmldoc_parse_example(node, buffer)) {
+                       ret = 1;
+                       break;
+               }
+
                /* parse <para> elements inside special tags. */
                for (node = ast_xml_node_get_children(node); node; node = ast_xml_node_get_next(node)) {
                        /* first <para> just print it without tabs at the begining. */
-                       if ((xmldoc_parse_para(node, (!count ? "" : tabs), posttabs, buffer) == 2)
-                               || (xmldoc_parse_info(node, (!count ? "": tabs), posttabs, buffer) == 2)) {
+                       if ((xmldoc_parse_para(node, "", posttabs, buffer) == 2)
+                               || (xmldoc_parse_info(node, "", posttabs, buffer) == 2)) {
                                ret = 2;
                        }
                }
@@ -1585,7 +1548,7 @@ static int xmldoc_parse_variable(struct ast_xml_node *node, const char *tabs, st
                /* Check inside this node for any explanation about its meaning. */
                if (tmptext) {
                        /* Cleanup text. */
-                       xmldoc_string_cleanup(tmptext, &cleanstr, 1);
+                       xmldoc_string_cleanup(tmptext, &cleanstr, 1, 0);
                        ast_xml_free_text(tmptext);
                        if (cleanstr && ast_str_strlen(cleanstr) > 0) {
                                ast_str_append(buffer, 0, ":%s", ast_str_buffer(cleanstr));
@@ -2147,18 +2110,27 @@ static struct ast_str *xmldoc_get_formatted(struct ast_xml_node *node, int raw_o
                /* xmldoc_string_cleanup will allocate the ret object */
                notcleanret = ast_xml_get_text(node);
                tmpstr = notcleanret;
-               xmldoc_string_cleanup(ast_skip_blanks(notcleanret), &ret, 0);
+               xmldoc_string_cleanup(ast_skip_blanks(notcleanret), &ret, 0, 0);
                ast_xml_free_text(tmpstr);
        } else {
                ret = ast_str_create(128);
+               if (!ret) {
+                       return NULL;
+               }
                for (tmp = ast_xml_node_get_children(node); tmp; tmp = ast_xml_node_get_next(tmp)) {
-                       /* if found, parse a <para> element. */
+                       /* if found, parse children elements. */
                        if (xmldoc_parse_common_elements(tmp, "", "\n", &ret)) {
                                continue;
                        }
-                       /* if found, parse a <variablelist> element. */
-                       xmldoc_parse_variablelist(tmp, "", &ret);
-                       xmldoc_parse_enumlist(tmp, "    ", &ret);
+                       if (xmldoc_parse_variablelist(tmp, "", &ret)) {
+                               continue;
+                       }
+                       if (xmldoc_parse_enumlist(tmp, "    ", &ret)) {
+                               continue;
+                       }
+                       if (xmldoc_parse_specialtags(tmp, "", "", &ret)) {
+                               continue;
+                       }
                }
                /* remove last '\n' */
                /* XXX Don't modify ast_str internals manually */
@@ -2194,7 +2166,7 @@ static char *_xmldoc_build_field(struct ast_xml_node *node, const char *var, int
        }
 
        formatted = xmldoc_get_formatted(node, raw, raw);
-       if (ast_str_strlen(formatted) > 0) {
+       if (formatted && ast_str_strlen(formatted) > 0) {
                ret = ast_strdup(ast_str_buffer(formatted));
        }
        ast_free(formatted);
@@ -2300,9 +2272,9 @@ static void ast_xml_doc_item_destructor(void *obj)
        ast_free(doc->description);
        ast_string_field_free_memory(doc);
 
-       if (doc->next) {
-               ao2_ref(doc->next, -1);
-               doc->next = NULL;
+       if (AST_LIST_NEXT(doc, next)) {
+               ao2_ref(AST_LIST_NEXT(doc, next), -1);
+               AST_LIST_NEXT(doc, next) = NULL;
        }
 }
 
@@ -2428,20 +2400,164 @@ static struct ast_xml_doc_item *xmldoc_build_documentation_item(struct ast_xml_n
        return item;
 }
 
+/*!
+ * \internal
+ * \brief Build the list responses for an item
+ *
+ * \param manager_action The action node to parse
+ *
+ * \note This method exists for when you already have the node.  This
+ * prevents having to lock the documentation tree twice
+ *
+ * \retval A list of ast_xml_doc_items
+ * \retval NULL on failure
+ *
+ * \since 13.0.0
+ */
+static struct ast_xml_doc_item *xmldoc_build_list_responses(struct ast_xml_node *manager_action)
+{
+       struct ast_xml_node *event;
+       struct ast_xml_node *responses;
+       struct ast_xml_node *list_elements;
+       struct ast_xml_doc_item_list root;
+
+       AST_LIST_HEAD_INIT(&root);
+
+       responses = ast_xml_find_element(ast_xml_node_get_children(manager_action), "responses", NULL, NULL);
+       if (!responses) {
+               return NULL;
+       }
+
+       list_elements = ast_xml_find_element(ast_xml_node_get_children(responses), "list-elements", NULL, NULL);
+       if (!list_elements) {
+               return NULL;
+       }
+
+       /* Iterate over managerEvent nodes */
+       for (event = ast_xml_node_get_children(list_elements); event; event = ast_xml_node_get_next(event)) {
+               struct ast_xml_node *event_instance;
+               RAII_VAR(const char *, name, ast_xml_get_attribute(event, "name"),
+                       ast_xml_free_attr);
+               struct ast_xml_doc_item *new_item;
+
+               if (!name || strcmp(ast_xml_node_get_name(event), "managerEvent")) {
+                       continue;
+               }
+
+               event_instance = ast_xml_find_element(ast_xml_node_get_children(event),
+                       "managerEventInstance", NULL, NULL);
+               new_item = xmldoc_build_documentation_item(event_instance, name, "managerEvent");
+               if (!new_item) {
+                       ao2_cleanup(AST_LIST_FIRST(&root));
+                       return NULL;
+               }
+
+               AST_LIST_INSERT_TAIL(&root, new_item, next);
+       }
+
+       return AST_LIST_FIRST(&root);
+}
+
+struct ast_xml_doc_item *ast_xmldoc_build_list_responses(const char *type, const char *name, const char *module)
+{
+       struct ast_xml_node *node;
+
+       if (ast_strlen_zero(type) || ast_strlen_zero(name)) {
+               return NULL;
+       }
+
+       node = xmldoc_get_node(type, name, module, documentation_language);
+
+       if (!node || !ast_xml_node_get_children(node)) {
+               return NULL;
+       }
+
+       return xmldoc_build_list_responses(node);
+}
+
+/*!
+ * \internal
+ * \brief Build the final response for an item
+ *
+ * \param manager_action The action node to parse
+ *
+ * \note This method exists for when you already have the node.  This
+ * prevents having to lock the documentation tree twice
+ *
+ * \retval An ast_xml_doc_item
+ * \retval NULL on failure
+ *
+ * \since 13.0.0
+ */
+static struct ast_xml_doc_item *xmldoc_build_final_response(struct ast_xml_node *manager_action)
+{
+       struct ast_xml_node *responses;
+       struct ast_xml_node *final_response_event;
+       struct ast_xml_node *event_instance;
+
+       responses = ast_xml_find_element(ast_xml_node_get_children(manager_action),
+               "responses", NULL, NULL);
+       if (!responses) {
+               return NULL;
+       }
+
+       final_response_event = ast_xml_find_element(ast_xml_node_get_children(responses),
+               "managerEvent", NULL, NULL);
+       if (!final_response_event) {
+               return NULL;
+       }
+
+       event_instance = ast_xml_find_element(ast_xml_node_get_children(final_response_event),
+               "managerEventInstance", NULL, NULL);
+       if (!event_instance) {
+               return NULL;
+       } else {
+               const char *name;
+               struct ast_xml_doc_item *res;
+
+               name = ast_xml_get_attribute(final_response_event, "name");
+               res = xmldoc_build_documentation_item(event_instance, name, "managerEvent");
+               ast_xml_free_attr(name);
+               return res;
+       }
+
+}
+
+struct ast_xml_doc_item *ast_xmldoc_build_final_response(const char *type, const char *name, const char *module)
+{
+       struct ast_xml_node *node;
+
+       if (ast_strlen_zero(type) || ast_strlen_zero(name)) {
+               return NULL;
+       }
+
+       node = xmldoc_get_node(type, name, module, documentation_language);
+
+       if (!node || !ast_xml_node_get_children(node)) {
+               return NULL;
+       }
+
+       return xmldoc_build_final_response(node);
+}
+
 struct ast_xml_xpath_results *__attribute__((format(printf, 1, 2))) ast_xmldoc_query(const char *fmt, ...)
 {
        struct ast_xml_xpath_results *results = NULL;
        struct documentation_tree *doctree;
        RAII_VAR(struct ast_str *, xpath_str, ast_str_create(128), ast_free);
        va_list ap;
+       int res;
 
        if (!xpath_str) {
                return NULL;
        }
 
        va_start(ap, fmt);
-       ast_str_set_va(&xpath_str, 0, fmt, ap);
+       res = ast_str_set_va(&xpath_str, 0, fmt, ap);
        va_end(ap);
+       if (res == AST_DYNSTR_BUILD_FAILED) {
+               return NULL;
+       }
 
        AST_RWLIST_RDLOCK(&xmldoc_tree);
        AST_LIST_TRAVERSE(&xmldoc_tree, doctree, entry) {
@@ -2455,7 +2571,7 @@ struct ast_xml_xpath_results *__attribute__((format(printf, 1, 2))) ast_xmldoc_q
        return results;
 }
 
-static void build_config_docs(struct ast_xml_node *cur, struct ast_xml_doc_item **tail)
+static void build_config_docs(struct ast_xml_node *cur, struct ast_xml_doc_item_list *root)
 {
        struct ast_xml_node *iter;
        struct ast_xml_doc_item *item;
@@ -2478,9 +2594,8 @@ static void build_config_docs(struct ast_xml_node *cur, struct ast_xml_doc_item
                        ast_string_field_set(item, ref, name);
                        ast_xml_free_attr(name);
                }
-               (*tail)->next = item;
-               *tail = (*tail)->next;
-               build_config_docs(iter, tail);
+               AST_LIST_INSERT_TAIL(root, item, next);
+               build_config_docs(iter, root);
        }
 }
 
@@ -2536,7 +2651,6 @@ int ast_xmldoc_regenerate_doc_item(struct ast_xml_doc_item *item)
 struct ao2_container *ast_xmldoc_build_documentation(const char *type)
 {
        struct ao2_container *docs;
-       struct ast_xml_doc_item *item = NULL, *root = NULL;
        struct ast_xml_node *node = NULL, *instance = NULL;
        struct documentation_tree *doctree;
        const char *name;
@@ -2555,6 +2669,8 @@ struct ao2_container *ast_xmldoc_build_documentation(const char *type)
                }
 
                for (node = ast_xml_node_get_children(node); node; node = ast_xml_node_get_next(node)) {
+                       struct ast_xml_doc_item *item = NULL;
+
                        /* Ignore empty nodes or nodes that aren't of the type requested */
                        if (!ast_xml_node_get_children(node) || strcasecmp(ast_xml_node_get_name(node), type)) {
                                continue;
@@ -2566,6 +2682,10 @@ struct ao2_container *ast_xmldoc_build_documentation(const char *type)
 
                        switch (xmldoc_get_syntax_type(type)) {
                        case MANAGER_EVENT_SYNTAX:
+                       {
+                               struct ast_xml_doc_item_list root;
+
+                               AST_LIST_HEAD_INIT(&root);
                                for (instance = ast_xml_node_get_children(node); instance; instance = ast_xml_node_get_next(instance)) {
                                        struct ast_xml_doc_item *temp;
                                        if (!ast_xml_node_get_children(instance) || strcasecmp(ast_xml_node_get_name(instance), "managerEventInstance")) {
@@ -2575,28 +2695,27 @@ struct ao2_container *ast_xmldoc_build_documentation(const char *type)
                                        if (!temp) {
                                                break;
                                        }
-                                       if (!item) {
-                                               item = temp;
-                                               root = item;
-                                       } else {
-                                               item->next = temp;
-                                               item = temp;
-                                       }
+                                       AST_LIST_INSERT_TAIL(&root, temp, next);
                                }
-                               item = root;
+                               item = AST_LIST_FIRST(&root);
                                break;
+                       }
                        case CONFIG_INFO_SYNTAX:
                        {
-                               struct ast_xml_doc_item *tail;
                                RAII_VAR(const char *, name, ast_xml_get_attribute(node, "name"), ast_xml_free_attr);
-                               if (item || !ast_xml_node_get_children(node) || strcasecmp(ast_xml_node_get_name(node), "configInfo")) {
+
+                               if (!ast_xml_node_get_children(node) || strcasecmp(ast_xml_node_get_name(node), "configInfo")) {
                                        break;
                                }
-                               if (!(item = xmldoc_build_documentation_item(node, name, "configInfo"))) {
-                                       break;
+
+                               item = xmldoc_build_documentation_item(node, name, "configInfo");
+                               if (item) {
+                                       struct ast_xml_doc_item_list root;
+
+                                       AST_LIST_HEAD_INIT(&root);
+                                       AST_LIST_INSERT_TAIL(&root, item, next);
+                                       build_config_docs(node, &root);
                                }
-                               tail = item;
-                               build_config_docs(node, &tail);
                                break;
                        }
                        default:
@@ -2607,7 +2726,6 @@ struct ao2_container *ast_xmldoc_build_documentation(const char *type)
                        if (item) {
                                ao2_link(docs, item);
                                ao2_t_ref(item, -1, "Dispose of creation ref");
-                               item = NULL;
                        }
                }
        }
@@ -2748,7 +2866,7 @@ int ast_xmldoc_load_documentation(void)
 
        ast_cli_register(&cli_dump_xmldocs);
        /* register function to be run when asterisk finish. */
-       ast_register_atexit(xmldoc_unload_documentation);
+       ast_register_cleanup(xmldoc_unload_documentation);
 
        globbuf.gl_offs = 0;    /* slots to reserve in gl_pathv */
 
@@ -2765,7 +2883,7 @@ int ast_xmldoc_load_documentation(void)
        globret = glob(xmlpattern, MY_GLOB_FLAGS, NULL, &globbuf);
 #endif
 
-       ast_debug(3, "gl_pathc %zd\n", globbuf.gl_pathc);
+       ast_debug(3, "gl_pathc %zu\n", (size_t)globbuf.gl_pathc);
        if (globret == GLOB_NOSPACE) {
                ast_log(LOG_WARNING, "XML load failure, glob expansion of pattern '%s' failed: Not enough memory\n", xmlpattern);
                ast_free(xmlpattern);