From 28c6468405f983a01dc8b722f230e3fd7c20465f Mon Sep 17 00:00:00 2001 From: Dan Nicholson Date: Fri, 16 Nov 2012 08:45:53 -0800 Subject: [PATCH] Pass around flags types instead of function pointers This makes the code uglier in the short term, but prepares for using merged lists of Cflags and Libs in one go. --- pkg.c | 126 +++++++++++++++++++++------------------------------------- 1 file changed, 46 insertions(+), 80 deletions(-) diff --git a/pkg.c b/pkg.c index 3891107..e9cfe64 100644 --- a/pkg.c +++ b/pkg.c @@ -496,56 +496,6 @@ string_list_to_string (GList *list) return retval; } -typedef GList *(* GetListFunc) (Package *pkg); - -static GList * -get_l_libs (Package *pkg) -{ - return pkg->l_libs; -} - -static GList * -get_L_libs (Package *pkg) -{ - return pkg->L_libs; -} - -static GList * -get_other_libs (Package *pkg) -{ - return pkg->other_libs; -} - -static GList * -get_I_cflags (Package *pkg) -{ - return pkg->I_cflags; -} - -static GList * -get_other_cflags (Package *pkg) -{ - return pkg->other_cflags; -} - -static GList * -get_conflicts (Package *pkg) -{ - return pkg->conflicts; -} - -static GList * -get_requires (Package *pkg) -{ - return pkg->requires; -} - -static GList * -get_requires_private (Package *pkg) -{ - return pkg->requires_private; -} - static int pathposcmp (gconstpointer a, gconstpointer b) { @@ -586,17 +536,11 @@ packages_sort_by_path_position (GList *list) } static void -recursive_fill_list (Package *pkg, GetListFunc func, GList **listp) +recursive_fill_list (Package *pkg, gboolean include_private, GList **listp) { GList *tmp; static GList *chain = NULL; - /* - * This function should only be called to resolve Requires or - * Requires.private. - */ - g_assert (func == get_requires || func == get_requires_private); - /* * If the package is one of the parents, we can skip it. This allows * circular requires loops to be broken. @@ -613,9 +557,9 @@ recursive_fill_list (Package *pkg, GetListFunc func, GList **listp) /* Start from the end of the required package list to maintain order since * the recursive list is built by prepending. */ - for (tmp = g_list_last ((*func) (pkg)); tmp != NULL; - tmp = g_list_previous (tmp)) - recursive_fill_list (tmp->data, func, listp); + tmp = include_private ? pkg->requires_private : pkg->requires; + for (tmp = g_list_last (tmp); tmp != NULL; tmp = g_list_previous (tmp)) + recursive_fill_list (tmp->data, include_private, listp); *listp = g_list_prepend (*listp, pkg); @@ -625,17 +569,42 @@ recursive_fill_list (Package *pkg, GetListFunc func, GList **listp) /* merge the flags from the individual packages */ static GList * -merge_flag_lists (GList *packages, GetListFunc func) +merge_flag_lists (GList *packages, FlagType type) { - GList *pkg; - GList *flags; GList *last = NULL; GList *merged = NULL; /* keep track of the last element to avoid traversing the whole list */ - for (pkg = packages; pkg != NULL; pkg = pkg->next) + for (; packages != NULL; packages = g_list_next (packages)) { - for (flags = (*func) (pkg->data); flags != NULL; flags = flags->next) + Package *pkg = packages->data; + GList *flags; + + /* fetch the appropriate flags */ + switch (type) + { + case CFLAGS_OTHER: + flags = pkg->other_cflags; + break; + case CFLAGS_I: + flags = pkg->I_cflags; + break; + case LIBS_OTHER: + flags = pkg->other_libs; + break; + case LIBS_L: + flags = pkg->L_libs; + break; + case LIBS_l: + flags = pkg->l_libs; + break; + default: + g_assert_not_reached (); + break; + } + + /* manually copy the elements so we can keep track of the end */ + for (; flags != NULL; flags = g_list_next (flags)) { if (last == NULL) { @@ -688,7 +657,7 @@ package_list_strip_duplicates (GList *packages) } static GList * -fill_list (GList *packages, GetListFunc func, +fill_list (GList *packages, FlagType type, gboolean in_path_order, gboolean include_private) { GList *tmp; @@ -698,9 +667,7 @@ fill_list (GList *packages, GetListFunc func, /* Start from the end of the requested package list to maintain order since * the recursive list is built by prepending. */ for (tmp = g_list_last (packages); tmp != NULL; tmp = g_list_previous (tmp)) - recursive_fill_list (tmp->data, - include_private ? get_requires_private : get_requires, - &expanded); + recursive_fill_list (tmp->data, include_private, &expanded); /* Remove duplicate packages from the recursive list. This should provide a * serialized package list where all interdependencies are resolved @@ -716,7 +683,7 @@ fill_list (GList *packages, GetListFunc func, spew_package_list (" sorted", expanded); } - flags = merge_flag_lists (expanded, func); + flags = merge_flag_lists (expanded, type); g_list_free (expanded); return flags; @@ -818,8 +785,8 @@ verify_package (Package *pkg) /* Make sure we didn't drag in any conflicts via Requires * (inefficient algorithm, who cares) */ - recursive_fill_list (pkg, get_requires_private, &requires); - conflicts = get_conflicts (pkg); + recursive_fill_list (pkg, TRUE, &requires); + conflicts = pkg->conflicts; requires_iter = requires; while (requires_iter != NULL) @@ -994,13 +961,13 @@ verify_package (Package *pkg) * The former is done for -I/-L flags, and the latter for all others. */ static char * -get_multi_merged (GList *pkgs, GetListFunc func, gboolean in_path_order, +get_multi_merged (GList *pkgs, FlagType type, gboolean in_path_order, gboolean include_private) { GList *list; char *retval; - list = fill_list (pkgs, func, in_path_order, include_private); + list = fill_list (pkgs, type, in_path_order, include_private); list = string_list_strip_duplicates (list, in_path_order); retval = string_list_to_string (list); g_list_free (list); @@ -1019,36 +986,35 @@ packages_get_flags (GList *pkgs, FlagType flags) /* sort packages in path order for -L/-I, dependency order otherwise */ if (flags & CFLAGS_OTHER) { - cur = get_multi_merged (pkgs, get_other_cflags, FALSE, TRUE); + cur = get_multi_merged (pkgs, CFLAGS_OTHER, FALSE, TRUE); debug_spew ("adding CFLAGS_OTHER string \"%s\"\n", cur); g_string_append (str, cur); g_free (cur); } if (flags & CFLAGS_I) { - cur = get_multi_merged (pkgs, get_I_cflags, TRUE, TRUE); + cur = get_multi_merged (pkgs, CFLAGS_I, TRUE, TRUE); debug_spew ("adding CFLAGS_I string \"%s\"\n", cur); g_string_append (str, cur); g_free (cur); } if (flags & LIBS_OTHER) { - cur = get_multi_merged (pkgs, get_other_libs, FALSE, - !ignore_private_libs); + cur = get_multi_merged (pkgs, LIBS_OTHER, FALSE, !ignore_private_libs); debug_spew ("adding LIBS_OTHER string \"%s\"\n", cur); g_string_append (str, cur); g_free (cur); } if (flags & LIBS_L) { - cur = get_multi_merged (pkgs, get_L_libs, TRUE, !ignore_private_libs); + cur = get_multi_merged (pkgs, LIBS_L, TRUE, !ignore_private_libs); debug_spew ("adding LIBS_L string \"%s\"\n", cur); g_string_append (str, cur); g_free (cur); } if (flags & LIBS_l) { - cur = get_multi_merged (pkgs, get_l_libs, FALSE, !ignore_private_libs); + cur = get_multi_merged (pkgs, LIBS_l, FALSE, !ignore_private_libs); debug_spew ("adding LIBS_l string \"%s\"\n", cur); g_string_append (str, cur); g_free (cur);