static gboolean
gwy_app_recent_file_list_filter(GtkTreeModel *model,
GtkTreeIter *iter,
gpointer data)
{
Controls *controls = (Controls*)data;
GwyRecentFile *rf;
if (!controls->pattern)
return TRUE;
gtk_tree_model_get(model, iter, 0, &rf, -1);
/* This can happen when the row has been just created and rf is not set
* yet. */
if (!rf)
return FALSE;
if (controls->casesens)
return g_pattern_match_string(controls->pattern, rf->file_utf8);
else {
if (!rf->file_utf8_lc)
rf->file_utf8_lc = g_utf8_strdown(rf->file_utf8, -1);
return g_pattern_match_string(controls->pattern, rf->file_utf8_lc);
}
}
static gboolean
fuzzy_check_content_type (struct fuzzy_rule *rule, GMimeContentType *type)
{
struct fuzzy_mime_type *ft;
GList *cur;
cur = rule->mime_types;
while (cur) {
ft = cur->data;
if (ft->type) {
if (g_pattern_match_string (ft->type, type->type)) {
if (ft->subtype) {
if (g_pattern_match_string (ft->subtype, type->subtype)) {
return TRUE;
}
}
else {
return TRUE;
}
}
}
cur = g_list_next (cur);
}
return FALSE;
}
void
mud_connections_icon_fileset_cb(GtkFileChooserButton *chooser,
MudConnections *conn)
{
const gchar *file;
gchar *current_folder =
gtk_file_chooser_get_current_folder(
GTK_FILE_CHOOSER(conn->priv->icon_dialog_chooser));
GDir *dir = g_dir_open(current_folder ,0, NULL);
GPatternSpec *xpm_pattern = g_pattern_spec_new("*.xpm");
GPatternSpec *svg_pattern = g_pattern_spec_new("*.svg");
GPatternSpec *bmp_pattern = g_pattern_spec_new("*.bmp");
GPatternSpec *png_pattern = g_pattern_spec_new("*.png");
gtk_list_store_clear(
GTK_LIST_STORE(conn->priv->icon_dialog_view_model));
while( (file = g_dir_read_name(dir) ) != NULL)
if( g_pattern_match_string(xpm_pattern, file) ||
g_pattern_match_string(svg_pattern, file) ||
g_pattern_match_string(bmp_pattern, file) ||
g_pattern_match_string(png_pattern, file))
{
gchar *full_path = g_strconcat(current_folder,
G_DIR_SEPARATOR_S,
file, NULL);
GdkPixbuf *icon = gdk_pixbuf_new_from_file_at_size(
full_path, 48, 48, NULL);
GtkTreeIter iter;
if(icon)
{
gtk_list_store_append(
GTK_LIST_STORE(conn->priv->icon_dialog_view_model),
&iter);
gtk_list_store_set(
GTK_LIST_STORE(conn->priv->icon_dialog_view_model),
&iter,
MODEL_COLUMN_STRING, file,
MODEL_COLUMN_PIXBUF, icon,
-1);
g_object_unref(icon);
}
g_free(full_path);
}
g_free(current_folder);
g_dir_close(dir);
g_pattern_spec_free(xpm_pattern);
g_pattern_spec_free(svg_pattern);
g_pattern_spec_free(bmp_pattern);
g_pattern_spec_free(png_pattern);
}
/*! \brief Find all text objects that match a pattern
*
* \param pages the list of pages to search
* \param text the pattern to match
* \return a list of objects that match the given pattern
*/
static GSList*
find_objects_using_pattern (GSList *pages, const char *text)
{
GSList *object_list = NULL;
GSList *page_iter = pages;
GPatternSpec *pattern;
g_return_val_if_fail (text != NULL, NULL);
pattern = g_pattern_spec_new (text);
while (page_iter != NULL) {
const GList *object_iter;
PAGE *page = (PAGE*) page_iter->data;
page_iter = g_slist_next (page_iter);
if (page == NULL) {
g_warning ("NULL page encountered");
continue;
}
object_iter = s_page_objects (page);
while (object_iter != NULL) {
OBJECT *object = (OBJECT*) object_iter->data;
const char *str;
object_iter = g_list_next (object_iter);
if (object == NULL) {
g_warning ("NULL object encountered");
continue;
}
if (object->type != OBJ_TEXT) {
continue;
}
if (!(o_is_visible (page->toplevel, object) || page->toplevel->show_hidden_text)) {
continue;
}
str = geda_text_object_get_string (object);
if (str == NULL) {
g_warning ("NULL string encountered");
continue;
}
if (g_pattern_match_string (pattern, str)) {
object_list = g_slist_prepend (object_list, object);
}
}
}
g_pattern_spec_free (pattern);
return g_slist_reverse (object_list);
}
static void
_handle_file_created(WildcardSourceDriver *self, const DirectoryMonitorEvent *event)
{
if (g_pattern_match_string(self->compiled_pattern, event->name))
{
WildcardFileReader *reader = g_hash_table_lookup(self->file_readers, event->full_path);
if (!reader)
{
_create_file_reader(self, event->full_path);
msg_debug("Wildcard: file created", evt_tag_str("filename", event->full_path));
}
else
{
if (wildcard_file_reader_is_deleted(reader))
{
msg_info("File is deleted, new file create with same name. "
"While old file is reading, skip the new one",
evt_tag_str("filename", event->full_path));
pending_file_list_add(self->waiting_list, event->full_path);
}
else if (!log_pipe_init(&reader->super.super))
{
msg_error("Can not re-initialize reader for file",
evt_tag_str("filename", event->full_path));
}
else
{
msg_debug("Wildcard: file reader reinitialized", evt_tag_str("filename", event->full_path));
}
}
}
}
gchar *
value_pairs_transform_set_apply(ValuePairsTransformSet *vpts, gchar *key)
{
if (g_pattern_match_string(vpts->pattern, key))
{
GList *l;
SBGString *sb;
gchar *new_key;
sb = sb_gstring_acquire ();
g_string_assign(sb_gstring_string(sb), key);
l = vpts->transforms;
while (l)
{
value_pairs_transform_apply((ValuePairsTransform *)l->data, sb);
l = l->next;
}
new_key = sb_gstring_string(sb)->str;
g_string_steal(sb_gstring_string(sb));
sb_gstring_release (sb);
return new_key;
}
return g_strdup(key);
}
void
search_foreach(playlist_t * pl, GPatternSpec * pattern, GtkTreeIter * list_iter, int album_node) {
char text[MAXLEN];
char * tmp = NULL;
playlist_data_t * pldata;
gtk_tree_model_get(GTK_TREE_MODEL(pl->store), list_iter, PL_COL_DATA, &pldata, -1);
if (album_node) {
snprintf(text, MAXLEN-1, "%s: %s", pldata->artist, pldata->album);
} else {
playlist_data_get_display_name(text, pldata);
}
if (casesens) {
tmp = strdup(text);
} else {
tmp = g_utf8_strup(text, -1);
}
if (g_pattern_match_string(pattern, tmp)) {
GtkTreeIter iter;
GtkTreePath * path;
path = gtk_tree_model_get_path(GTK_TREE_MODEL(pl->store), list_iter);
gtk_list_store_append(search_store, &iter);
gtk_list_store_set(search_store, &iter, 0, text,
1, (gpointer)path, 2, pl->name, 3, (gpointer)pl, -1);
}
g_free(tmp);
}
GList *
nautilus_directory_match_pattern (NautilusDirectory *directory, const char *pattern)
{
GList *files, *l, *ret;
GPatternSpec *spec;
ret = NULL;
spec = g_pattern_spec_new (pattern);
files = nautilus_directory_get_file_list (directory);
for (l = files; l; l = l->next) {
NautilusFile *file;
char *name;
file = NAUTILUS_FILE (l->data);
name = nautilus_file_get_display_name (file);
if (g_pattern_match_string (spec, name)) {
ret = g_list_prepend(ret, nautilus_file_ref (file));
}
g_free (name);
}
g_pattern_spec_free (spec);
nautilus_file_list_free (files);
return ret;
}
static GList *
games_file_list_new_internal (const gchar * glob, va_list path)
{
GPatternSpec *filespec = g_pattern_spec_new (glob);
gchar *pathelement;
GList *list = NULL;
GDir *dir;
const gchar *filename;
gchar *fullname;
while ((pathelement = va_arg (path, gchar *)) != NULL) {
dir = g_dir_open (pathelement, 0, NULL);
if (dir != NULL) {
while ((filename = g_dir_read_name (dir)) != NULL) {
if (g_pattern_match_string (filespec, filename)) {
fullname = g_build_filename (pathelement, filename, NULL);
if (g_file_test (fullname, G_FILE_TEST_IS_REGULAR)) {
list = g_list_append (list, fullname);
} else
g_free (fullname);
}
}
g_dir_close (dir);
}
}
g_pattern_spec_free (filespec);
return list;
}
static gboolean filter_tag(tagEntry *entry, GPatternSpec *name, gboolean declaration, gboolean case_sensitive)
{
gboolean filter = TRUE;
gchar *entry_name;
if (!EMPTY(entry->kind))
{
gboolean is_prototype;
is_prototype = g_strcmp0(entry->kind, "prototype") == 0;
filter = (declaration && !is_prototype) || (!declaration && is_prototype);
if (filter)
return TRUE;
}
if (case_sensitive)
entry_name = g_strdup(entry->name);
else
entry_name = g_utf8_strdown(entry->name, -1);
filter = !g_pattern_match_string(name, entry_name);
g_free(entry_name);
return filter;
}
/*
* Return policy for given context based on the otr_policy /setting
*/
static OtrlPolicy ops_policy (void *opdata, ConnContext *context)
{
struct co_info *coi = context->app_data;
char *server = strchr (context->accountname, '@') + 1;
OtrlPolicy op = IO_DEFAULT_OTR_POLICY;
GSList *pl;
char fullname[1024];
g_snprintf (fullname, sizeof(fullname), "%s@%s", context->username, server);
/* loop through otr_policy */
if (plistunknown)
{
pl = plistunknown;
do
{
struct plistentry *ple = pl->data;
if (g_pattern_match_string (ple->namepat, fullname))
op = ple->policy;
} while ((pl = g_slist_next (pl)));
}
if (plistknown && context->fingerprint_root.next)
{
pl = plistknown;
/* loop through otr_policy_known */
do
{
struct plistentry *ple = pl->data;
if (g_pattern_match_string (ple->namepat, fullname))
op = ple->policy;
} while ((pl = g_slist_next (pl)));
}
if (coi && coi->finished && (op == OTRL_POLICY_OPPORTUNISTIC || op == OTRL_POLICY_ALWAYS))
op = OTRL_POLICY_MANUAL | OTRL_POLICY_WHITESPACE_START_AKE;
return op;
}
gboolean patterns_match(GSList *patterns, const gchar *str)
{
GSList *elem;
foreach_slist (elem, patterns)
{
GPatternSpec *pattern = elem->data;
if (g_pattern_match_string(pattern, str))
return TRUE;
}
gboolean patterns_match(GSList *patterns, const gchar *str)
{
GSList *elem;
for (elem = patterns; elem != NULL; elem = g_slist_next(elem))
{
GPatternSpec *pattern = elem->data;
if (g_pattern_match_string(pattern, str))
return TRUE;
}
return FALSE;
}
static void find_file_recursive(GtkTreeIter *iter, gboolean case_sensitive, gboolean full_path, GPatternSpec *pattern)
{
GtkTreeModel *model = GTK_TREE_MODEL(s_file_store);
GtkTreeIter child;
gboolean iterate;
iterate = gtk_tree_model_iter_children(model, &child, iter);
if (iterate)
{
while (iterate)
{
find_file_recursive(&child, case_sensitive, full_path, pattern);
iterate = gtk_tree_model_iter_next(model, &child);
}
}
else
{
gchar *utf8_name;
if (iter == NULL)
return;
if (full_path)
{
gchar *utf8_path, *utf8_base_path;
utf8_path = build_path(iter);
utf8_base_path = get_project_base_path();
utf8_name = get_relative_path(utf8_base_path, utf8_path);
g_free(utf8_path);
g_free(utf8_base_path);
}
else
gtk_tree_model_get(GTK_TREE_MODEL(model), iter, FILEVIEW_COLUMN_NAME, &utf8_name, -1);
if (!case_sensitive)
SETPTR(utf8_name, g_utf8_strdown(utf8_name, -1));
if (g_pattern_match_string(pattern, utf8_name))
{
gchar *utf8_base_path = get_project_base_path();
gchar *utf8_path, *rel_path;
utf8_path = build_path(iter);
rel_path = get_relative_path(utf8_base_path, utf8_path);
msgwin_msg_add(COLOR_BLACK, -1, NULL, "%s", rel_path ? rel_path : utf8_path);
g_free(utf8_path);
g_free(rel_path);
g_free(utf8_base_path);
}
g_free(utf8_name);
}
}
static gboolean to_ignore(const char *filename, GPatternSpec **patterns)
{
int i;
if(patterns==NULL) {
return FALSE;
}
for(i=0; patterns[i]!=NULL; i++) {
if(g_pattern_match_string(patterns[i], filename))
return TRUE;
}
return FALSE;
}
/*
* gst_validate_runner_get_reporting_level_for_name:
*
* Returns: the #GstValidateReportingDetails that will be applied for a given name.
* If no pattern was set for such a name, this function will return
* #GST_VALIDATE_SHOW_UNKNOWN, and reporting for that name will
* default to the global reporting level.
*/
GstValidateReportingDetails
gst_validate_runner_get_reporting_level_for_name (GstValidateRunner * runner,
const gchar * name)
{
GList *tmp;
for (tmp = runner->priv->report_pattern_levels; tmp; tmp = tmp->next) {
PatternLevel *pattern_level = (PatternLevel *) tmp->data;
if (g_pattern_match_string (pattern_level->pattern, name))
return pattern_level->level;
}
return GST_VALIDATE_SHOW_UNKNOWN;
}
gboolean
g_pattern_match_simple (const gchar *pattern,
const gchar *string)
{
GPatternSpec *pspec;
gboolean ergo;
g_return_val_if_fail (pattern != NULL, FALSE);
g_return_val_if_fail (string != NULL, FALSE);
pspec = g_pattern_spec_new (pattern);
ergo = g_pattern_match_string (pspec, string);
g_pattern_spec_free (pspec);
return ergo;
}
static gboolean match(TMTag *tag, const gchar *name, gboolean declaration, gboolean case_sensitive,
MatchType match_type, GPatternSpec *pspec, gchar *utf8_path)
{
const gint forward_types = tm_tag_prototype_t | tm_tag_externvar_t;
gboolean matches = FALSE;
gint type;
type = declaration ? forward_types : tm_tag_max_t - forward_types;
matches = tag->type & type;
if (matches)
{
gchar *name_case;
if (case_sensitive)
name_case = g_strdup(tag->name);
else
name_case = g_utf8_strdown(tag->name, -1);
switch (match_type)
{
case MATCH_FULL:
matches = g_strcmp0(name_case, name) == 0;
break;
case MATCH_PATTERN:
matches = g_pattern_match_string(pspec, name_case);
break;
case MATCH_PREFIX:
matches = g_str_has_prefix(name_case, name);
break;
}
g_free(name_case);
}
if (matches && utf8_path)
{
gchar *utf8_file_name = utils_get_utf8_from_locale(tag->file->file_name);
gchar *relpath;
relpath = get_relative_path(utf8_path, utf8_file_name);
matches = relpath != NULL;
g_free(relpath);
g_free(utf8_file_name);
}
return matches;
}
/* Override vanilla g_log() to take $Msg_filter into account.
* Cannot use #GLogFunc:s because mafw-log may (and should) be active. */
void g_log(const gchar *domain, GLogLevelFlags level, const gchar *fmt, ...)
{
guint i;
va_list args;
/* Change the level of the message to G_LOG_LEVEL_INFO if it matches
* any of $Msg_filters. It only makes sense if the level is above. */
if (Msg_filters && (level & (G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_WARNING
| G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR))) {
for (i = 0; i < Msg_filters->len; i++)
if (g_pattern_match_string(Msg_filters->pdata[i], fmt)){
level &= ~G_LOG_LEVEL_MASK;
level |= G_LOG_LEVEL_INFO;
break;
}
}
va_start(args, fmt);
g_logv(domain, level, fmt, args);
va_end(args);
}
static void engine_scan_dir(gchar * dir)
{
GDir * d;
d = g_dir_open(dir,0,NULL);
if (d)
{
gchar * n;
GPatternSpec * ps;
ps = g_pattern_spec_new("lib*.so");
while ((n = (gchar *) g_dir_read_name(d)))
{
if (g_pattern_match_string(ps,n))
{
gchar * dln = g_strjoin("/",dir,n,NULL);
append_engine(dln);
}
}
g_pattern_spec_free(ps);
g_dir_close(d);
}
}
static char *
find_file_with_pattern (const char *dir, const char *pattern)
{
GDir *filedir;
char *found_filename;
const char *filename;
GPatternSpec *pat;
filedir = g_dir_open (dir, 0, NULL);
if (filedir == NULL)
return NULL;
pat = g_pattern_spec_new (pattern);
if (pat == NULL)
{
g_dir_close (filedir);
return NULL;
}
found_filename = NULL;
while ((filename = g_dir_read_name (filedir)))
{
if (g_pattern_match_string (pat, filename))
{
char *tmp = g_build_filename (dir, filename, NULL);
if (is_owned_by_user_and_socket (tmp))
found_filename = g_strdup (filename);
g_free (tmp);
}
if (found_filename != NULL)
break;
}
g_pattern_spec_free (pat);
g_dir_close (filedir);
return found_filename;
}
GList* get_files_by_pattern(const gchar* dirpath, FcitxSubConfigPattern* pattern, int index)
{
GList* result = NULL;
DIR* dir = opendir(dirpath);
if (!dir)
return result;
gchar* filter = pattern->patternlist[index];
struct dirent* drt;
GPatternSpec * patternspec = g_pattern_spec_new(filter);
while ((drt = readdir(dir)) != NULL) {
if (strcmp(drt->d_name , ".") == 0 || strcmp(drt->d_name, "..") == 0)
continue;
if (!g_pattern_match_string(patternspec, drt->d_name))
continue;
if (pattern->patternlist[index + 1] == 0) {
char *path;
asprintf(&path, "%s/%s", dirpath, drt->d_name);
struct stat statbuf;
if (stat(path, &statbuf) == 0) {
result = g_list_append(result, realpath(path, NULL));
}
free(path);
} else {
char *path;
asprintf(&path, "%s/%s", dirpath, drt->d_name);
GList* r = get_files_by_pattern(path, pattern, index + 1);
result = g_list_concat(result, r);
free(path);
}
}
closedir(dir);
g_pattern_spec_free(patternspec);
return result;
}
Vector<String> listDirectory(const String& path, const String& filter)
{
Vector<String> entries;
GUniquePtr<gchar> filename = unescapedFilename(path);
if (!filename)
return entries;
GUniquePtr<GDir> dir(g_dir_open(filename.get(), 0, nullptr));
if (!dir)
return entries;
GUniquePtr<GPatternSpec> pspec(g_pattern_spec_new((filter.utf8()).data()));
while (const char* name = g_dir_read_name(dir.get())) {
if (!g_pattern_match_string(pspec.get(), name))
continue;
GUniquePtr<gchar> entry(g_build_filename(filename.get(), name, nullptr));
entries.append(filenameToString(entry.get()));
}
return entries;
}
/**
* file_plugin_proxy_detect:
* @filename: File information.
* @only_name: Whether only name should be used for detection (otherwise
* trying to open the file is allowed). Note this parameter is
* formal, as the proxy always decides only on filename basis.
* @name: Plug-in name (i.e. file-detection function) to run.
*
* The plug-in proxy itself. Emulates filetype detection based on file
* name glob given by the plug-in during registration.
*
* Returns: The score (as defined in gwyddion filetype module interface).
**/
static gint
file_plugin_proxy_detect(const GwyFileDetectInfo *fileinfo,
G_GNUC_UNUSED gboolean only_name,
const gchar *name)
{
FilePluginInfo *info;
gint i, max;
gwy_debug("called as %s with file `%s'", name, fileinfo->name);
if (!(info = file_find_plugin(name, GWY_FILE_OPERATION_MASK)))
return 0;
max = G_MININT;
for (i = 0; info->pattern[i]; i++) {
if (info->specificity[i] > max
&& g_pattern_match_string(info->pattern[i], fileinfo->name))
max = info->specificity[i];
}
if (max == G_MININT)
return 0;
return CLAMP(max, 1, 40);
}
/**
* gtk_accel_map_foreach:
* @data: (allow-none): data to be passed into @foreach_func
* @foreach_func: (scope call): function to be executed for each accel
* map entry which is not filtered out
*
* Loops over the entries in the accelerator map whose accel path
* doesn’t match any of the filters added with gtk_accel_map_add_filter(),
* and execute @foreach_func on each. The signature of @foreach_func is
* that of #GtkAccelMapForeach, the @changed parameter indicates whether
* this accelerator was changed during runtime (thus, would need
* saving during an accelerator map dump).
*/
void
gtk_accel_map_foreach (gpointer data,
GtkAccelMapForeach foreach_func)
{
GSList *entries, *slist, *node;
g_return_if_fail (foreach_func != NULL);
entries = g_hash_table_slist_values (accel_entry_ht);
for (slist = entries; slist; slist = slist->next)
{
AccelEntry *entry = slist->data;
gboolean changed = entry->accel_key != entry->std_accel_key || entry->accel_mods != entry->std_accel_mods;
for (node = accel_filters; node; node = node->next)
if (g_pattern_match_string (node->data, entry->accel_path))
goto skip_accel;
foreach_func (data, entry->accel_path, entry->accel_key, entry->accel_mods, changed);
skip_accel:
/* noop */;
}
g_slist_free (entries);
}
static void swap_clean (void)
{
const gchar *swap_dir = gegl_swap_dir ();
GDir *dir;
if (! swap_dir)
return;
dir = g_dir_open (gegl_swap_dir (), 0, NULL);
if (dir != NULL)
{
GPatternSpec *pattern = g_pattern_spec_new ("*");
const gchar *name;
while ((name = g_dir_read_name (dir)) != NULL)
{
if (g_pattern_match_string (pattern, name))
{
gint readpid = atoi (name);
if (!pid_is_running (readpid))
{
gchar *fname = g_build_filename (gegl_swap_dir (),
name,
NULL);
g_unlink (fname);
g_free (fname);
}
}
}
g_pattern_spec_free (pattern);
g_dir_close (dir);
}
}
static gboolean try_swap_header_source(gchar *file_name, gboolean is_header, GSList *file_list, GSList *header_patterns, GSList *source_patterns)
{
gchar *name_pattern;
gchar *base_name = NULL;
GSList *elem;
GPatternSpec *pattern;
gboolean found = FALSE;
name_pattern = g_path_get_basename(file_name);
setptr(name_pattern, utils_remove_ext_from_filename(name_pattern));
setptr(name_pattern, g_strconcat(name_pattern, ".*", NULL));
pattern = g_pattern_spec_new(name_pattern);
g_free(name_pattern);
for (elem = file_list; elem != NULL; elem = g_slist_next(elem))
{
gchar *full_name = elem->data;
base_name = g_path_get_basename(full_name);
if (g_pattern_match_string(pattern, base_name) &&
gprj_project_is_in_project(full_name))
{
if ((is_header && patterns_match(source_patterns, base_name)) ||
(!is_header && patterns_match(header_patterns, base_name)))
{
open_file(full_name);
found = TRUE;
break;
}
}
}
g_free(base_name);
g_pattern_spec_free(pattern);
return found;
}
/*! \brief Find all symbols matching a pattern.
*
* \par Function Description
* Searches the library, returning all symbols whose
* names match \a pattern.
*
* Two search modes are available: \b CLIB_EXACT, where \a pattern is
* compared to the symbol name using strcmp(), and \b CLIB_GLOB,
* where \a pattern is assumed to be a glob pattern (see the GLib
* documentation for details of the glob syntax applicable).
*
* \warning The #CLibSymbol instances in the \b GList returned belong
* to the component library, and should be considered constants; they
* should not be manipulated or free()'d. On the other hand, the \b
* GList returned must be freed with \b g_list_free() when no longer
* needed. Note that the values returned will be invalidated by a
* call to s_clib_free() or s_clib_refresh().
*
* \param pattern The pattern to match against.
* \param mode The search mode to use.
* \return A \b GList of matching #CLibSymbol structures.
*/
GList *s_clib_search (const gchar *pattern, const CLibSearchMode mode)
{
GList *sourcelist;
GList *symlist;
GList *result = NULL;
CLibSource *source;
CLibSymbol *symbol;
GPatternSpec *globpattern = NULL;
gchar *key;
gchar keytype;
if (pattern == NULL) return NULL;
/* Use different cache keys depending on what sort of search is being done */
switch (mode)
{
case CLIB_GLOB:
keytype = 'g';
break;
case CLIB_EXACT:
keytype = 's';
break;
default:
g_critical ("s_clib_search: Bad search mode %1$i\n", mode);
return NULL;
}
key = g_strdup_printf("%c%s", keytype, pattern);
/* Check to see if the query is already in the cache */
result = (GList *) g_hash_table_lookup (clib_search_cache, key);
if (result != NULL) {
g_free (key);
return g_list_copy (result);
}
if (mode == CLIB_GLOB) {
globpattern = g_pattern_spec_new(pattern);
}
for (sourcelist = clib_sources;
sourcelist != NULL;
sourcelist = g_list_next(sourcelist)) {
source = (CLibSource *) sourcelist->data;
for (symlist = source->symbols;
symlist != NULL;
symlist = g_list_next(symlist)) {
symbol = (CLibSymbol *) symlist->data;
switch (mode)
{
case CLIB_EXACT:
if (strcmp (pattern, symbol->name) == 0) {
result = g_list_prepend (result, symbol);
}
break;
case CLIB_GLOB:
if (g_pattern_match_string (globpattern, symbol->name)) {
result = g_list_prepend (result, symbol);
}
break;
}
}
}
result = g_list_reverse (result);
if (globpattern != NULL) {
g_pattern_spec_free (globpattern);
}
g_hash_table_insert (clib_search_cache, key, g_list_copy (result));
/* __don't__ free key here, it's stored by the hash table! */
return result;
}
void
gegl_exit (void)
{
glong timing = gegl_ticks ();
gegl_tile_storage_cache_cleanup ();
gegl_tile_cache_destroy ();
gegl_operation_gtype_cleanup ();
gegl_extension_handler_cleanup ();
if (module_db != NULL)
{
g_object_unref (module_db);
module_db = NULL;
}
babl_exit ();
timing = gegl_ticks () - timing;
gegl_instrument ("gegl", "gegl_exit", timing);
/* used when tracking buffer and tile leaks */
if (g_getenv ("GEGL_DEBUG_BUFS") != NULL)
{
gegl_buffer_stats ();
gegl_tile_backend_ram_stats ();
gegl_tile_backend_file_stats ();
#if HAVE_GIO
gegl_tile_backend_tiledir_stats ();
#endif
}
global_time = gegl_ticks () - global_time;
gegl_instrument ("gegl", "gegl", global_time);
if (g_getenv ("GEGL_DEBUG_TIME") != NULL)
{
g_printf ("\n%s", gegl_instrument_utf8 ());
}
if (gegl_buffer_leaks ())
g_printf (" buffer-leaks: %i\n", gegl_buffer_leaks ());
gegl_tile_cache_destroy ();
if (gegl_swap_dir ())
{
/* remove all files matching <$GEGL_SWAP>/GEGL-<pid>-*.swap */
guint pid = getpid ();
GDir *dir = g_dir_open (gegl_swap_dir (), 0, NULL);
gchar *glob = g_strdup_printf ("%i-*", pid);
GPatternSpec *pattern = g_pattern_spec_new (glob);
g_free (glob);
if (dir != NULL)
{
const gchar *name;
while ((name = g_dir_read_name (dir)) != NULL)
{
if (g_pattern_match_string (pattern, name))
{
gchar *fname = g_build_filename (gegl_swap_dir (),
name,
NULL);
g_unlink (fname);
g_free (fname);
}
}
g_dir_close (dir);
}
g_pattern_spec_free (pattern);
}
g_object_unref (config);
config = NULL;
}
/* Funcion loadDispatcher
* Precondiciones:
* Postcondiciones:
* Entrada:
* Salida:
* Proceso:
* */
gpointer
loadDispatcher (gpointer data)
{
ThreadData* tData;
Message* msg;
Plugin* plugin;
RoutingEntry* entry;
GData** dPlugins;
GAsyncQueue* qMessages;
gint tableLength, i;
GError* ioError;
gchar** funcError;
tData = data;
dPlugins = tData->dPlugins;
qMessages = tData->qMessages;
tableLength = g_queue_get_length(routingTable);
/* Now the dispatcher is fully functional. */
g_debug("Dispatcher up & running");
/* Keeps sending data */
while (dPlugins != NULL)
{
/* Gets a new message to dispatch.
* Trying to pop a message is actually more efficient than
* search for at least one element in the queue.
* */
if ((msg = (Message*)g_async_queue_try_pop(qMessages)) != NULL)
{
/* Chooses a default plugin using the original message protocol. */
plugin = g_datalist_get_data(dPlugins, msg->proto);
/* Checks if the message has already reached its destination.
* - If it has, it will be logged into a file.
* - If it has not reached its destination and there is not a
* 'route' defined for it, dispatch.
* - If it has not reached its destination and there is a
* 'route' defined for it, dispatch it through that way.
* */
if (g_str_equal(msg->dest, plugin->pluginAddress()))
{
ioError = NULL;
/* Write to disk cache. */
if (!((g_io_channel_write_chars(msgLog,
g_strconcat(msg->proto, DELIMITER, msg->src, DELIMITER, msg->data, EOL, NULL),
-1, NULL,
&ioError) == (G_IO_STATUS_ERROR | G_IO_STATUS_AGAIN)) &&
(g_io_channel_flush(msgLog,
&ioError) == (G_IO_STATUS_ERROR | G_IO_STATUS_AGAIN))))
{
if (ioError != NULL)
{
g_warning("%s: %s", CANNOTWRITEDATA, ioError->message);
}
else
{
g_warning("%s: %s", CANNOTWRITEDATA, NOERRORAVAILABLE);
}
}
else
{
g_debug(MSGWRITEONLOG);
}
}
else
{
i = 0;
/* Search for a route in the route table. */
while (i < tableLength)
{
entry = g_queue_peek_nth(routingTable, i);
if (g_str_equal(entry->msgProto, msg->proto) &&
g_pattern_match_string(entry->msgAddrPattern, msg->dest))
{
plugin = g_datalist_get_data(dPlugins, entry->destProto);
i = tableLength;
}
else
{
i++;
}
}
if (!plugin->pluginSend((gpointer)msg->dest, (gpointer)msg, funcError))
{
g_warning("%s: %s", CANNOTSENDDATA, *funcError);
}
}
}
else
{
g_usleep(WAITPERIOD);
}
}
g_debug("End dispatching process");
return (NULL);
}