menu-layout.c

Bug Summary

File:	menu-layout.c
Warning:	line 567, column 20 Access to field 'prev' results in a dereference of a null pointer (loaded from field 'next')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name menu-layout.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/rootdir/libmenu -fcoverage-compilation-dir=/rootdir/libmenu -resource-dir /usr/lib/llvm-19/lib/clang/19 -D HAVE_CONFIG_H -I . -I .. -I /usr/include/gio-unix-2.0 -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -I /usr/include/libmount -I /usr/include/blkid -D CAFEMENU_I_KNOW_THIS_IS_UNSTABLE -D PIC -internal-isystem /usr/lib/llvm-19/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -analyzer-checker deadcode.DeadStores -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastSize -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.core.IdenticalExpr -analyzer-checker alpha.security.ArrayBoundV2 -analyzer-checker alpha.security.MallocOverflow -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.NotNullTerminated -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2025-02-13-090307-11729-1 -x c menu-layout.c
1/* Menu layout in-memory data structure (a custom "DOM tree") */

3/*
* Copyright (C) 2002 - 2004 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/

22#include <config.h>

24#include "menu-layout.h"

26#include <string.h>
27#include <stdio.h>
28#include <stdlib.h>
29#include <unistd.h>
30#include <errno(*__errno_location ()).h>

32#include "entry-directories.h"
33#include "menu-util.h"

35typedef struct MenuLayoutNodeMenu          MenuLayoutNodeMenu;
36typedef struct MenuLayoutNodeRoot          MenuLayoutNodeRoot;
37typedef struct MenuLayoutNodeLegacyDir     MenuLayoutNodeLegacyDir;
38typedef struct MenuLayoutNodeMergeFile     MenuLayoutNodeMergeFile;
39typedef struct MenuLayoutNodeDefaultLayout MenuLayoutNodeDefaultLayout;
40typedef struct MenuLayoutNodeMenuname      MenuLayoutNodeMenuname;
41typedef struct MenuLayoutNodeMerge         MenuLayoutNodeMerge;

43struct MenuLayoutNode
44{
/* Node lists are circular, for length-one lists
 * prev/next point back to the node itself.
 */
MenuLayoutNode *prev;
MenuLayoutNode *next;
MenuLayoutNode *parent;
MenuLayoutNode *children;

char *content;

guint refcount : 20;
guint type : 7;
57};

59struct MenuLayoutNodeRoot
60{
MenuLayoutNode node;

char *basedir;
char *name;

GMainContext *main_context;

GSList *monitors;
GSource *monitors_idle_handler;
70};

72struct MenuLayoutNodeMenu
73{
MenuLayoutNode node;

MenuLayoutNode *name_node; /* cache of the <Name> node */

EntryDirectoryList *app_dirs;
EntryDirectoryList *dir_dirs;
80};

82struct MenuLayoutNodeLegacyDir
83{
MenuLayoutNode node;

char *prefix;
87};

89struct MenuLayoutNodeMergeFile
90{
MenuLayoutNode node;

MenuMergeFileType type;
94};

96struct MenuLayoutNodeDefaultLayout
97{
MenuLayoutNode node;

MenuLayoutValues layout_values;
101};

103struct MenuLayoutNodeMenuname
104{
MenuLayoutNode node;

MenuLayoutValues layout_values;
108};

110struct MenuLayoutNodeMerge
111{
MenuLayoutNode node;

MenuLayoutMergeType merge_type;
115};

117typedef struct
118{
MenuLayoutNodeEntriesChangedFunc callback;
gpointer                         user_data;
121} MenuLayoutNodeEntriesMonitor;


124static inline MenuLayoutNode *
125node_next (MenuLayoutNode *node)
126{
/* root nodes (no parent) never have siblings */
if (node->parent == NULL((void*)0))
  return NULL((void*)0);

/* circular list */
if (node->next == node->parent->children)
  return NULL((void*)0);

return node->next;
136}

138static gboolean
139menu_layout_invoke_monitors (MenuLayoutNodeRoot *nr)
140{
GSList *tmp;

g_assert (nr->node.type == MENU_LAYOUT_NODE_ROOT)do { if (nr->node.type == MENU_LAYOUT_NODE_ROOT) ; else g_assertion_message_expr
 (((gchar*) 0), "menu-layout.c", 143, ((const char*) (__func__
)), "nr->node.type == MENU_LAYOUT_NODE_ROOT"); } while (0);

nr->monitors_idle_handler = NULL((void*)0);

tmp = nr->monitors;
while (tmp != NULL((void*)0))
  {
    MenuLayoutNodeEntriesMonitor *monitor = tmp->data;
    GSList                       *next    = tmp->next;

    monitor->callback ((MenuLayoutNode *) nr, monitor->user_data);

    tmp = next;
  }

return FALSE(0);
159}

161static void
162handle_entry_directory_changed (EntryDirectory *dir G_GNUC_UNUSED__attribute__ ((__unused__)),
		MenuLayoutNode *node)
164{
MenuLayoutNodeRoot *nr;

g_assert (node->type == MENU_LAYOUT_NODE_MENU)do { if (node->type == MENU_LAYOUT_NODE_MENU) ; else g_assertion_message_expr
 (((gchar*) 0), "menu-layout.c", 167, ((const char*) (__func__
)), "node->type == MENU_LAYOUT_NODE_MENU"); } while (0);

nr = (MenuLayoutNodeRoot *) menu_layout_node_get_root (node);

if (nr->monitors_idle_handler == NULL((void*)0))
  {
    nr->monitors_idle_handler = g_idle_source_new ();
    g_source_set_callback (nr->monitors_idle_handler,
                           (GSourceFunc) menu_layout_invoke_monitors, nr, NULL((void*)0));
    g_source_attach (nr->monitors_idle_handler, nr->main_context);
    g_source_unref (nr->monitors_idle_handler);
  }
179}

181static void
182remove_entry_directory_list (MenuLayoutNodeMenu  *nm,
                           EntryDirectoryList **dirs)
184{
if (*dirs)
  {
    entry_directory_list_remove_monitors (*dirs,
                                          (EntryDirectoryChangedFunc) handle_entry_directory_changed,
                                          nm);
    entry_directory_list_unref (*dirs);
    *dirs = NULL((void*)0);
  }
193}

195MenuLayoutNode *
196menu_layout_node_ref (MenuLayoutNode *node)
197{
g_return_val_if_fail (node != NULL, NULL)do { if ((node != ((void*)0))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "node != NULL"); return
 (((void*)0)); } } while (0);

node->refcount += 1;

return node;
203}

205void
206menu_layout_node_unref (MenuLayoutNode *node)
207{
g_return_if_fail (node != NULL)do { if ((node != ((void*)0))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "node != NULL"); return
; } } while (0);
g_return_if_fail (node->refcount > 0)do { if ((node->refcount > 0)) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "node->refcount > 0"
); return; } } while (0);

node->refcount -= 1;
if (node->refcount == 0)
  {
    MenuLayoutNode *iter;

    iter = node->children;
    while (iter != NULL((void*)0))
      {
        MenuLayoutNode *next = node_next (iter);

        menu_layout_node_unref (iter);

        iter = next;
      }

    if (node->type == MENU_LAYOUT_NODE_MENU)
      {
        MenuLayoutNodeMenu *nm = (MenuLayoutNodeMenu *) node;

        if (nm->name_node)
          menu_layout_node_unref (nm->name_node);

        remove_entry_directory_list (nm, &nm->app_dirs);
        remove_entry_directory_list (nm, &nm->dir_dirs);
      }
    else if (node->type == MENU_LAYOUT_NODE_LEGACY_DIR)
      {
        MenuLayoutNodeLegacyDir *legacy = (MenuLayoutNodeLegacyDir *) node;

        g_free (legacy->prefix);
      }
    else if (node->type == MENU_LAYOUT_NODE_ROOT)
      {
        MenuLayoutNodeRoot *nr = (MenuLayoutNodeRoot*) node;

        g_slist_foreach (nr->monitors, (GFunc) g_free, NULL((void*)0));
        g_slist_free (nr->monitors);

        if (nr->monitors_idle_handler != NULL((void*)0))
          g_source_destroy (nr->monitors_idle_handler);
        nr->monitors_idle_handler = NULL((void*)0);

        if (nr->main_context != NULL((void*)0))
          g_main_context_unref (nr->main_context);
        nr->main_context = NULL((void*)0);

        g_free (nr->basedir);
        g_free (nr->name);
      }

    g_free (node->content);
    g_free (node);
  }
264}

266MenuLayoutNode *
267menu_layout_node_new (MenuLayoutNodeType type)
268{
MenuLayoutNode *node;

switch (type)
  {
  case MENU_LAYOUT_NODE_MENU:
    node = (MenuLayoutNode *) g_new0 (MenuLayoutNodeMenu, 1)((MenuLayoutNodeMenu *) g_malloc0_n ((1), sizeof (MenuLayoutNodeMenu
)));
    break;

  case MENU_LAYOUT_NODE_LEGACY_DIR:
    node = (MenuLayoutNode *) g_new0 (MenuLayoutNodeLegacyDir, 1)((MenuLayoutNodeLegacyDir *) g_malloc0_n ((1), sizeof (MenuLayoutNodeLegacyDir
)));
    break;

  case MENU_LAYOUT_NODE_ROOT:
    node = (MenuLayoutNode*) g_new0 (MenuLayoutNodeRoot, 1)((MenuLayoutNodeRoot *) g_malloc0_n ((1), sizeof (MenuLayoutNodeRoot
)));
    break;

  case MENU_LAYOUT_NODE_MERGE_FILE:
    node = (MenuLayoutNode *) g_new0 (MenuLayoutNodeMergeFile, 1)((MenuLayoutNodeMergeFile *) g_malloc0_n ((1), sizeof (MenuLayoutNodeMergeFile
)));
    break;

  case MENU_LAYOUT_NODE_DEFAULT_LAYOUT:
    node = (MenuLayoutNode *) g_new0 (MenuLayoutNodeDefaultLayout, 1)((MenuLayoutNodeDefaultLayout *) g_malloc0_n ((1), sizeof (MenuLayoutNodeDefaultLayout
)));
    break;

  case MENU_LAYOUT_NODE_MENUNAME:
    node = (MenuLayoutNode *) g_new0 (MenuLayoutNodeMenuname, 1)((MenuLayoutNodeMenuname *) g_malloc0_n ((1), sizeof (MenuLayoutNodeMenuname
)));
    break;

  case MENU_LAYOUT_NODE_MERGE:
    node = (MenuLayoutNode *) g_new0 (MenuLayoutNodeMerge, 1)((MenuLayoutNodeMerge *) g_malloc0_n ((1), sizeof (MenuLayoutNodeMerge
)));
    break;

  default:
    node = g_new0 (MenuLayoutNode, 1)((MenuLayoutNode *) g_malloc0_n ((1), sizeof (MenuLayoutNode)
));
    break;
  }

node->type = type;

node->refcount = 1;

/* we're in a list of one node */
node->next = node;
node->prev = node;

return node;
315}

317MenuLayoutNode *
318menu_layout_node_get_next (MenuLayoutNode *node)
319{
return node_next (node);
321}

323MenuLayoutNode *
324menu_layout_node_get_parent (MenuLayoutNode *node)
325{
return node->parent;
327}

329MenuLayoutNode *
330menu_layout_node_get_children (MenuLayoutNode *node)
331{
return node->children;
333}

335MenuLayoutNode *
336menu_layout_node_get_root (MenuLayoutNode *node)
337{
MenuLayoutNode *parent;

parent = node;
while (parent->parent != NULL((void*)0))
  parent = parent->parent;

g_assert (parent->type == MENU_LAYOUT_NODE_ROOT)do { if (parent->type == MENU_LAYOUT_NODE_ROOT) ; else g_assertion_message_expr
 (((gchar*) 0), "menu-layout.c", 344, ((const char*) (__func__
)), "parent->type == MENU_LAYOUT_NODE_ROOT"); } while (0);

return parent;
347}

349char *
350menu_layout_node_get_content_as_path (MenuLayoutNode *node)
351{
if (node->content == NULL((void*)0))
  {
    menu_verbose ("  (node has no content to get as a path)\n");
    return NULL((void*)0);
  }

if (g_path_is_absolute (node->content))
  {
    return g_strdup (node->content)g_strdup_inline (node->content);
  }
else
  {
    MenuLayoutNodeRoot *root;

    root = (MenuLayoutNodeRoot *) menu_layout_node_get_root (node);

    if (root->basedir == NULL((void*)0))
      {
        menu_verbose ("No basedir available, using \"%s\" as-is\n",
                      node->content);
        return g_strdup (node->content)g_strdup_inline (node->content);
      }
    else
      {
        menu_verbose ("Using basedir \"%s\" filename \"%s\"\n",
                      root->basedir, node->content);
        return g_build_filename (root->basedir, node->content, NULL((void*)0));
      }
  }
381}

383#define RETURN_IF_NO_PARENT(node)do { if ((node)->parent == ((void*)0)) { g_warning ("To add siblings to a menu node, "
 "it must not be the root node, " "and must be linked in below some root node\n"
 "node parent = %p and type = %d", (node)->parent, (node)->
type); return; } } while (0) G_STMT_STARTdo {                  \
  if ((node)->parent == NULL((void*)0))                                   \
    {                                                           \
      g_warning ("To add siblings to a menu node, "             \
                 "it must not be the root node, "               \
                 "and must be linked in below some root node\n" \
                 "node parent = %p and type = %d",              \
                 (node)->parent, (node)->type);                 \
      return;                                                   \
    }                                                           \
} G_STMT_ENDwhile (0)

395#define RETURN_IF_HAS_ENTRY_DIRS(node)do { if ((node)->type == MENU_LAYOUT_NODE_MENU && (
((MenuLayoutNodeMenu*)(node))->app_dirs != ((void*)0) || (
(MenuLayoutNodeMenu*)(node))->dir_dirs != ((void*)0))) { g_warning
 ("node acquired ->app_dirs or ->dir_dirs " "while not rooted in a tree\n"
); return; } } while (0) G_STMT_STARTdo {             \
  if ((node)->type == MENU_LAYOUT_NODE_MENU &&                  \
      (((MenuLayoutNodeMenu*)(node))->app_dirs != NULL((void*)0) ||       \
       ((MenuLayoutNodeMenu*)(node))->dir_dirs != NULL((void*)0)))        \
    {                                                           \
      g_warning ("node acquired ->app_dirs or ->dir_dirs "      \
                 "while not rooted in a tree\n");               \
      return;                                                   \
    }                                                           \
} G_STMT_ENDwhile (0)                                                    \

406void
407menu_layout_node_insert_before (MenuLayoutNode *node,
                              MenuLayoutNode *new_sibling)
409{
g_return_if_fail (new_sibling != NULL)do { if ((new_sibling != ((void*)0))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "new_sibling != NULL"
); return; } } while (0);
g_return_if_fail (new_sibling->parent == NULL)do { if ((new_sibling->parent == ((void*)0))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "new_sibling->parent == NULL"
); return; } } while (0);

RETURN_IF_NO_PARENT (node)do { if ((node)->parent == ((void*)0)) { g_warning ("To add siblings to a menu node, "
 "it must not be the root node, " "and must be linked in below some root node\n"
 "node parent = %p and type = %d", (node)->parent, (node)->
type); return; } } while (0);
RETURN_IF_HAS_ENTRY_DIRS (new_sibling)do { if ((new_sibling)->type == MENU_LAYOUT_NODE_MENU &&
 (((MenuLayoutNodeMenu*)(new_sibling))->app_dirs != ((void
*)0) || ((MenuLayoutNodeMenu*)(new_sibling))->dir_dirs != (
(void*)0))) { g_warning ("node acquired ->app_dirs or ->dir_dirs "
 "while not rooted in a tree\n"); return; } } while (0);

new_sibling->next = node;
new_sibling->prev = node->prev;

node->prev = new_sibling;
new_sibling->prev->next = new_sibling;

new_sibling->parent = node->parent;

if (node == node->parent->children)
  node->parent->children = new_sibling;

menu_layout_node_ref (new_sibling);
428}

430void
431menu_layout_node_insert_after (MenuLayoutNode *node,
                             MenuLayoutNode *new_sibling)
433{
g_return_if_fail (new_sibling != NULL)do { if ((new_sibling != ((void*)0))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "new_sibling != NULL"
); return; } } while (0);
g_return_if_fail (new_sibling->parent == NULL)do { if ((new_sibling->parent == ((void*)0))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "new_sibling->parent == NULL"
); return; } } while (0);

RETURN_IF_NO_PARENT (node)do { if ((node)->parent == ((void*)0)) { g_warning ("To add siblings to a menu node, "
 "it must not be the root node, " "and must be linked in below some root node\n"
 "node parent = %p and type = %d", (node)->parent, (node)->
type); return; } } while (0);
RETURN_IF_HAS_ENTRY_DIRS (new_sibling)do { if ((new_sibling)->type == MENU_LAYOUT_NODE_MENU &&
 (((MenuLayoutNodeMenu*)(new_sibling))->app_dirs != ((void
*)0) || ((MenuLayoutNodeMenu*)(new_sibling))->dir_dirs != (
(void*)0))) { g_warning ("node acquired ->app_dirs or ->dir_dirs "
 "while not rooted in a tree\n"); return; } } while (0);

new_sibling->prev = node;
new_sibling->next = node->next;

node->next = new_sibling;
new_sibling->next->prev = new_sibling;

new_sibling->parent = node->parent;

menu_layout_node_ref (new_sibling);
449}

451void
452menu_layout_node_prepend_child (MenuLayoutNode *parent,
                              MenuLayoutNode *new_child)
454{
RETURN_IF_HAS_ENTRY_DIRS (new_child)do { if ((new_child)->type == MENU_LAYOUT_NODE_MENU &&
 (((MenuLayoutNodeMenu*)(new_child))->app_dirs != ((void*)
0) || ((MenuLayoutNodeMenu*)(new_child))->dir_dirs != ((void
*)0))) { g_warning ("node acquired ->app_dirs or ->dir_dirs "
 "while not rooted in a tree\n"); return; } } while (0);

if (parent->children)
  {
    menu_layout_node_insert_before (parent->children, new_child);
  }
else
  {
    parent->children = menu_layout_node_ref (new_child);
    new_child->parent = parent;
  }
466}

468void
469menu_layout_node_append_child (MenuLayoutNode *parent,
                             MenuLayoutNode *new_child)
471{
RETURN_IF_HAS_ENTRY_DIRS (new_child)do { if ((new_child)->type == MENU_LAYOUT_NODE_MENU &&
 (((MenuLayoutNodeMenu*)(new_child))->app_dirs != ((void*)
0) || ((MenuLayoutNodeMenu*)(new_child))->dir_dirs != ((void
*)0))) { g_warning ("node acquired ->app_dirs or ->dir_dirs "
 "while not rooted in a tree\n"); return; } } while (0);

if (parent->children)
  {
    menu_layout_node_insert_after (parent->children->prev, new_child);
  }
else
  {
    parent->children = menu_layout_node_ref (new_child);
    new_child->parent = parent;
  }
483}

485void
486menu_layout_node_unlink (MenuLayoutNode *node)
487{
g_return_if_fail (node != NULL)do { if ((node != ((void*)0))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "node != NULL"); return
; } } while (0);
30
←
Taking true branch→
31
←
Loop condition is false.  Exiting loop→
g_return_if_fail (node->parent != NULL)do { if ((node->parent != ((void*)0))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "node->parent != NULL"
); return; } } while (0);
32
←
Taking true branch→
33
←
Loop condition is false.  Exiting loop→

menu_layout_node_steal (node);
34
←
Calling 'menu_layout_node_steal'→
menu_layout_node_unref (node);
493}

495static void
496recursive_clean_entry_directory_lists (MenuLayoutNode *node,
                                     gboolean        apps)
498{
EntryDirectoryList **dirs;
MenuLayoutNodeMenu  *nm;
MenuLayoutNode      *iter;

if (node->type != MENU_LAYOUT_NODE_MENU)
  return;

nm = (MenuLayoutNodeMenu *) node;

dirs = apps ? &nm->app_dirs : &nm->dir_dirs;

if (*dirs == NULL((void*)0) || entry_directory_list_get_length (*dirs) == 0)
  return; /* child menus continue to have valid lists */

remove_entry_directory_list (nm, dirs);

iter = node->children;
while (iter != NULL((void*)0))
  {
    if (iter->type == MENU_LAYOUT_NODE_MENU)
      recursive_clean_entry_directory_lists (iter, apps);

    iter = node_next (iter);
  }
523}

525void
526menu_layout_node_steal (MenuLayoutNode *node)
527{
g_return_if_fail (node != NULL)do { if ((node != ((void*)0))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "node != NULL"); return
; } } while (0);
35
←
Taking true branch→
36
←
Loop condition is false.  Exiting loop→
g_return_if_fail (node->parent != NULL)do { if ((node->parent != ((void*)0))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "node->parent != NULL"
); return; } } while (0);
37
←
Taking true branch→
38
←
Loop condition is false.  Exiting loop→

switch (node->type)
39
←
Control jumps to the 'default' case at line 553→
  {
  case MENU_LAYOUT_NODE_NAME:
    {
      MenuLayoutNodeMenu *nm = (MenuLayoutNodeMenu *) node->parent;

      if (nm->name_node == node)
        {
          menu_layout_node_unref (nm->name_node);
          nm->name_node = NULL((void*)0);
        }
    }
    break;

  case MENU_LAYOUT_NODE_APP_DIR:
    recursive_clean_entry_directory_lists (node->parent, TRUE(!(0)));
    break;

  case MENU_LAYOUT_NODE_DIRECTORY_DIR:
    recursive_clean_entry_directory_lists (node->parent, FALSE(0));
    break;

  default:
    break;
40
←
 Execution continues on line 557→
  }

if (node->parent40.1
Field 'parent' is non-null
 && node->parent->children == node)
41
←
Assuming 'node' is not equal to field 'children'→
42
←
Taking false branch→
  {
    if (node->next != node)
      node->parent->children = node->next;
    else
      node->parent->children = NULL((void*)0);
  }

/* these are no-ops for length-one node lists */
node->prev->next = node->next;
node->next->prev = node->prev;
43
←
Access to field 'prev' results in a dereference of a null pointer (loaded from field 'next')

node->parent = NULL((void*)0);

/* point to ourselves, now we're length one */
node->next = node;
node->prev = node;
574}

576MenuLayoutNodeType
577menu_layout_node_get_type (MenuLayoutNode *node)
578{
return node->type;
580}

582const char *
583menu_layout_node_get_content (MenuLayoutNode *node)
584{
return node->content;
586}

588void
589menu_layout_node_set_content (MenuLayoutNode *node,
                            const char     *content)
591{
if (node->content == content)
  return;

g_free (node->content);
node->content = g_strdup (content)g_strdup_inline (content);
597}

599const char *
600menu_layout_node_root_get_name (MenuLayoutNode *node)
601{
MenuLayoutNodeRoot *nr;

g_return_val_if_fail (node->type == MENU_LAYOUT_NODE_ROOT, NULL)do { if ((node->type == MENU_LAYOUT_NODE_ROOT)) { } else {
 g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__
)), "node->type == MENU_LAYOUT_NODE_ROOT"); return (((void
*)0)); } } while (0);

nr = (MenuLayoutNodeRoot*) node;

return nr->name;
609}

611const char *
612menu_layout_node_root_get_basedir (MenuLayoutNode *node)
613{
MenuLayoutNodeRoot *nr;

g_return_val_if_fail (node->type == MENU_LAYOUT_NODE_ROOT, NULL)do { if ((node->type == MENU_LAYOUT_NODE_ROOT)) { } else {
 g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__
)), "node->type == MENU_LAYOUT_NODE_ROOT"); return (((void
*)0)); } } while (0);

nr = (MenuLayoutNodeRoot*) node;

return nr->basedir;
621}

623const char *
624menu_layout_node_menu_get_name (MenuLayoutNode *node)
625{
MenuLayoutNodeMenu *nm;

g_return_val_if_fail (node->type == MENU_LAYOUT_NODE_MENU, NULL)do { if ((node->type == MENU_LAYOUT_NODE_MENU)) { } else {
 g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__
)), "node->type == MENU_LAYOUT_NODE_MENU"); return (((void
*)0)); } } while (0);

nm = (MenuLayoutNodeMenu*) node;

if (nm->name_node == NULL((void*)0))
  {
    MenuLayoutNode *iter;

    iter = node->children;
    while (iter != NULL((void*)0))
      {
        if (iter->type == MENU_LAYOUT_NODE_NAME)
          {
            nm->name_node = menu_layout_node_ref (iter);
            break;
          }

        iter = node_next (iter);
      }
  }

if (nm->name_node == NULL((void*)0))
  return NULL((void*)0);

return menu_layout_node_get_content (nm->name_node);
653}

655static void
656ensure_dir_lists (MenuLayoutNodeMenu *nm)
657{
MenuLayoutNode     *node;
MenuLayoutNode     *iter;
EntryDirectoryList *app_dirs;
EntryDirectoryList *dir_dirs;

node = (MenuLayoutNode *) nm;

if (nm->app_dirs && nm->dir_dirs)
  return;

app_dirs = NULL((void*)0);
dir_dirs = NULL((void*)0);

if (nm->app_dirs == NULL((void*)0))
  {
    app_dirs = entry_directory_list_new ();

    if (node->parent && node->parent->type == MENU_LAYOUT_NODE_MENU)
      {
        EntryDirectoryList *dirs;

        if ((dirs = menu_layout_node_menu_get_app_dirs (node->parent)))
          entry_directory_list_append_list (app_dirs, dirs);
      }
  }

if (nm->dir_dirs == NULL((void*)0))
  {
    dir_dirs = entry_directory_list_new ();

    if (node->parent && node->parent->type == MENU_LAYOUT_NODE_MENU)
      {
        EntryDirectoryList *dirs;

        if ((dirs = menu_layout_node_menu_get_directory_dirs (node->parent)))
          entry_directory_list_append_list (dir_dirs, dirs);
      }
  }

iter = node->children;
while (iter != NULL((void*)0))
  {
    EntryDirectory *ed;

    if (app_dirs != NULL((void*)0) && iter->type == MENU_LAYOUT_NODE_APP_DIR)
      {
        char *path;

        path = menu_layout_node_get_content_as_path (iter);

        ed = entry_directory_new (DESKTOP_ENTRY_DESKTOP, path);
        if (ed != NULL((void*)0))
          {
            entry_directory_list_prepend (app_dirs, ed);
            entry_directory_unref (ed);
          }

        g_free (path);
      }

    if (dir_dirs != NULL((void*)0) && iter->type == MENU_LAYOUT_NODE_DIRECTORY_DIR)
      {
        char *path;

        path = menu_layout_node_get_content_as_path (iter);

        ed = entry_directory_new (DESKTOP_ENTRY_DIRECTORY, path);
        if (ed != NULL((void*)0))
          {
            entry_directory_list_prepend (dir_dirs, ed);
            entry_directory_unref (ed);
          }

        g_free (path);
      }

    if (iter->type == MENU_LAYOUT_NODE_LEGACY_DIR)
      {
        MenuLayoutNodeLegacyDir *legacy = (MenuLayoutNodeLegacyDir *) iter;
        char                    *path;

        path = menu_layout_node_get_content_as_path (iter);

        if (app_dirs != NULL((void*)0)) /* we're loading app dirs */
          {
            ed = entry_directory_new_legacy (DESKTOP_ENTRY_DESKTOP,
                                             path,
                                             legacy->prefix);
            if (ed != NULL((void*)0))
              {
                entry_directory_list_prepend (app_dirs, ed);
                entry_directory_unref (ed);
              }
          }

        if (dir_dirs != NULL((void*)0)) /* we're loading dir dirs */
          {
            ed = entry_directory_new_legacy (DESKTOP_ENTRY_DIRECTORY,
                                             path,
                                             legacy->prefix);
            if (ed != NULL((void*)0))
              {
                entry_directory_list_prepend (dir_dirs, ed);
                entry_directory_unref (ed);
              }
          }

        g_free (path);
      }

    iter = node_next (iter);
  }

if (app_dirs)
  {
    g_assert (nm->app_dirs == NULL)do { if (nm->app_dirs == ((void*)0)) ; else g_assertion_message_expr
 (((gchar*) 0), "menu-layout.c", 773, ((const char*) (__func__
)), "nm->app_dirs == NULL"); } while (0);

    nm->app_dirs = app_dirs;
    entry_directory_list_add_monitors (nm->app_dirs,
                                       (EntryDirectoryChangedFunc) handle_entry_directory_changed,
                                       nm);
  }

if (dir_dirs)
  {
    g_assert (nm->dir_dirs == NULL)do { if (nm->dir_dirs == ((void*)0)) ; else g_assertion_message_expr
 (((gchar*) 0), "menu-layout.c", 783, ((const char*) (__func__
)), "nm->dir_dirs == NULL"); } while (0);

    nm->dir_dirs = dir_dirs;
    entry_directory_list_add_monitors (nm->dir_dirs,
                                       (EntryDirectoryChangedFunc) handle_entry_directory_changed,
                                       nm);
  }
790}

792EntryDirectoryList *
793menu_layout_node_menu_get_app_dirs (MenuLayoutNode *node)
794{
MenuLayoutNodeMenu *nm;

g_return_val_if_fail (node->type == MENU_LAYOUT_NODE_MENU, NULL)do { if ((node->type == MENU_LAYOUT_NODE_MENU)) { } else {
 g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__
)), "node->type == MENU_LAYOUT_NODE_MENU"); return (((void
*)0)); } } while (0);

nm = (MenuLayoutNodeMenu *) node;

ensure_dir_lists (nm);

return nm->app_dirs;
804}

806EntryDirectoryList *
807menu_layout_node_menu_get_directory_dirs (MenuLayoutNode *node)
808{
MenuLayoutNodeMenu *nm;

g_return_val_if_fail (node->type == MENU_LAYOUT_NODE_MENU, NULL)do { if ((node->type == MENU_LAYOUT_NODE_MENU)) { } else {
 g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__
)), "node->type == MENU_LAYOUT_NODE_MENU"); return (((void
*)0)); } } while (0);

nm = (MenuLayoutNodeMenu *) node;

ensure_dir_lists (nm);

return nm->dir_dirs;
818}

820const char *
821menu_layout_node_move_get_old (MenuLayoutNode *node)
822{
MenuLayoutNode *iter;

iter = node->children;
while (iter != NULL((void*)0))
  {
    if (iter->type == MENU_LAYOUT_NODE_OLD)
      return iter->content;

    iter = node_next (iter);
  }

return NULL((void*)0);
835}

837const char *
838menu_layout_node_move_get_new (MenuLayoutNode *node)
839{
MenuLayoutNode *iter;

iter = node->children;
while (iter != NULL((void*)0))
  {
    if (iter->type == MENU_LAYOUT_NODE_NEW)
      return iter->content;

    iter = node_next (iter);
  }

return NULL((void*)0);
852}

854const char *
855menu_layout_node_legacy_dir_get_prefix (MenuLayoutNode *node)
856{
MenuLayoutNodeLegacyDir *legacy;

g_return_val_if_fail (node->type == MENU_LAYOUT_NODE_LEGACY_DIR, NULL)do { if ((node->type == MENU_LAYOUT_NODE_LEGACY_DIR)) { } else
 { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__
)), "node->type == MENU_LAYOUT_NODE_LEGACY_DIR"); return (
((void*)0)); } } while (0);

legacy = (MenuLayoutNodeLegacyDir *) node;

return legacy->prefix;
864}

866void
867menu_layout_node_legacy_dir_set_prefix (MenuLayoutNode *node,
                                      const char     *prefix)
869{
MenuLayoutNodeLegacyDir *legacy;

g_return_if_fail (node->type == MENU_LAYOUT_NODE_LEGACY_DIR)do { if ((node->type == MENU_LAYOUT_NODE_LEGACY_DIR)) { } else
 { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__
)), "node->type == MENU_LAYOUT_NODE_LEGACY_DIR"); return; }
 } while (0);

legacy = (MenuLayoutNodeLegacyDir *) node;

g_free (legacy->prefix);
legacy->prefix = g_strdup (prefix)g_strdup_inline (prefix);
878}

880MenuMergeFileType
881menu_layout_node_merge_file_get_type (MenuLayoutNode *node)
882{
MenuLayoutNodeMergeFile *merge_file;

g_return_val_if_fail (node->type == MENU_LAYOUT_NODE_MERGE_FILE, FALSE)do { if ((node->type == MENU_LAYOUT_NODE_MERGE_FILE)) { } else
 { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__
)), "node->type == MENU_LAYOUT_NODE_MERGE_FILE"); return (
(0)); } } while (0);

merge_file = (MenuLayoutNodeMergeFile *) node;

return merge_file->type;
890}

892void
893menu_layout_node_merge_file_set_type (MenuLayoutNode    *node,
		      MenuMergeFileType  type)
895{
MenuLayoutNodeMergeFile *merge_file;

g_return_if_fail (node->type == MENU_LAYOUT_NODE_MERGE_FILE)do { if ((node->type == MENU_LAYOUT_NODE_MERGE_FILE)) { } else
 { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__
)), "node->type == MENU_LAYOUT_NODE_MERGE_FILE"); return; }
 } while (0);

merge_file = (MenuLayoutNodeMergeFile *) node;

merge_file->type = type;
903}

905MenuLayoutMergeType
906menu_layout_node_merge_get_type (MenuLayoutNode *node)
907{
MenuLayoutNodeMerge *merge;

g_return_val_if_fail (node->type == MENU_LAYOUT_NODE_MERGE, 0)do { if ((node->type == MENU_LAYOUT_NODE_MERGE)) { } else {
 g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__
)), "node->type == MENU_LAYOUT_NODE_MERGE"); return (0); }
 } while (0);

merge = (MenuLayoutNodeMerge *) node;

return merge->merge_type;
915}

917static void
918menu_layout_node_merge_set_type (MenuLayoutNode *node,
                               const char     *merge_type)
920{
MenuLayoutNodeMerge *merge;

g_return_if_fail (node->type == MENU_LAYOUT_NODE_MERGE)do { if ((node->type == MENU_LAYOUT_NODE_MERGE)) { } else {
 g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__
)), "node->type == MENU_LAYOUT_NODE_MERGE"); return; } } while
 (0);

merge = (MenuLayoutNodeMerge *) node;

merge->merge_type = MENU_LAYOUT_MERGE_NONE;

if (strcmp (merge_type, "menus") == 0)
  {
    merge->merge_type = MENU_LAYOUT_MERGE_MENUS;
  }
else if (strcmp (merge_type, "files") == 0)
  {
    merge->merge_type = MENU_LAYOUT_MERGE_FILES;
  }
else if (strcmp (merge_type, "all") == 0)
  {
    merge->merge_type = MENU_LAYOUT_MERGE_ALL;
  }
941}

943void
944menu_layout_node_default_layout_get_values (MenuLayoutNode   *node,
			    MenuLayoutValues *values)
946{
MenuLayoutNodeDefaultLayout *default_layout;

g_return_if_fail (node->type == MENU_LAYOUT_NODE_DEFAULT_LAYOUT)do { if ((node->type == MENU_LAYOUT_NODE_DEFAULT_LAYOUT)) {
 } else { g_return_if_fail_warning (((gchar*) 0), ((const char
*) (__func__)), "node->type == MENU_LAYOUT_NODE_DEFAULT_LAYOUT"
); return; } } while (0);
g_return_if_fail (values != NULL)do { if ((values != ((void*)0))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "values != NULL")
; return; } } while (0);

default_layout = (MenuLayoutNodeDefaultLayout *) node;

*values = default_layout->layout_values;
955}

957void
958menu_layout_node_menuname_get_values (MenuLayoutNode   *node,
		      MenuLayoutValues *values)
960{
MenuLayoutNodeMenuname *menuname;

g_return_if_fail (node->type == MENU_LAYOUT_NODE_MENUNAME)do { if ((node->type == MENU_LAYOUT_NODE_MENUNAME)) { } else
 { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__
)), "node->type == MENU_LAYOUT_NODE_MENUNAME"); return; } }
 while (0);
g_return_if_fail (values != NULL)do { if ((values != ((void*)0))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "values != NULL")
; return; } } while (0);

menuname = (MenuLayoutNodeMenuname *) node;

*values = menuname->layout_values;
969}

971static void
972menu_layout_values_set (MenuLayoutValues *values,
	const char       *show_empty,
	const char       *inline_menus,
	const char       *inline_limit,
	const char       *inline_header,
	const char       *inline_alias)
978{
values->mask          = MENU_LAYOUT_VALUES_NONE;
values->show_empty    = FALSE(0);
values->inline_menus  = FALSE(0);
values->inline_limit  = 4;
values->inline_header = FALSE(0);
values->inline_alias  = FALSE(0);

if (show_empty != NULL((void*)0))
  {
    values->show_empty = strcmp (show_empty, "true") == 0;
    values->mask |= MENU_LAYOUT_VALUES_SHOW_EMPTY;
  }

if (inline_menus != NULL((void*)0))
  {
    values->inline_menus = strcmp (inline_menus, "true") == 0;
    values->mask |= MENU_LAYOUT_VALUES_INLINE_MENUS;
  }

if (inline_limit != NULL((void*)0))
  {
    char *end;
    int   limit;

    limit = strtol (inline_limit, &end, 10);
    if (*end == '\0')
{
 values->inline_limit = limit;
 values->mask |= MENU_LAYOUT_VALUES_INLINE_LIMIT;
}
  }

if (inline_header != NULL((void*)0))
  {
    values->inline_header = strcmp (inline_header, "true") == 0;
    values->mask |= MENU_LAYOUT_VALUES_INLINE_HEADER;
  }

if (inline_alias != NULL((void*)0))
  {
    values->inline_alias = strcmp (inline_alias, "true") == 0;
    values->mask |= MENU_LAYOUT_VALUES_INLINE_ALIAS;
  }
1022}

1024static void
1025menu_layout_node_default_layout_set_values (MenuLayoutNode *node,
			    const char     *show_empty,
			    const char     *inline_menus,
			    const char     *inline_limit,
			    const char     *inline_header,
			    const char     *inline_alias)
1031{
MenuLayoutNodeDefaultLayout *default_layout;

g_return_if_fail (node->type == MENU_LAYOUT_NODE_DEFAULT_LAYOUT)do { if ((node->type == MENU_LAYOUT_NODE_DEFAULT_LAYOUT)) {
 } else { g_return_if_fail_warning (((gchar*) 0), ((const char
*) (__func__)), "node->type == MENU_LAYOUT_NODE_DEFAULT_LAYOUT"
); return; } } while (0);

default_layout = (MenuLayoutNodeDefaultLayout *) node;

menu_layout_values_set (&default_layout->layout_values,
	  show_empty,
	  inline_menus,
	  inline_limit,
	  inline_header,
	  inline_alias);
1044}

1046static void
1047menu_layout_node_menuname_set_values (MenuLayoutNode *node,
		      const char     *show_empty,
		      const char     *inline_menus,
		      const char     *inline_limit,
		      const char     *inline_header,
		      const char     *inline_alias)
1053{
MenuLayoutNodeMenuname *menuname;

g_return_if_fail (node->type == MENU_LAYOUT_NODE_MENUNAME)do { if ((node->type == MENU_LAYOUT_NODE_MENUNAME)) { } else
 { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__
)), "node->type == MENU_LAYOUT_NODE_MENUNAME"); return; } }
 while (0);

menuname = (MenuLayoutNodeMenuname *) node;

menu_layout_values_set (&menuname->layout_values,
	  show_empty,
	  inline_menus,
	  inline_limit,
	  inline_header,
	  inline_alias);
1066}

1068void
1069menu_layout_node_root_add_entries_monitor (MenuLayoutNode                   *node,
                                         MenuLayoutNodeEntriesChangedFunc  callback,
                                         gpointer                          user_data)
1072{
MenuLayoutNodeEntriesMonitor *monitor;
MenuLayoutNodeRoot           *nr;
GSList                       *tmp;

g_return_if_fail (node->type == MENU_LAYOUT_NODE_ROOT)do { if ((node->type == MENU_LAYOUT_NODE_ROOT)) { } else {
 g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__
)), "node->type == MENU_LAYOUT_NODE_ROOT"); return; } } while
 (0);

nr = (MenuLayoutNodeRoot *) node;

tmp = nr->monitors;
while (tmp != NULL((void*)0))
  {
    monitor = tmp->data;

    if (monitor->callback  == callback &&
        monitor->user_data == user_data)
      break;

    tmp = tmp->next;
  }

if (tmp == NULL((void*)0))
  {
    monitor            = g_new0 (MenuLayoutNodeEntriesMonitor, 1)((MenuLayoutNodeEntriesMonitor *) g_malloc0_n ((1), sizeof (MenuLayoutNodeEntriesMonitor
)));
    monitor->callback  = callback;
    monitor->user_data = user_data;

    nr->monitors = g_slist_append (nr->monitors, monitor);
  }
1101}

1103void
1104menu_layout_node_root_remove_entries_monitor (MenuLayoutNode                   *node,
                                            MenuLayoutNodeEntriesChangedFunc  callback,
                                            gpointer                          user_data)
1107{
MenuLayoutNodeRoot *nr;
GSList             *tmp;

g_return_if_fail (node->type == MENU_LAYOUT_NODE_ROOT)do { if ((node->type == MENU_LAYOUT_NODE_ROOT)) { } else {
 g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__
)), "node->type == MENU_LAYOUT_NODE_ROOT"); return; } } while
 (0);

nr = (MenuLayoutNodeRoot *) node;

tmp = nr->monitors;
while (tmp != NULL((void*)0))
  {
    MenuLayoutNodeEntriesMonitor *monitor = tmp->data;
    GSList                       *next = tmp->next;

    if (monitor->callback == callback &&
        monitor->user_data == user_data)
      {
        nr->monitors = g_slist_delete_link (nr->monitors, tmp);
        g_free (monitor);
      }

    tmp = next;
  }
1130}


1133/*
* Menu file parsing
*/

1137typedef struct
1138{
MenuLayoutNode *root;
MenuLayoutNode *stack_top;
1141} MenuParser;

1143static void set_error (GError             **err,
                     GMarkupParseContext *context,
                     int                  error_domain,
                     int                  error_code,
                     const char          *format,
                     ...) G_GNUC_PRINTF (5, 6)__attribute__((__format__ (__printf__, 5, 6)));

1150static void add_context_to_error (GError             **err,
                                GMarkupParseContext *context);

1153static void start_element_handler (GMarkupParseContext  *context,
                                 const char           *element_name,
                                 const char          **attribute_names,
                                 const char          **attribute_values,
                                 gpointer              user_data,
                                 GError              **error);
1159static void end_element_handler   (GMarkupParseContext  *context,
                                 const char           *element_name,
                                 gpointer              user_data,
                                 GError              **error);
1163static void text_handler          (GMarkupParseContext  *context,
                                 const char           *text,
                                 gsize                 text_len,
                                 gpointer              user_data,
                                 GError              **error);
1168static void passthrough_handler   (GMarkupParseContext  *context,
                                 const char           *passthrough_text,
                                 gsize                 text_len,
                                 gpointer              user_data,
                                 GError              **error);


1175static GMarkupParser menu_funcs = {
start_element_handler,
end_element_handler,
text_handler,
passthrough_handler,
NULL((void*)0)
1181};

1183static void
1184set_error (GError              **err,
         GMarkupParseContext  *context,
         int                   error_domain,
         int                   error_code,
         const char           *format,
         ...)
1190{
int      line, ch;
va_list  args;
char    *str;

g_markup_parse_context_get_position (context, &line, &ch);

va_start (args, format)__builtin_va_start(args, format);
str = g_strdup_vprintf (format, args);
va_end (args)__builtin_va_end(args);

g_set_error (err, error_domain, error_code,
             "Line %d character %d: %s",
             line, ch, str);

g_free (str);
1206}

1208static void
1209add_context_to_error (GError             **err,
                    GMarkupParseContext *context)
1211{
int   line, ch;
char *str;

if (err == NULL((void*)0) || *err == NULL((void*)0))
  return;

g_markup_parse_context_get_position (context, &line, &ch);

str = g_strdup_printf ("Line %d character %d: %s",
                       line, ch, (*err)->message);
g_free ((*err)->message);
(*err)->message = str;
1224}

1226#define ELEMENT_IS(name)(strcmp (element_name, (name)) == 0) (strcmp (element_name, (name)) == 0)

1228typedef struct
1229{
const char  *name;
const char **retloc;
1232} LocateAttr;

1234static gboolean
1235locate_attributes (GMarkupParseContext  *context,
                 const char           *element_name,
                 const char          **attribute_names,
                 const char          **attribute_values,
                 GError              **error,
                 const char           *first_attribute_name,
                 const char          **first_attribute_retloc,
                 ...)
1243{
1244#define MAX_ATTRS 24
LocateAttr   attrs[MAX_ATTRS];
int          n_attrs;
va_list      args;
const char  *name;
const char **retloc;
gboolean     retval;
int          i;

g_return_val_if_fail (first_attribute_name != NULL, FALSE)do { if ((first_attribute_name != ((void*)0))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "first_attribute_name != NULL"
); return ((0)); } } while (0);
g_return_val_if_fail (first_attribute_retloc != NULL, FALSE)do { if ((first_attribute_retloc != ((void*)0))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "first_attribute_retloc != NULL"
); return ((0)); } } while (0);

retval = TRUE(!(0));

n_attrs = 1;
attrs[0].name = first_attribute_name;
attrs[0].retloc = first_attribute_retloc;
*first_attribute_retloc = NULL((void*)0);

va_start (args, first_attribute_retloc)__builtin_va_start(args, first_attribute_retloc);

name = va_arg (args, const char *)__builtin_va_arg(args, const char *);
retloc = va_arg (args, const char **)__builtin_va_arg(args, const char **);

while (name != NULL((void*)0))
  {
    g_return_val_if_fail (retloc != NULL, FALSE)do { if ((retloc != ((void*)0))) { } else { g_return_if_fail_warning
 (((gchar*) 0), ((const char*) (__func__)), "retloc != NULL")
; return ((0)); } } while (0);

    g_assert (n_attrs < MAX_ATTRS)do { if (n_attrs < MAX_ATTRS) ; else g_assertion_message_expr
 (((gchar*) 0), "menu-layout.c", 1272, ((const char*) (__func__
)), "n_attrs < MAX_ATTRS"); } while (0);

    attrs[n_attrs].name = name;
    attrs[n_attrs].retloc = retloc;
    n_attrs += 1;
    *retloc = NULL((void*)0);

    name = va_arg (args, const char *)__builtin_va_arg(args, const char *);
    retloc = va_arg (args, const char **)__builtin_va_arg(args, const char **);
  }

va_end (args)__builtin_va_end(args);

i = 0;
while (attribute_names[i])
  {
    int j;

    j = 0;
    while (j < n_attrs)
      {
        if (strcmp (attrs[j].name, attribute_names[i]) == 0)
          {
            retloc = attrs[j].retloc;

            if (*retloc != NULL((void*)0))
              {
                set_error (error, context,
                           G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_PARSE,
                           "Attribute \"%s\" repeated twice on the same <%s> element",
                           attrs[j].name, element_name);
                retval = FALSE(0);
                goto out;
              }

            *retloc = attribute_values[i];
            break;
          }

        ++j;
      }

    if (j == n_attrs)
      {
        set_error (error, context,
                   G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_PARSE,
                   "Attribute \"%s\" is invalid on <%s> element in this context",
                   attribute_names[i], element_name);
        retval = FALSE(0);
        goto out;
      }

    ++i;
  }

out:
return retval;

1330#undef MAX_ATTRS
1331}

1333static gboolean
1334check_no_attributes (GMarkupParseContext  *context,
     const char           *element_name,
     const char          **attribute_names,
     const char          **attribute_values G_GNUC_UNUSED__attribute__ ((__unused__)),
     GError              **error)
1339{
if (attribute_names[0] != NULL((void*)0))
  {
    set_error (error, context,
               G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_PARSE,
               "Attribute \"%s\" is invalid on <%s> element in this context",
               attribute_names[0], element_name);
    return FALSE(0);
  }

return TRUE(!(0));
1350}

1352static int
1353has_child_of_type (MenuLayoutNode     *node,
                 MenuLayoutNodeType  type)
1355{
MenuLayoutNode *iter;

iter = node->children;
while (iter)
  {
    if (iter->type == type)
      return TRUE(!(0));

    iter = node_next (iter);
  }

return FALSE(0);
1368}

1370static void
1371push_node (MenuParser         *parser,
         MenuLayoutNodeType  type)
1373{
MenuLayoutNode *node;

node = menu_layout_node_new (type);
menu_layout_node_append_child (parser->stack_top, node);
menu_layout_node_unref (node);

parser->stack_top = node;
1381}

1383static void
1384start_menu_element (MenuParser           *parser,
                  GMarkupParseContext  *context,
                  const char           *element_name,
                  const char          **attribute_names,
                  const char          **attribute_values,
                  GError              **error)
1390{
if (!check_no_attributes (context, element_name,
                          attribute_names, attribute_values,
                          error))
  return;

if (!(parser->stack_top->type == MENU_LAYOUT_NODE_ROOT ||
      parser->stack_top->type == MENU_LAYOUT_NODE_MENU))
  {
    set_error (error, context,
               G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_PARSE,
               "<Menu> element can only appear below other <Menu> elements or at toplevel\n");
  }
else
  {
    push_node (parser, MENU_LAYOUT_NODE_MENU);
  }
1407}

1409static void
1410start_menu_child_element (MenuParser           *parser,
                        GMarkupParseContext  *context,
                        const char           *element_name,
                        const char          **attribute_names,
                        const char          **attribute_values,
                        GError              **error)
1416{
if (ELEMENT_IS ("LegacyDir")(strcmp (element_name, ("LegacyDir")) == 0))
  {
    const char *prefix;

    push_node (parser, MENU_LAYOUT_NODE_LEGACY_DIR);

    if (!locate_attributes (context, element_name,
                            attribute_names, attribute_values,
                            error,
                            "prefix", &prefix,
                            NULL((void*)0)))
      return;

    menu_layout_node_legacy_dir_set_prefix (parser->stack_top, prefix);
  }
else if (ELEMENT_IS ("MergeFile")(strcmp (element_name, ("MergeFile")) == 0))
  {
    const char *type;

    push_node (parser, MENU_LAYOUT_NODE_MERGE_FILE);

    if (!locate_attributes (context, element_name,
                            attribute_names, attribute_values,
                            error,
                            "type", &type,
                            NULL((void*)0)))
      return;

    if (type != NULL((void*)0) && strcmp (type, "parent") == 0)
{
 menu_layout_node_merge_file_set_type (parser->stack_top,
				MENU_MERGE_FILE_TYPE_PARENT);
}
  }
else if (ELEMENT_IS ("DefaultLayout")(strcmp (element_name, ("DefaultLayout")) == 0))
  {
    const char *show_empty;
    const char *inline_menus;
    const char *inline_limit;
    const char *inline_header;
    const char *inline_alias;

    push_node (parser, MENU_LAYOUT_NODE_DEFAULT_LAYOUT);

    locate_attributes (context, element_name,
                       attribute_names, attribute_values,
                       error,
                       "show_empty",    &show_empty,
                       "inline",        &inline_menus,
                       "inline_limit",  &inline_limit,
                       "inline_header", &inline_header,
                       "inline_alias",  &inline_alias,
                       NULL((void*)0));

    menu_layout_node_default_layout_set_values (parser->stack_top,
				  show_empty,
				  inline_menus,
				  inline_limit,
				  inline_header,
				  inline_alias);
  }
else
  {
    if (!check_no_attributes (context, element_name,
                              attribute_names, attribute_values,
                              error))
      return;

    if (ELEMENT_IS ("AppDir")(strcmp (element_name, ("AppDir")) == 0))
      {
        push_node (parser, MENU_LAYOUT_NODE_APP_DIR);
      }
    else if (ELEMENT_IS ("DefaultAppDirs")(strcmp (element_name, ("DefaultAppDirs")) == 0))
      {
        push_node (parser, MENU_LAYOUT_NODE_DEFAULT_APP_DIRS);
      }
    else if (ELEMENT_IS ("DirectoryDir")(strcmp (element_name, ("DirectoryDir")) == 0))
      {
        push_node (parser, MENU_LAYOUT_NODE_DIRECTORY_DIR);
      }
    else if (ELEMENT_IS ("DefaultDirectoryDirs")(strcmp (element_name, ("DefaultDirectoryDirs")) == 0))
      {
        push_node (parser, MENU_LAYOUT_NODE_DEFAULT_DIRECTORY_DIRS);
      }
    else if (ELEMENT_IS ("DefaultMergeDirs")(strcmp (element_name, ("DefaultMergeDirs")) == 0))
      {
        push_node (parser, MENU_LAYOUT_NODE_DEFAULT_MERGE_DIRS);
      }
    else if (ELEMENT_IS ("Name")(strcmp (element_name, ("Name")) == 0))
      {
        if (has_child_of_type (parser->stack_top, MENU_LAYOUT_NODE_NAME))
          {
            set_error (error, context,
                       G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_PARSE,
                       "Multiple <Name> elements in a <Menu> element is not allowed\n");
            return;
          }

        push_node (parser, MENU_LAYOUT_NODE_NAME);
      }
    else if (ELEMENT_IS ("Directory")(strcmp (element_name, ("Directory")) == 0))
      {
        push_node (parser, MENU_LAYOUT_NODE_DIRECTORY);
      }
    else if (ELEMENT_IS ("OnlyUnallocated")(strcmp (element_name, ("OnlyUnallocated")) == 0))
      {
        push_node (parser, MENU_LAYOUT_NODE_ONLY_UNALLOCATED);
      }
    else if (ELEMENT_IS ("NotOnlyUnallocated")(strcmp (element_name, ("NotOnlyUnallocated")) == 0))
      {
        push_node (parser, MENU_LAYOUT_NODE_NOT_ONLY_UNALLOCATED);
      }
    else if (ELEMENT_IS ("Include")(strcmp (element_name, ("Include")) == 0))
      {
        push_node (parser, MENU_LAYOUT_NODE_INCLUDE);
      }
    else if (ELEMENT_IS ("Exclude")(strcmp (element_name, ("Exclude")) == 0))
      {
        push_node (parser, MENU_LAYOUT_NODE_EXCLUDE);
      }
    else if (ELEMENT_IS ("MergeDir")(strcmp (element_name, ("MergeDir")) == 0))
      {
        push_node (parser, MENU_LAYOUT_NODE_MERGE_DIR);
      }
    else if (ELEMENT_IS ("KDELegacyDirs")(strcmp (element_name, ("KDELegacyDirs")) == 0))
      {
        push_node (parser, MENU_LAYOUT_NODE_KDE_LEGACY_DIRS);
      }
    else if (ELEMENT_IS ("Move")(strcmp (element_name, ("Move")) == 0))
      {
        push_node (parser, MENU_LAYOUT_NODE_MOVE);
      }
    else if (ELEMENT_IS ("Deleted")(strcmp (element_name, ("Deleted")) == 0))
      {
        push_node (parser, MENU_LAYOUT_NODE_DELETED);

      }
    else if (ELEMENT_IS ("NotDeleted")(strcmp (element_name, ("NotDeleted")) == 0))
      {
        push_node (parser, MENU_LAYOUT_NODE_NOT_DELETED);
      }
    else if (ELEMENT_IS ("Layout")(strcmp (element_name, ("Layout")) == 0))
      {
        push_node (parser, MENU_LAYOUT_NODE_LAYOUT);
      }
    else
      {
        set_error (error, context,
                   G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_UNKNOWN_ELEMENT,
                   "Element <%s> may not appear below <%s>\n",
                   element_name, "Menu");
      }
  }
1570}

1572static void
1573start_matching_rule_element (MenuParser           *parser,
                           GMarkupParseContext  *context,
                           const char           *element_name,
                           const char          **attribute_names,
                           const char          **attribute_values,
                           GError              **error)
1579{
if (!check_no_attributes (context, element_name,
                          attribute_names, attribute_values,
                          error))
  return;


if (ELEMENT_IS ("Filename")(strcmp (element_name, ("Filename")) == 0))
  {
    push_node (parser, MENU_LAYOUT_NODE_FILENAME);
  }
else if (ELEMENT_IS ("Category")(strcmp (element_name, ("Category")) == 0))
  {
    push_node (parser, MENU_LAYOUT_NODE_CATEGORY);
  }
else if (ELEMENT_IS ("All")(strcmp (element_name, ("All")) == 0))
  {
    push_node (parser, MENU_LAYOUT_NODE_ALL);
  }
else if (ELEMENT_IS ("And")(strcmp (element_name, ("And")) == 0))
  {
    push_node (parser, MENU_LAYOUT_NODE_AND);
  }
else if (ELEMENT_IS ("Or")(strcmp (element_name, ("Or")) == 0))
  {
    push_node (parser, MENU_LAYOUT_NODE_OR);
  }
else if (ELEMENT_IS ("Not")(strcmp (element_name, ("Not")) == 0))
  {
    push_node (parser, MENU_LAYOUT_NODE_NOT);
  }
else
  {
    set_error (error, context,
               G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_UNKNOWN_ELEMENT,
               "Element <%s> may not appear in this context\n",
               element_name);
  }
1617}

1619static void
1620start_move_child_element (MenuParser           *parser,
                        GMarkupParseContext  *context,
                        const char           *element_name,
                        const char          **attribute_names,
                        const char          **attribute_values,
                        GError              **error)
1626{
if (!check_no_attributes (context, element_name,
                          attribute_names, attribute_values,
                          error))
  return;

if (ELEMENT_IS ("Old")(strcmp (element_name, ("Old")) == 0))
  {
    push_node (parser, MENU_LAYOUT_NODE_OLD);
  }
else if (ELEMENT_IS ("New")(strcmp (element_name, ("New")) == 0))
  {
    push_node (parser, MENU_LAYOUT_NODE_NEW);
  }
else
  {
    set_error (error, context,
               G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_UNKNOWN_ELEMENT,
               "Element <%s> may not appear below <%s>\n",
               element_name, "Move");
  }
1647}

1649static void
1650start_layout_child_element (MenuParser           *parser,
                          GMarkupParseContext  *context,
                          const char           *element_name,
                          const char          **attribute_names,
                          const char          **attribute_values,
                          GError              **error)
1656{
if (ELEMENT_IS ("Menuname")(strcmp (element_name, ("Menuname")) == 0))
  {
    const char *show_empty;
    const char *inline_menus;
    const char *inline_limit;
    const char *inline_header;
    const char *inline_alias;

    push_node (parser, MENU_LAYOUT_NODE_MENUNAME);

    locate_attributes (context, element_name,
                       attribute_names, attribute_values,
                       error,
                       "show_empty",    &show_empty,
                       "inline",        &inline_menus,
                       "inline_limit",  &inline_limit,
                       "inline_header", &inline_header,
                       "inline_alias",  &inline_alias,
                       NULL((void*)0));

     menu_layout_node_menuname_set_values (parser->stack_top,
			     show_empty,
			     inline_menus,
			     inline_limit,
			     inline_header,
			     inline_alias);
  }
else if (ELEMENT_IS ("Merge")(strcmp (element_name, ("Merge")) == 0))
  {
      const char *type;

      push_node (parser, MENU_LAYOUT_NODE_MERGE);

      locate_attributes (context, element_name,
                         attribute_names, attribute_values,
                         error,
                         "type", &type,
                         NULL((void*)0));

menu_layout_node_merge_set_type (parser->stack_top, type);
  }
else
  {
    if (!check_no_attributes (context, element_name,
                              attribute_names, attribute_values,
                              error))
      return;

    if (ELEMENT_IS ("Filename")(strcmp (element_name, ("Filename")) == 0))
      {
        push_node (parser, MENU_LAYOUT_NODE_FILENAME);
      }
    else if (ELEMENT_IS ("Separator")(strcmp (element_name, ("Separator")) == 0))
      {
        push_node (parser, MENU_LAYOUT_NODE_SEPARATOR);
      }
    else
      {
        set_error (error, context,
                   G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_UNKNOWN_ELEMENT,
                   "Element <%s> may not appear below <%s>\n",
                   element_name, "Move");
      }
  }
1721}

1723static void
1724start_element_handler (GMarkupParseContext   *context,
                     const char            *element_name,
                     const char           **attribute_names,
                     const char           **attribute_values,
                     gpointer               user_data,
                     GError               **error)
1730{
MenuParser *parser = user_data;

if (ELEMENT_IS ("Menu")(strcmp (element_name, ("Menu")) == 0))
  {
    if (parser->stack_top == parser->root &&
        has_child_of_type (parser->root, MENU_LAYOUT_NODE_MENU))
      {
        set_error (error, context,
                   G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_PARSE,
                   "Multiple root elements in menu file, only one toplevel <Menu> is allowed\n");
        return;
      }

    start_menu_element (parser, context, element_name,
                        attribute_names, attribute_values,
                        error);
  }
else if (parser->stack_top == parser->root)
  {
    set_error (error, context,
               G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_PARSE,
               "Root element in a menu file must be <Menu>, not <%s>\n",
               element_name);
  }
else if (parser->stack_top->type == MENU_LAYOUT_NODE_MENU)
  {
    start_menu_child_element (parser, context, element_name,
                              attribute_names, attribute_values,
                              error);
  }
else if (parser->stack_top->type == MENU_LAYOUT_NODE_INCLUDE ||
         parser->stack_top->type == MENU_LAYOUT_NODE_EXCLUDE ||
         parser->stack_top->type == MENU_LAYOUT_NODE_AND     ||
         parser->stack_top->type == MENU_LAYOUT_NODE_OR      ||
         parser->stack_top->type == MENU_LAYOUT_NODE_NOT)
  {
    start_matching_rule_element (parser, context, element_name,
                                 attribute_names, attribute_values,
                                 error);
  }
else if (parser->stack_top->type == MENU_LAYOUT_NODE_MOVE)
  {
    start_move_child_element (parser, context, element_name,
                              attribute_names, attribute_values,
                              error);
  }
else if (parser->stack_top->type == MENU_LAYOUT_NODE_LAYOUT ||
         parser->stack_top->type == MENU_LAYOUT_NODE_DEFAULT_LAYOUT)
  {
    start_layout_child_element (parser, context, element_name,
                                attribute_names, attribute_values,
                                error);
  }
else
  {
    set_error (error, context,
               G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_UNKNOWN_ELEMENT,
               "Element <%s> may not appear in this context\n",
               element_name);
  }

add_context_to_error (error, context);
1793}

1795/* we want to make sure that the <Layout> or <DefaultLayout> is either empty,
* or contain one <Merge> of type "all", or contain one <Merge> of type "menus"
* and one <Merge> of type "files". If this is not the case, we try to clean up
* things:
*  + if there is at least one <Merge> of type "all", then we only keep the
*    last <Merge> of type "all" and remove all others <Merge>
*  + if there is no <Merge> with type "all", we keep only the last <Merge> of
*    type "menus" and the last <Merge> of type "files". If there's no <Merge>
*    of type "menus" we append one, and then if there's no <Merge> of type
*    "files", we append one. (So menus are before files)
*/
1806static gboolean
1807fixup_layout_node (GMarkupParseContext   *context G_GNUC_UNUSED__attribute__ ((__unused__)),
   MenuParser            *parser G_GNUC_UNUSED__attribute__ ((__unused__)),
   MenuLayoutNode        *node,
   GError              **error G_GNUC_UNUSED__attribute__ ((__unused__)))
1811{
MenuLayoutNode *child;
MenuLayoutNode *last_all;
MenuLayoutNode *last_menus;
MenuLayoutNode *last_files;
int             n_all;
int             n_menus;
int             n_files;

if (!node->children)
6
←
Assuming field 'children' is non-null→
7
←
Taking false branch→
  {
    return TRUE(!(0));
  }

last_all   = NULL((void*)0);
last_menus = NULL((void*)0);
last_files = NULL((void*)0);
n_all   = 0;
n_menus = 0;
n_files = 0;

child = node->children;
while (child7.1
'child' is not equal to NULL
 != NULL((void*)0))
8
←
Loop condition is true.  Entering loop body→
13
←
Assuming 'child' is not equal to NULL→
14
←
Loop condition is true.  Entering loop body→
19
←
Assuming 'child' is equal to NULL→
  {
    switch (child->type)
9
←
Control jumps to 'case MENU_LAYOUT_NODE_MERGE:'  at line 1837→
15
←
Control jumps to 'case MENU_LAYOUT_NODE_MERGE:'  at line 1837→
      {
      case MENU_LAYOUT_NODE_MERGE:
 switch (menu_layout_node_merge_get_type (child))
10
←
Control jumps to 'case MENU_LAYOUT_MERGE_ALL:'  at line 1853→
16
←
Control jumps to 'case MENU_LAYOUT_MERGE_MENUS:'  at line 1843→
   {
   case MENU_LAYOUT_MERGE_NONE:
     break;

   case MENU_LAYOUT_MERGE_MENUS:
     last_menus = child;
     n_menus++;
     break;
17
←
 Execution continues on line 1862→

   case MENU_LAYOUT_MERGE_FILES:
     last_files = child;
     n_files++;
     break;

   case MENU_LAYOUT_MERGE_ALL:
     last_all = child;
     n_all++;
     break;
11
←
 Execution continues on line 1862→

   default:
     g_assert_not_reached ()do { g_assertion_message_expr (((gchar*) 0), "menu-layout.c",
 1859, ((const char*) (__func__)), ((void*)0)); } while (0);
     break;
   }
        break;

 default:
   break;
}

    child = node_next (child);
12
←
 Execution continues on line 1868→
18
←
 Execution continues on line 1868→
  }

if ((n_all19.1
'n_all' is equal to 1
 == 1 && n_menus19.2
'n_menus' is not equal to 0
 == 0 && n_files == 0) ||
    (n_all19.3
'n_all' is not equal to 0
 == 0 && n_menus == 1 && n_files == 1))
  {
    return TRUE(!(0));
  }
else if (n_all19.4
'n_all' is <= 1
 > 1 || n_menus19.5
'n_menus' is <= 1
 > 1 || n_files19.6
'n_files' is <= 1
 > 1 ||
         (n_all19.7
'n_all' is equal to 1
 == 1 && (n_menus19.8
'n_menus' is not equal to 0
 != 0 || n_files != 0)))
  {
    child = node->children;
    while (child19.9
'child' is not equal to NULL
1
'child' is not equal to NULL
 != NULL((void*)0))
20
←
Loop condition is true.  Entering loop body→
26
←
Loop condition is true.  Entering loop body→
{
 MenuLayoutNode *next;

 next = node_next (child);

 switch (child->type)
21
←
Control jumps to 'case MENU_LAYOUT_NODE_MERGE:'  at line 1888→
27
←
Control jumps to 'case MENU_LAYOUT_NODE_MERGE:'  at line 1888→
   {
   case MENU_LAYOUT_NODE_MERGE:
     switch (menu_layout_node_merge_get_type (child))
22
←
Control jumps to 'case MENU_LAYOUT_MERGE_ALL:'  at line 1910→
28
←
Control jumps to 'case MENU_LAYOUT_MERGE_MENUS:'  at line 1894→
{
case MENU_LAYOUT_MERGE_NONE:
  break;

case MENU_LAYOUT_MERGE_MENUS:
  if (n_all28.1
'n_all' is 1
 || last_menus != child)
    {
      menu_verbose ("removing duplicated merge menus element\n");
      menu_layout_node_unlink (child);
29
←
Calling 'menu_layout_node_unlink'→
    }
  break;

case MENU_LAYOUT_MERGE_FILES:
  if (n_all || last_files != child)
    {
      menu_verbose ("removing duplicated merge files element\n");
      menu_layout_node_unlink (child);
    }
  break;

case MENU_LAYOUT_MERGE_ALL:
  if (last_all22.1
'last_all' is equal to 'child'
 != child)
23
←
Taking false branch→
    {
      menu_verbose ("removing duplicated merge all element\n");
      menu_layout_node_unlink (child);
    }
  break;
24
←
 Execution continues on line 1922→

default:
  g_assert_not_reached ()do { g_assertion_message_expr (((gchar*) 0), "menu-layout.c",
 1919, ((const char*) (__func__)), ((void*)0)); } while (0);
  break;
}
     break;
25
←
 Execution continues on line 1928→

     default:
break;
   }

 child = next;
}
  }

if (n_all == 0 && n_menus == 0)
  {
    last_menus = menu_layout_node_new (MENU_LAYOUT_NODE_MERGE);
    menu_layout_node_merge_set_type (last_menus, "menus");
    menu_verbose ("appending missing merge menus element\n");
    menu_layout_node_append_child (node, last_menus);
  }

if (n_all == 0 && n_files == 0)
  {
    last_files = menu_layout_node_new (MENU_LAYOUT_NODE_MERGE);
    menu_layout_node_merge_set_type (last_files, "files");
    menu_verbose ("appending missing merge files element\n");
    menu_layout_node_append_child (node, last_files);
  }

return TRUE(!(0));
1949}

1951/* we want to a) check that we have old-new pairs and b) canonicalize
* such that each <Move> has exactly one old-new pair
*/
1954static gboolean
1955fixup_move_node (GMarkupParseContext   *context,
 MenuParser            *parser G_GNUC_UNUSED__attribute__ ((__unused__)),
 MenuLayoutNode        *node,
 GError              **error)
1959{
MenuLayoutNode *child;
int             n_old;
int             n_new;

n_old = 0;
n_new = 0;

child = node->children;
while (child != NULL((void*)0))
  {
    switch (child->type)
      {
      case MENU_LAYOUT_NODE_OLD:
        if (n_new != n_old)
          {
            set_error (error, context,
                       G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_PARSE,
                       "<Old>/<New> elements not paired properly\n");
            return FALSE(0);
          }

        n_old += 1;

        break;

      case MENU_LAYOUT_NODE_NEW:
        n_new += 1;

        if (n_new != n_old)
          {
            set_error (error, context,
                       G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_PARSE,
                       "<Old>/<New> elements not paired properly\n");
            return FALSE(0);
          }

        break;

      default:
        g_assert_not_reached ()do { g_assertion_message_expr (((gchar*) 0), "menu-layout.c",
 1999, ((const char*) (__func__)), ((void*)0)); } while (0);
        break;
      }

    child = node_next (child);
  }

if (n_new == 0 || n_old == 0)
  {
    set_error (error, context,
               G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_PARSE,
               "<Old>/<New> elements missing under <Move>\n");
    return FALSE(0);
  }

g_assert (n_new == n_old)do { if (n_new == n_old) ; else g_assertion_message_expr (((gchar
*) 0), "menu-layout.c", 2014, ((const char*) (__func__)), "n_new == n_old"
); } while (0);
g_assert ((n_new + n_old) % 2 == 0)do { if ((n_new + n_old) % 2 == 0) ; else g_assertion_message_expr
 (((gchar*) 0), "menu-layout.c", 2015, ((const char*) (__func__
)), "(n_new + n_old) % 2 == 0"); } while (0);

if (n_new > 1)
  {
    MenuLayoutNode *prev;
    MenuLayoutNode *append_after;

    /* Need to split the <Move> into multiple <Move> */

    n_old = 0;
    n_new = 0;
    prev = NULL((void*)0);
    append_after = node;

    child = node->children;
    while (child != NULL((void*)0))
      {
        MenuLayoutNode *next;

        next = node_next (child);

        switch (child->type)
          {
          case MENU_LAYOUT_NODE_OLD:
            n_old += 1;
            break;

          case MENU_LAYOUT_NODE_NEW:
            n_new += 1;
            break;

          default:
            g_assert_not_reached ()do { g_assertion_message_expr (((gchar*) 0), "menu-layout.c",
 2047, ((const char*) (__func__)), ((void*)0)); } while (0);
            break;
          }

        if (n_old == n_new &&
            n_old > 1)
          {
            /* Move the just-completed pair */
            MenuLayoutNode *new_move;

            g_assert (prev != NULL)do { if (prev != ((void*)0)) ; else g_assertion_message_expr (
((gchar*) 0), "menu-layout.c", 2057, ((const char*) (__func__
)), "prev != NULL"); } while (0);

            new_move = menu_layout_node_new (MENU_LAYOUT_NODE_MOVE);
            menu_verbose ("inserting new_move after append_after\n");
            menu_layout_node_insert_after (append_after, new_move);
            append_after = new_move;

            menu_layout_node_steal (prev);
            menu_layout_node_steal (child);

            menu_verbose ("appending prev to new_move\n");
            menu_layout_node_append_child (new_move, prev);
            menu_verbose ("appending child to new_move\n");
            menu_layout_node_append_child (new_move, child);

            menu_verbose ("Created new move element old = %s new = %s\n",
                          menu_layout_node_move_get_old (new_move),
                          menu_layout_node_move_get_new (new_move));

            menu_layout_node_unref (new_move);
            menu_layout_node_unref (prev);
            menu_layout_node_unref (child);

            prev = NULL((void*)0);
          }
        else
          {
            prev = child;
          }

        prev = child;
        child = next;
      }
  }

return TRUE(!(0));
2093}

2095static void
2096end_element_handler (GMarkupParseContext  *context,
                   const char           *element_name,
                   gpointer              user_data,
                   GError              **error)
2100{
MenuParser *parser = user_data;

g_assert (parser->stack_top != NULL)do { if (parser->stack_top != ((void*)0)) ; else g_assertion_message_expr
 (((gchar*) 0), "menu-layout.c", 2103, ((const char*) (__func__
)), "parser->stack_top != NULL"); } while (0);
1
Assuming field 'stack_top' is not equal to null→
2
←
Taking true branch→
3
←
Loop condition is false.  Exiting loop→

switch (parser->stack_top->type)
4
←
Control jumps to 'case MENU_LAYOUT_NODE_LAYOUT:'  at line 2159→
  {
  case MENU_LAYOUT_NODE_APP_DIR:
  case MENU_LAYOUT_NODE_DIRECTORY_DIR:
  case MENU_LAYOUT_NODE_NAME:
  case MENU_LAYOUT_NODE_DIRECTORY:
  case MENU_LAYOUT_NODE_FILENAME:
  case MENU_LAYOUT_NODE_CATEGORY:
  case MENU_LAYOUT_NODE_MERGE_DIR:
  case MENU_LAYOUT_NODE_LEGACY_DIR:
  case MENU_LAYOUT_NODE_OLD:
  case MENU_LAYOUT_NODE_NEW:
  case MENU_LAYOUT_NODE_MENUNAME:
    if (menu_layout_node_get_content (parser->stack_top) == NULL((void*)0))
      {
        set_error (error, context,
                   G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_INVALID_CONTENT,
                   "Element <%s> is required to contain text and was empty\n",
                   element_name);
        goto out;
      }
    break;

  case MENU_LAYOUT_NODE_MENU:
    if (!has_child_of_type (parser->stack_top, MENU_LAYOUT_NODE_NAME))
      {
        set_error (error, context,
                   G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_PARSE,
                   "<Menu> elements are required to contain a <Name> element\n");
        goto out;
      }
    break;

  case MENU_LAYOUT_NODE_ROOT:
  case MENU_LAYOUT_NODE_PASSTHROUGH:
  case MENU_LAYOUT_NODE_DEFAULT_APP_DIRS:
  case MENU_LAYOUT_NODE_DEFAULT_DIRECTORY_DIRS:
  case MENU_LAYOUT_NODE_DEFAULT_MERGE_DIRS:
  case MENU_LAYOUT_NODE_ONLY_UNALLOCATED:
  case MENU_LAYOUT_NODE_NOT_ONLY_UNALLOCATED:
  case MENU_LAYOUT_NODE_INCLUDE:
  case MENU_LAYOUT_NODE_EXCLUDE:
  case MENU_LAYOUT_NODE_ALL:
  case MENU_LAYOUT_NODE_AND:
  case MENU_LAYOUT_NODE_OR:
  case MENU_LAYOUT_NODE_NOT:
  case MENU_LAYOUT_NODE_KDE_LEGACY_DIRS:
  case MENU_LAYOUT_NODE_DELETED:
  case MENU_LAYOUT_NODE_NOT_DELETED:
  case MENU_LAYOUT_NODE_SEPARATOR:
  case MENU_LAYOUT_NODE_MERGE:
  case MENU_LAYOUT_NODE_MERGE_FILE:
    break;

  case MENU_LAYOUT_NODE_LAYOUT:
  case MENU_LAYOUT_NODE_DEFAULT_LAYOUT:
    if (!fixup_layout_node (context, parser, parser->stack_top, error))
5
←
Calling 'fixup_layout_node'→
      goto out;
    break;

  case MENU_LAYOUT_NODE_MOVE:
    if (!fixup_move_node (context, parser, parser->stack_top, error))
      goto out;
    break;
  }

out:
parser->stack_top = parser->stack_top->parent;
2173}

2175static gboolean
2176all_whitespace (const char *text,
              int         text_len)
2178{
const char *p;
const char *end;

p = text;
end = text + text_len;

while (p != end)
  {
    if (!g_ascii_isspace (*p)((g_ascii_table[(guchar) (*p)] & G_ASCII_SPACE) != 0))
      return FALSE(0);

    p = g_utf8_next_char (p)((p) + g_utf8_skip[*(const guchar *)(p)]);
  }

return TRUE(!(0));
2194}

2196static void
2197text_handler (GMarkupParseContext  *context,
            const char           *text,
            gsize                 text_len,
            gpointer              user_data,
            GError              **error)
2202{
MenuParser *parser = user_data;

switch (parser->stack_top->type)
  {
  case MENU_LAYOUT_NODE_APP_DIR:
  case MENU_LAYOUT_NODE_DIRECTORY_DIR:
  case MENU_LAYOUT_NODE_NAME:
  case MENU_LAYOUT_NODE_DIRECTORY:
  case MENU_LAYOUT_NODE_FILENAME:
  case MENU_LAYOUT_NODE_CATEGORY:
  case MENU_LAYOUT_NODE_MERGE_FILE:
  case MENU_LAYOUT_NODE_MERGE_DIR:
  case MENU_LAYOUT_NODE_LEGACY_DIR:
  case MENU_LAYOUT_NODE_OLD:
  case MENU_LAYOUT_NODE_NEW:
  case MENU_LAYOUT_NODE_MENUNAME:
    g_assert (menu_layout_node_get_content (parser->stack_top) == NULL)do { if (menu_layout_node_get_content (parser->stack_top) ==
 ((void*)0)) ; else g_assertion_message_expr (((gchar*) 0), "menu-layout.c"
, 2219, ((const char*) (__func__)), "menu_layout_node_get_content (parser->stack_top) == NULL"
); } while (0);

    menu_layout_node_set_content (parser->stack_top, text);
    break;

  case MENU_LAYOUT_NODE_ROOT:
  case MENU_LAYOUT_NODE_PASSTHROUGH:
  case MENU_LAYOUT_NODE_MENU:
  case MENU_LAYOUT_NODE_DEFAULT_APP_DIRS:
  case MENU_LAYOUT_NODE_DEFAULT_DIRECTORY_DIRS:
  case MENU_LAYOUT_NODE_DEFAULT_MERGE_DIRS:
  case MENU_LAYOUT_NODE_ONLY_UNALLOCATED:
  case MENU_LAYOUT_NODE_NOT_ONLY_UNALLOCATED:
  case MENU_LAYOUT_NODE_INCLUDE:
  case MENU_LAYOUT_NODE_EXCLUDE:
  case MENU_LAYOUT_NODE_ALL:
  case MENU_LAYOUT_NODE_AND:
  case MENU_LAYOUT_NODE_OR:
  case MENU_LAYOUT_NODE_NOT:
  case MENU_LAYOUT_NODE_KDE_LEGACY_DIRS:
  case MENU_LAYOUT_NODE_MOVE:
  case MENU_LAYOUT_NODE_DELETED:
  case MENU_LAYOUT_NODE_NOT_DELETED:
  case MENU_LAYOUT_NODE_LAYOUT:
  case MENU_LAYOUT_NODE_DEFAULT_LAYOUT:
  case MENU_LAYOUT_NODE_SEPARATOR:
  case MENU_LAYOUT_NODE_MERGE:
    if (!all_whitespace (text, text_len))
      {
        set_error (error, context,
                   G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_PARSE,
                   "No text is allowed inside element <%s>",
                   g_markup_parse_context_get_element (context));
      }
    break;
  }

add_context_to_error (error, context);
2257}

2259static void
2260passthrough_handler (GMarkupParseContext  *context,
     const char           *passthrough_text,
     gsize                 text_len G_GNUC_UNUSED__attribute__ ((__unused__)),
     gpointer              user_data,
     GError              **error)
2265{
MenuParser *parser = user_data;
MenuLayoutNode *node;

/* don't push passthrough on the stack, it's not an element */

node = menu_layout_node_new (MENU_LAYOUT_NODE_PASSTHROUGH);
menu_layout_node_set_content (node, passthrough_text);

menu_layout_node_append_child (parser->stack_top, node);
menu_layout_node_unref (node);

add_context_to_error (error, context);
2278}

2280static void
2281menu_parser_init (MenuParser *parser)
2282{
parser->root = menu_layout_node_new (MENU_LAYOUT_NODE_ROOT);
parser->stack_top = parser->root;
2285}

2287static void
2288menu_parser_free (MenuParser *parser)
2289{
if (parser->root)
  menu_layout_node_unref (parser->root);
2292}

2294MenuLayoutNode *
2295menu_layout_load (const char  *filename,
                const char  *non_prefixed_basename,
                GError     **err)
2298{
GMainContext        *main_context;
GMarkupParseContext *context;
MenuLayoutNodeRoot  *root;
MenuLayoutNode      *retval;
MenuParser           parser;
GError              *error;
GString             *str;
char                *text;
char                *s;
gsize                length;

text = NULL((void*)0);
length = 0;
retval = NULL((void*)0);
context = NULL((void*)0);

main_context = g_main_context_get_thread_default ();

menu_verbose ("Loading \"%s\" from disk\n", filename);

if (!g_file_get_contents (filename,
                          &text,
                          &length,
                          err))
  {
    menu_verbose ("Failed to load \"%s\"\n",
                  filename);
    return NULL((void*)0);
  }

g_assert (text != NULL)do { if (text != ((void*)0)) ; else g_assertion_message_expr (
((gchar*) 0), "menu-layout.c", 2329, ((const char*) (__func__
)), "text != NULL"); } while (0);

menu_parser_init (&parser);

root = (MenuLayoutNodeRoot *) parser.root;

root->basedir = g_path_get_dirname (filename);
menu_verbose ("Set basedir \"%s\"\n", root->basedir);

if (non_prefixed_basename)
  s = g_strdup (non_prefixed_basename)g_strdup_inline (non_prefixed_basename);
else
  s = g_path_get_basename (filename);
str = g_string_new (s);
if (g_str_has_suffix (str->str, ".menu")(__builtin_constant_p (".menu")? __extension__ ({ const char *
 const __str = (str->str); const char * const __suffix = (
".menu"); gboolean __result = (0); if (__str == ((void*)0) ||
 __suffix == ((void*)0)) __result = (g_str_has_suffix) (__str
, __suffix); else { const size_t __str_len = strlen (((__str)
 + !(__str))); const size_t __suffix_len = strlen (((__suffix
) + !(__suffix))); if (__str_len >= __suffix_len) __result
 = memcmp (__str + __str_len - __suffix_len, ((__suffix) + !(
__suffix)), __suffix_len) == 0; } __result; }) : (g_str_has_suffix
) (str->str, ".menu") ))
  g_string_truncate (str, str->len - strlen (".menu"))g_string_truncate_inline (str, str->len - strlen (".menu")
);

root->name = str->str;
menu_verbose ("Set menu name \"%s\"\n", root->name);

g_string_free (str, FALSE)(__builtin_constant_p ((0)) ? (((0)) ? (g_string_free) ((str)
, ((0))) : g_string_free_and_steal (str)) : (g_string_free) (
(str), ((0))));
g_free (s);

context = g_markup_parse_context_new (&menu_funcs, 0, &parser, NULL((void*)0));

error = NULL((void*)0);
if (!g_markup_parse_context_parse (context,
                                   text,
                                   length,
                                   &error))
  goto out;

error = NULL((void*)0);
g_markup_parse_context_end_parse (context, &error);

root->main_context = main_context ? g_main_context_ref (main_context) : NULL((void*)0);

out:
if (context)
  g_markup_parse_context_free (context);
g_free (text);

if (error)
  {
    menu_verbose ("Error \"%s\" loading \"%s\"\n",
                  error->message, filename);
    g_propagate_error (err, error);
  }
else if (has_child_of_type (parser.root, MENU_LAYOUT_NODE_MENU))
  {
    menu_verbose ("File loaded OK\n");
    retval = parser.root;
    parser.root = NULL((void*)0);
  }
else
  {
    menu_verbose ("Did not have a root element in file\n");
    g_set_error (err, G_MARKUP_ERRORg_markup_error_quark (), G_MARKUP_ERROR_PARSE,
                 "Menu file %s did not contain a root <Menu> element",
                 filename);
  }

menu_parser_free (&parser);

return retval;
2394}