From d18e0f667d33527c1c5e54f448f6aa2ba59dabdb Mon Sep 17 00:00:00 2001

From: Jakub Filak <jfilak@redhat.com>

Date: Thu, 4 Dec 2014 08:43:17 +0100

Subject: [PATCH 127/136] lib: add Problem Format API

Related to #303

Signed-off-by: Jakub Filak <jfilak@redhat.com>

---

 po/POTFILES.in               |    1 +

 src/include/Makefile.am      |    1 +

 src/include/problem_report.h |  225 ++++++++

 src/lib/Makefile.am          |    5 +-

 src/lib/problem_report.c     | 1209 ++++++++++++++++++++++++++++++++++++++++++

 tests/Makefile.am            |    3 +-

 tests/problem_report.at      |  690 ++++++++++++++++++++++++

 tests/testsuite.at           |    1 +

 8 files changed, 2133 insertions(+), 2 deletions(-)

 create mode 100644 src/include/problem_report.h

 create mode 100644 src/lib/problem_report.c

 create mode 100644 tests/problem_report.at

diff --git a/po/POTFILES.in b/po/POTFILES.in

index 00046e2..c597b11 100644

--- a/po/POTFILES.in

+++ b/po/POTFILES.in

@@ -23,6 +23,7 @@ src/lib/ureport.c

 src/lib/make_descr.c

 src/lib/parse_options.c

 src/lib/problem_data.c

+src/lib/problem_report.c

 src/lib/run_event.c

 src/plugins/abrt_rh_support.c

 src/plugins/report_Bugzilla.xml.in

diff --git a/src/include/Makefile.am b/src/include/Makefile.am

index de44cda..47ba399 100644

--- a/src/include/Makefile.am

+++ b/src/include/Makefile.am

@@ -5,6 +5,7 @@ libreport_include_HEADERS = \

     dump_dir.h \

     event_config.h \

     problem_data.h \

+    problem_report.h \

     report.h \

     run_event.h \

     libreport_curl.h \

diff --git a/src/include/problem_report.h b/src/include/problem_report.h

new file mode 100644

index 0000000..30781e6

--- /dev/null

+++ b/src/include/problem_report.h

@@ -0,0 +1,225 @@

+/*

+    Copyright (C) 2014  ABRT team

+    Copyright (C) 2014  RedHat Inc

+

+    This program is free software; you can redistribute it and/or modify

+    it under the terms of the GNU General Public License as published by

+    the Free Software Foundation; either version 2 of the License, or

+    (at your option) any later version.

+

+    This program is distributed in the hope that it will be useful,

+    but WITHOUT ANY WARRANTY; without even the implied warranty of

+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+    GNU General Public License for more details.

+

+    You should have received a copy of the GNU General Public License along

+    with this program; if not, write to the Free Software Foundation, Inc.,

+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+*/

+#ifndef LIBREPORT_PROBLEM_REPORT_H

+#define LIBREPORT_PROBLEM_REPORT_H

+

+#include <glib.h>

+#include <stdio.h>

+#include "problem_data.h"

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+#define PR_SEC_SUMMARY "summary"

+#define PR_SEC_DESCRIPTION "description"

+

+/*

+ * The problem report structure represents a problem data formatted according

+ * to a format string.

+ *

+ * A problem report is composed of well-known sections:

+ *   - summary

+ *   - descritpion

+ *   - attach

+ *

+ * and custom sections accessed by:

+ *   problem_report_get_section();

+ */

+struct problem_report;

+typedef struct problem_report problem_report_t;

+

+/*

+ * Helpers for easily switching between FILE and struct strbuf

+ */

+

+/*

+ * Type of buffer used by Problem report

+ */

+typedef FILE problem_report_buffer;

+

+/*

+ * Wrapper for the proble buffer's formated output function.

+ */

+#define problem_report_buffer_printf(buf, fmt, ...)\

+    fprintf((buf), (fmt), ##__VA_ARGS__)

+

+

+/*

+ * Get a section buffer

+ *

+ * Use this function if you need to amend something to a formatted section.

+ *

+ * @param self Problem report

+ * @param section_name Name of required section

+ * @return Always valid pointer to a section buffer

+ */

+problem_report_buffer *problem_report_get_buffer(const problem_report_t *self,

+        const char *section_name);

+

+/*

+ * Get Summary string

+ *

+ * The returned pointer is valid as long as you perform no further output to

+ * the summary buffer.

+ *

+ * @param self Problem report

+ * @return Non-NULL pointer to summary data

+ */

+const char *problem_report_get_summary(const problem_report_t *self);

+

+/*

+ * Get Description string

+ *

+ * The returned pointer is valid as long as you perform no further output to

+ * the description buffer.

+ *

+ * @param self Problem report

+ * @return Non-NULL pointer to description data

+ */

+const char *problem_report_get_description(const problem_report_t *self);

+

+/*

+ * Get Section's string

+ *

+ * The returned pointer is valid as long as you perform no further output to

+ * the section's buffer.

+ *

+ * @param self Problem report

+ * @param section_name Name of the required section

+ * @return Non-NULL pointer to description data

+ */

+const char *problem_report_get_section(const problem_report_t *self,

+        const char *section_name);

+

+/*

+ * Get GList of the problem data items that are to be attached

+ *

+ * @param self Problem report

+ * @return A pointer to GList (NULL means empty list)

+ */

+GList *problem_report_get_attachments(const problem_report_t *self);

+

+/*

+ * Releases all resources allocated by a problem report

+ *

+ * @param self Problem report

+ */

+void problem_report_free(problem_report_t *self);

+

+

+/*

+ * An enum of Extra section flags

+ */

+enum problem_formatter_section_flags {

+    PFFF_REQUIRED = 1 << 0, ///< section must be present in the format spec

+};

+

+/*

+ * The problem formatter structure formats a problem data according to a format

+ * string and stores result a problem report.

+ *

+ * The problem formatter uses '%reason%' as %summary section format string, if

+ * %summary is not provided by a format string.

+ */

+struct problem_formatter;

+typedef struct problem_formatter problem_formatter_t;

+

+/*

+ * Constructs a new problem formatter.

+ *

+ * @return Non-NULL pointer to the new problem formatter

+ */

+problem_formatter_t *problem_formatter_new(void);

+

+/*

+ * Releases all resources allocated by a problem formatter

+ *

+ * @param self Problem formatter

+ */

+void problem_formatter_free(problem_formatter_t *self);

+

+/*

+ * Adds a new recognized section

+ *

+ * The problem formatter ignores a section in the format spec if the section is

+ * not one of the default nor added by this function.

+ *

+ * How the problem formatter handles these extra sections:

+ *

+ * A custom section is something like %description section. %description is the

+ * default section where all text (sub)sections are stored. If the formatter

+ * finds the custom section in format string, then starts storing text

+ * (sub)sections in the custom section.

+ *

+ * (%description)    |:: comment

+ * (%description)    |

+ * (%description)    |Package:: package

+ * (%description)    |

+ * (%additiona_info) |%additional_info::

+ * (%additiona_info) |%reporter%

+ * (%additiona_info) |User:: user_name,uid

+ * (%additiona_info) |

+ * (%additiona_info) |Directories:: root,cwd

+ *

+ *

+ * @param self Problem formatter

+ * @param name Name of the added section

+ * @param flags Info about the added section

+ * @return Zero on success. -EEXIST if the name is already known by the formatter

+ */

+int problem_formatter_add_section(problem_formatter_t *self, const char *name, int flags);

+

+/*

+ * Loads a problem format from a string.

+ *

+ * @param self Problem formatter

+ * @param fmt Format

+ * @return Zero on success or number of warnings (e.g. missing section,

+ * unrecognized section).

+ */

+int problem_formatter_load_string(problem_formatter_t* self, const char *fmt);

+

+

+/*

+ * Loads a problem format from a file.

+ *

+ * @param self Problem formatter

+ * @param pat Path to the format file

+ * @return Zero on success or number of warnings (e.g. missing section,

+ * unrecognized section).

+ */

+int problem_formatter_load_file(problem_formatter_t* self, const char *path);

+

+/*

+ * Creates a new problem report, formats the data according to the loaded

+ * format string and stores output in the report.

+ *

+ * @param self Problem formatter

+ * @param data Problem data to format

+ * @param report Pointer where the created problem report is to be stored

+ * @return Zero on success, otherwise non-zero value.

+ */

+int problem_formatter_generate_report(const problem_formatter_t *self, problem_data_t *data, problem_report_t **report);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif // LIBREPORT_PROBLEM_REPORT_H

diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am

index 7d9722a..a0001ef 100644

--- a/src/lib/Makefile.am

+++ b/src/lib/Makefile.am

@@ -38,6 +38,7 @@ libreport_la_SOURCES = \

     make_descr.c \

     run_event.c \

     problem_data.c \

+    problem_report.c \

     create_dump_dir.c \

     abrt_types.c \

     parse_release.c \

@@ -76,6 +77,7 @@ libreport_la_CPPFLAGS = \

     $(GLIB_CFLAGS) \

     $(GOBJECT_CFLAGS) \

     $(AUGEAS_CFLAGS) \

+    $(SATYR_CFLAGS) \

     -D_GNU_SOURCE

 libreport_la_LDFLAGS = \

     -version-info 0:1:0

@@ -84,7 +86,8 @@ libreport_la_LIBADD = \

     $(GLIB_LIBS) \

     $(JOURNAL_LIBS) \

     $(GOBJECT_LIBS) \

-    $(AUGEAS_LIBS)

+    $(AUGEAS_LIBS) \

+    $(SATYR_LIBS)

 libreportconfdir = $(CONF_DIR)

 dist_libreportconf_DATA = \

diff --git a/src/lib/problem_report.c b/src/lib/problem_report.c

new file mode 100644

index 0000000..0afc1ca

--- /dev/null

+++ b/src/lib/problem_report.c

@@ -0,0 +1,1209 @@

+/*

+    Copyright (C) 2014  ABRT team

+    Copyright (C) 2014  RedHat Inc

+

+    This program is free software; you can redistribute it and/or modify

+    it under the terms of the GNU General Public License as published by

+    the Free Software Foundation; either version 2 of the License, or

+    (at your option) any later version.

+

+    This program is distributed in the hope that it will be useful,

+    but WITHOUT ANY WARRANTY; without even the implied warranty of

+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+    GNU General Public License for more details.

+

+    You should have received a copy of the GNU General Public License along

+    with this program; if not, write to the Free Software Foundation, Inc.,

+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+*/

+

+#include "problem_report.h"

+#include "internal_libreport.h"

+

+#include <satyr/stacktrace.h>

+#include <satyr/abrt.h>

+

+#include <assert.h>

+

+#define DESTROYED_POINTER (void *)0xdeadbeef

+

+/* FORMAT:

+ * |%summary:: Hello, world

+ * |Problem description:: %bare_comment

+ * |

+ * |Package:: package

+ * |

+ * |%attach: %binary, backtrace

+ * |

+ * |%additional_info::

+ * |%reporter%

+ * |User:: user_name,uid

+ * |

+ * |Directories:: root,cwd

+ *

+ * PARSED DATA (list of struct section_t):

+ * {

+ *   section_t {

+ *      .name     = '%summary';

+ *      .items    = { 'Hello, world' };

+ *      .children = NULL;

+ *   },

+ *   section_t {

+ *      .name     = '%attach'

+ *      .items    = { '%binary', 'backtrace' };

+ *      .children = NULL;

+ *   },

+ *   section_t {

+ *      .name     = '%description'

+ *      .items    = NULL;

+ *      .children = {

+ *        section_t {

+ *          .name     = 'Problem description:';

+ *          .items    = { '%bare_comment' };

+ *          .children = NULL;

+ *        },

+ *        section_t {

+ *          .name     = '';

+ *          .items    = NULL;

+ *          .children = NULL;

+ *        },

+ *        section_t {

+ *          .name     = 'Package:';

+ *          .items    = { 'package' };

+ *          .children = NULL;

+ *        },

+ *      }

+ *   },

+ *   section_t {

+ *      .name     = '%additional_info'

+ *      .items    = { '%reporter%' };

+ *      .children = {

+ *        section_t {

+ *          .name     = 'User:';

+ *          .items    = { 'user_name', 'uid' };

+ *          .children = NULL;

+ *        },

+ *        section_t {

+ *          .name     = '';

+ *          .items    = NULL;

+ *          .children = NULL;

+ *        },

+ *        section_t {

+ *          .name     = 'Directories:';

+ *          .items    = { 'root', 'cwd' };

+ *          .children = NULL;

+ *        },

+ *      }

+ *   }

+ * }

+ */

+struct section_t {

+    char *name;      ///< name or output text (%summar, 'Package version:');

+    GList *items;    ///< list of file names and special items (%reporter, %binar, ...)

+    GList *children; ///< list of sub sections (struct section_t)

+};

+

+typedef struct section_t section_t;

+

+static section_t *

+section_new(const char *name)

+{

+    section_t *self = xmalloc(sizeof(*self));

+    self->name = xstrdup(name);

+    self->items = NULL;

+    self->children = NULL;

+

+    return self;

+}

+

+static void

+section_free(section_t *self)

+{

+    if (self == NULL)

+        return;

+

+    free(self->name);

+    g_list_free_full(self->items, free);

+    g_list_free_full(self->children, (GDestroyNotify)section_free);

+

+    free(self);

+}

+

+static int

+section_name_cmp(section_t *lhs, const char *rhs)

+{

+    return strcmp((lhs->name + 1), rhs);

+}

+

+/* Utility functions */

+

+static GList*

+split_string_on_char(const char *str, char ch)

+{

+    GList *list = NULL;

+    for (;;)

+    {

+        const char *delim = strchrnul(str, ch);

+        list = g_list_prepend(list, xstrndup(str, delim - str));

+        if (*delim == '\0')

+            break;

+        str = delim + 1;

+    }

+    return g_list_reverse(list);

+}

+

+static int

+compare_item_name(const char *lookup, const char *name)

+{

+    if (lookup[0] == '-')

+        lookup++;

+    else if (strncmp(lookup, "%bare_", 6) == 0)

+        lookup += 6;

+    return strcmp(lookup, name);

+}

+

+static int

+is_item_name_in_section(const section_t *lookup, const char *name)

+{

+    if (g_list_find_custom(lookup->items, name, (GCompareFunc)compare_item_name))

+        return 0; /* "found it!" */

+    return 1;

+}

+

+static bool is_explicit_or_forbidden(const char *name, GList *comment_fmt_spec);

+

+static int

+is_explicit_or_forbidden_child(const section_t *master_section, const char *name)

+{

+    if (is_explicit_or_forbidden(name, master_section->children))

+        return 0; /* "found it!" */

+    return 1;

+}

+

+/* For example: 'package' belongs to '%oneline', but 'package' is used in

+ * 'Version of component', so it is not very helpful to include that file once

+ * more in another section

+ */

+static bool

+is_explicit_or_forbidden(const char *name, GList *comment_fmt_spec)

+{

+    return    g_list_find_custom(comment_fmt_spec, name, (GCompareFunc)is_item_name_in_section)

+           || g_list_find_custom(comment_fmt_spec, name, (GCompareFunc)is_explicit_or_forbidden_child);

+}

+

+static GList*

+load_stream(FILE *fp)

+{

+    assert(fp);

+

+    GList *sections = NULL;

+    section_t *master = section_new("%description");

+    section_t *sec = NULL;

+

+    sections = g_list_append(sections, master);

+

+    char *line;

+    while ((line = xmalloc_fgetline(fp)) != NULL)

+    {

+        /* Skip comments */

+        char first = *skip_whitespace(line);

+        if (first == '#')

+            goto free_line;

+

+        /* Handle trailing backslash continuation */

+ check_continuation: ;

+        unsigned len = strlen(line);

+        if (len && line[len-1] == '\\')

+        {

+            line[len-1] = '\0';

+            char *next_line = xmalloc_fgetline(fp);

+            if (next_line)

+            {

+                line = append_to_malloced_string(line, next_line);

+                free(next_line);

+                goto check_continuation;

+            }

+        }

+

+        /* We are reusing line buffer to form temporary

+         * "key\0values\0..." in its beginning

+         */

+        bool summary_line = false;

+        char *value = NULL;

+        char *src;

+        char *dst;

+        for (src = dst = line; *src; src++)

+        {

+            char c = *src;

+            /* did we reach the value list? */

+            if (!value && c == ':' && src[1] == ':')

+            {

+                *dst++ = '\0'; /* terminate key */

+                src += 1;

+                value = dst; /* remember where value starts */

+                summary_line = (strcmp(line, "%summary") == 0);

+                if (summary_line)

+                {

+                    value = (src + 1);

+                    break;

+                }

+                continue;

+            }

+            /* skip whitespace in value list */

+            if (value && isspace(c))

+                continue;

+            *dst++ = c; /* store next key or value char */

+        }

+

+        GList *item_list = NULL;

+        if (summary_line)

+        {

+            /* %summary is special */

+            item_list = g_list_append(NULL, xstrdup(skip_whitespace(value)));

+        }

+        else

+        {

+            *dst = '\0'; /* terminate value (or key) */

+            if (value)

+                item_list = split_string_on_char(value, ',');

+        }

+

+        sec = section_new(line);

+        sec->items = item_list;

+

+        if (sec->name[0] == '%')

+        {

+            if (!summary_line && strcmp(sec->name, "%attach") != 0)

+            {

+                master->children = g_list_reverse(master->children);

+                master = sec;

+            }

+

+            sections = g_list_prepend(sections, sec);

+        }

+        else

+            master->children = g_list_prepend(master->children, sec);

+

+ free_line:

+        free(line);

+    }

+

+    /* If master equals sec, then master's children list was not yet reversed.

+     *

+     * %description is the default section (i.e is not explicitly mentioned)

+     * and %summary nor %attach cause its children list to reverse.

+     */

+    if (master == sec || strcmp(master->name, "%description") == 0)

+        master->children = g_list_reverse(master->children);

+

+    return sections;

+}

+

+

+/* Summary generation */

+

+#define MAX_OPT_DEPTH 10

+static int

+format_percented_string(const char *str, problem_data_t *pd, FILE *result)

+{

+    long old_pos[MAX_OPT_DEPTH] = { 0 };

+    int okay[MAX_OPT_DEPTH] = { 1 };

+    long len = 0;

+    int opt_depth = 1;

+

+    while (*str) {

+        switch (*str) {

+        default:

+            putc(*str, result);

+            len++;

+            str++;

+            break;

+        case '\\':

+            if (str[1])

+                str++;

+            putc(*str, result);

+            len++;

+            str++;

+            break;

+        case '[':

+            if (str[1] == '[' && opt_depth < MAX_OPT_DEPTH)

+            {

+                old_pos[opt_depth] = len;

+                okay[opt_depth] = 1;

+                opt_depth++;

+                str += 2;

+            } else {

+                putc(*str, result);

+                len++;

+                str++;

+            }

+            break;

+        case ']':

+            if (str[1] == ']' && opt_depth > 1)

+            {

+                opt_depth--;

+                if (!okay[opt_depth])

+                {

+                    fseek(result, old_pos[opt_depth], SEEK_SET);

+                    len = old_pos[opt_depth];

+                }

+                str += 2;

+            } else {

+                putc(*str, result);

+                len++;

+                str++;

+            }

+            break;

+        case '%': ;

+            char *nextpercent = strchr(++str, '%');

+            if (!nextpercent)

+            {

+                error_msg_and_die("Unterminated %%element%%: '%s'", str - 1);

+            }

+

+            *nextpercent = '\0';

+            const problem_item *item = problem_data_get_item_or_NULL(pd, str);

+            *nextpercent = '%';

+

+            if (item && (item->flags & CD_FLAG_TXT))

+            {

+                fputs(item->content, result);

+                len += strlen(item->content);

+            }

+            else

+                okay[opt_depth - 1] = 0;

+            str = nextpercent + 1;

+            break;

+        }

+    }

+

+    if (opt_depth > 1)

+    {

+        error_msg_and_die("Unbalanced [[ ]] bracket");

+    }

+

+    if (!okay[0])

+    {

+        error_msg("Undefined variable outside of [[ ]] bracket");

+    }

+

+    return 0;

+}

+

+/* BZ comment generation */

+

+static int

+append_text(struct strbuf *result, const char *item_name, const char *content, bool print_item_name)

+{

+    char *eol = strchrnul(content, '\n');

+    if (eol[0] == '\0' || eol[1] == '\0')

+    {

+        /* one-liner */

+        int pad = 16 - (strlen(item_name) + 2);

+        if (pad < 0)

+            pad = 0;

+        if (print_item_name)

+            strbuf_append_strf(result,

+                    eol[0] == '\0' ? "%s: %*s%s\n" : "%s: %*s%s",

+                    item_name, pad, "", content

+            );

+        else

+            strbuf_append_strf(result,

+                    eol[0] == '\0' ? "%s\n" : "%s",

+                    content

+            );

+    }

+    else

+    {

+        /* multi-line item */

+        if (print_item_name)

+            strbuf_append_strf(result, "%s:\n", item_name);

+        for (;;)

+        {

+            eol = strchrnul(content, '\n');

+            strbuf_append_strf(result,

+                    /* For %bare_multiline_item, we don't want to print colons */

+                    (print_item_name ? ":%.*s\n" : "%.*s\n"),

+                    (int)(eol - content), content

+            );

+            if (eol[0] == '\0' || eol[1] == '\0')

+                break;

+            content = eol + 1;

+        }

+    }

+    return 1;

+}

+

+static int

+append_short_backtrace(struct strbuf *result, problem_data_t *problem_data, size_t max_text_size, bool print_item_name)

+{

+    const problem_item *item = problem_data_get_item_or_NULL(problem_data,

+                                                             FILENAME_BACKTRACE);

+    if (!item)

+        return 0; /* "I did not print anything" */

+    if (!(item->flags & CD_FLAG_TXT))

+        return 0; /* "I did not print anything" */

+

+    char *truncated = NULL;

+

+    if (strlen(item->content) >= max_text_size)

+    {

+        log_debug("'backtrace' exceeds the text file size, going to append its short version");

+

+        char *error_msg = NULL;

+        const char *analyzer = problem_data_get_content_or_NULL(problem_data, FILENAME_ANALYZER);

+        if (!analyzer)

+        {

+            log_debug("Problem data does not contain '"FILENAME_ANALYZER"' file");

+            return 0;

+        }

+

+        /* For CCpp crashes, use the GDB-produced backtrace which should be

+         * available by now. sr_abrt_type_from_analyzer returns SR_REPORT_CORE

+         * by default for CCpp crashes.

+         */

+        enum sr_report_type report_type = sr_abrt_type_from_analyzer(analyzer);

+        if (strcmp(analyzer, "CCpp") == 0)

+        {

+            log_debug("Successfully identified 'CCpp' abrt type");

+            report_type = SR_REPORT_GDB;

+        }

+

+        struct sr_stacktrace *backtrace = sr_stacktrace_parse(report_type,

+                item->content, &error_msg);

+

+        if (!backtrace)

+        {

+            log(_("Can't parse backtrace: %s"), error_msg);

+            free(error_msg);

+            return 0;

+        }

+

+        /* Get optimized thread stack trace for 10 top most frames */

+        truncated = sr_stacktrace_to_short_text(backtrace, 10);

+        sr_stacktrace_free(backtrace);

+

+        if (!truncated)

+        {

+            log(_("Can't generate stacktrace description (no crash thread?)"));

+            return 0;

+        }

+    }

+    else

+    {

+        log_debug("'backtrace' is small enough to be included as is");

+    }

+

+    append_text(result,

+                /*item_name:*/ truncated ? "truncated_backtrace" : FILENAME_BACKTRACE,

+                /*content:*/   truncated ? truncated             : item->content,

+                print_item_name

+    );

+    free(truncated);

+    return 1;

+}

+

+static int

+append_item(struct strbuf *result, const char *item_name, problem_data_t *pd, GList *comment_fmt_spec)

+{

+    bool print_item_name = (strncmp(item_name, "%bare_", strlen("%bare_")) != 0);

+    if (!print_item_name)

+        item_name += strlen("%bare_");

+

+    if (item_name[0] != '%')

+    {

+        struct problem_item *item = problem_data_get_item_or_NULL(pd, item_name);

+        if (!item)

+            return 0; /* "I did not print anything" */

+        if (!(item->flags & CD_FLAG_TXT))

+            return 0; /* "I did not print anything" */

+

+        char *formatted = problem_item_format(item);

+        char *content = formatted ? formatted : item->content;

+        append_text(result, item_name, content, print_item_name);

+        free(formatted);

+        return 1; /* "I printed something" */

+    }

+

+    /* Special item name */

+

+    /* Compat with previously-existed ad-hockery: %short_backtrace */

+    if (strcmp(item_name, "%short_backtrace") == 0)

+        return append_short_backtrace(result, pd, CD_TEXT_ATT_SIZE_BZ, print_item_name);

+

+    /* Compat with previously-existed ad-hockery: %reporter */

+    if (strcmp(item_name, "%reporter") == 0)

+        return append_text(result, "reporter", PACKAGE"-"VERSION, print_item_name);

+

+    /* %oneline,%multiline,%text */

+    bool oneline   = (strcmp(item_name+1, "oneline"  ) == 0);

+    bool multiline = (strcmp(item_name+1, "multiline") == 0);

+    bool text      = (strcmp(item_name+1, "text"     ) == 0);

+    if (!oneline && !multiline && !text)

+    {

+        log("Unknown or unsupported element specifier '%s'", item_name);

+        return 0; /* "I did not print anything" */

+    }

+

+    int printed = 0;

+

+    /* Iterate over _sorted_ items */

+    GList *sorted_names = g_hash_table_get_keys(pd);

+    sorted_names = g_list_sort(sorted_names, (GCompareFunc)strcmp);

+

+    /* %text => do as if %oneline, then repeat as if %multiline */

+    if (text)

+        oneline = 1;

+

+ again: ;

+    GList *l = sorted_names;

+    while (l)

+    {

+        const char *name = l->data;

+        l = l->next;

+        struct problem_item *item = g_hash_table_lookup(pd, name);

+        if (!item)

+            continue; /* paranoia, won't happen */