/** * lt_script_db_new: * * Create a new instance of a #lt_script_db_t. * * Returns: (transfer full): a new instance of #lt_script_db_t. */ lt_script_db_t * lt_script_db_new(void) { lt_script_db_t *retval = lt_mem_alloc_object(sizeof (lt_script_db_t)); if (retval) { lt_error_t *err = NULL; lt_script_t *le; LT_ITER_TMPL_INIT (&retval->parent, _lt_script_db); retval->script_entries = lt_trie_new(); lt_mem_add_ref((lt_mem_t *)retval, retval->script_entries, (lt_destroy_func_t)lt_trie_unref); le = lt_script_create(); lt_script_set_tag(le, "*"); lt_script_set_name(le, "Wildcard entry"); lt_trie_replace(retval->script_entries, lt_script_get_tag(le), le, (lt_destroy_func_t)lt_script_unref); le = lt_script_create(); lt_script_set_tag(le, ""); lt_script_set_name(le, "Empty entry"); lt_trie_replace(retval->script_entries, lt_script_get_tag(le), le, (lt_destroy_func_t)lt_script_unref); retval->xml = lt_xml_new(); if (!retval->xml) { lt_script_db_unref(retval); retval = NULL; goto bail; } lt_mem_add_ref((lt_mem_t *)retval, retval->xml, (lt_destroy_func_t)lt_xml_unref); lt_script_db_parse(retval, &err); if (lt_error_is_set(err, LT_ERR_ANY)) { lt_error_print(err, LT_ERR_ANY); lt_script_db_unref(retval); retval = NULL; lt_error_unref(err); } } bail: return retval; }
/** * lt_region_db_new: * * Create a new instance of a #lt_region_db_t. * * Returns: (transfer full): a new instance of #lt_region_db_t. */ lt_region_db_t * lt_region_db_new(void) { lt_region_db_t *retval = lt_mem_alloc_object(sizeof (lt_region_db_t)); if (retval) { GError *err = NULL; lt_region_t *le; retval->region_entries = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)lt_region_unref); lt_mem_add_ref(&retval->parent, retval->region_entries, (lt_destroy_func_t)g_hash_table_destroy); le = lt_region_create(); lt_region_set_tag(le, "*"); lt_region_set_name(le, "Wildcard entry"); g_hash_table_replace(retval->region_entries, g_strdup(lt_region_get_tag(le)), le); le = lt_region_create(); lt_region_set_tag(le, ""); lt_region_set_name(le, "Empty entry"); g_hash_table_replace(retval->region_entries, g_strdup(lt_region_get_tag(le)), le); retval->xml = lt_xml_new(); if (!retval->xml) { lt_region_db_unref(retval); retval = NULL; goto bail; } lt_mem_add_ref(&retval->parent, retval->xml, (lt_destroy_func_t)lt_xml_unref); lt_region_db_parse(retval, &err); if (err) { g_printerr(err->message); lt_region_db_unref(retval); retval = NULL; g_error_free(err); } } bail: return retval; }
/*< private >*/ static gboolean lt_xml_read_subtag_registry(lt_xml_t *xml, GError **error) { gchar *regfile = NULL; xmlParserCtxtPtr xmlparser; xmlDocPtr doc = NULL; GError *err = NULL; g_return_val_if_fail (xml != NULL, FALSE); #ifdef GNOME_ENABLE_DEBUG regfile = g_build_filename(BUILDDIR, "data", "language-subtag-registry.xml", NULL); if (!g_file_test(regfile, G_FILE_TEST_EXISTS)) { g_free(regfile); #endif regfile = g_build_filename(lt_db_get_datadir(), "language-subtag-registry.xml", NULL); #ifdef GNOME_ENABLE_DEBUG } #endif xmlparser = xmlNewParserCtxt(); if (!xmlparser) { g_set_error(&err, LT_ERROR, LT_ERR_OOM, "Unable to create an instance of xmlParserCtxt."); goto bail; } doc = xmlCtxtReadFile(xmlparser, regfile, "UTF-8", 0); if (!doc) { g_set_error(&err, LT_ERROR, LT_ERR_FAIL_ON_XML, "Unable to read the xml file: %s", regfile); goto bail; } xml->subtag_registry = doc; lt_mem_add_ref(&xml->parent, xml->subtag_registry, (lt_destroy_func_t)xmlFreeDoc); bail: g_free(regfile); if (xmlparser) xmlFreeParserCtxt(xmlparser); xmlCleanupParser(); if (err) { if (error) *error = g_error_copy(err); else g_warning(err->message); g_error_free(err); return FALSE; } return TRUE; }
void lt_region_set_preferred_tag(lt_region_t *region, const char *subtag) { lt_return_if_fail (region != NULL); lt_return_if_fail (subtag != NULL); if (region->preferred_tag) lt_mem_delete_ref(®ion->parent, region->preferred_tag); region->preferred_tag = strdup(subtag); lt_mem_add_ref(®ion->parent, region->preferred_tag, free); }
void lt_region_set_name(lt_region_t *region, const char *description) { lt_return_if_fail (region != NULL); lt_return_if_fail (description != NULL); if (region->description) lt_mem_delete_ref(®ion->parent, region->description); region->description = strdup(description); lt_mem_add_ref(®ion->parent, region->description, free); }
void lt_grandfathered_set_preferred_tag(lt_grandfathered_t *grandfathered, const gchar *subtag) { g_return_if_fail (grandfathered != NULL); g_return_if_fail (subtag != NULL); if (grandfathered->preferred_tag) lt_mem_remove_ref(&grandfathered->parent, grandfathered->preferred_tag); grandfathered->preferred_tag = g_strdup(subtag); lt_mem_add_ref(&grandfathered->parent, grandfathered->preferred_tag, (lt_destroy_func_t)g_free); }
void lt_grandfathered_set_name(lt_grandfathered_t *grandfathered, const gchar *description) { g_return_if_fail (grandfathered != NULL); g_return_if_fail (description != NULL); if (grandfathered->description) lt_mem_remove_ref(&grandfathered->parent, grandfathered->description); grandfathered->description = g_strdup(description); lt_mem_add_ref(&grandfathered->parent, grandfathered->description, (lt_destroy_func_t)g_free); }
void lt_redundant_set_preferred_tag(lt_redundant_t *redundant, const gchar *subtag) { g_return_if_fail (redundant != NULL); g_return_if_fail (subtag != NULL); if (redundant->preferred_tag) lt_mem_remove_ref(&redundant->parent, redundant->preferred_tag); redundant->preferred_tag = g_strdup(subtag); lt_mem_add_ref(&redundant->parent, redundant->preferred_tag, (lt_destroy_func_t)g_free); }
void lt_redundant_set_name(lt_redundant_t *redundant, const gchar *description) { g_return_if_fail (redundant != NULL); g_return_if_fail (description != NULL); if (redundant->description) lt_mem_remove_ref(&redundant->parent, redundant->description); redundant->description = g_strdup(description); lt_mem_add_ref(&redundant->parent, redundant->description, (lt_destroy_func_t)g_free); }
lt_list_t * lt_list_prepend(lt_list_t *list, lt_pointer_t data, lt_destroy_func_t func) { lt_list_t *l = lt_list_new(); l->value = data; l->next = list; lt_mem_add_ref(&l->parent, l, _lt_list_update); if (func) lt_mem_add_ref(&l->parent, data, func); if (list) { l->prev = list->prev; if (list->prev) list->prev->next = l; list->prev = l; } else { l->prev = NULL; } return l; }
static lt_ext_module_t * lt_ext_module_new_with_data(const char *name, const lt_ext_module_funcs_t *funcs) { lt_ext_module_t *retval; lt_return_val_if_fail (name != NULL, NULL); lt_return_val_if_fail (funcs != NULL, NULL); retval = lt_mem_alloc_object(sizeof (lt_ext_module_t)); if (retval) { retval->name = strdup(name); lt_mem_add_ref(&retval->parent, retval->name, (lt_destroy_func_t)free); retval->funcs = funcs; lt_debug(LT_MSGCAT_MODULE, "Loading the internal extension handler: %s", name); } return retval; }
static lt_ext_module_t * lt_ext_module_new_with_data(const gchar *name, const lt_ext_module_funcs_t *funcs) { lt_ext_module_t *retval; g_return_val_if_fail (name != NULL, NULL); g_return_val_if_fail (funcs != NULL, NULL); retval = lt_mem_alloc_object(sizeof (lt_ext_module_t)); if (retval) { retval->name = g_strdup(name); lt_mem_add_ref(&retval->parent, retval->name, (lt_destroy_func_t)g_free); retval->funcs = funcs; g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading the internal extension handler: %s", name); } return retval; }
lt_ext_module_t * lt_ext_module_new(const gchar *name) { lt_ext_module_t *retval; g_return_val_if_fail (name != NULL, NULL); retval = lt_mem_alloc_object(sizeof (lt_ext_module_t)); if (retval) { gchar *filename = g_path_get_basename(name), *module = NULL; static const gchar *prefix = "liblangtag-ext-"; static gsize prefix_len = 0; gchar singleton_c; gint singleton; if (prefix_len == 0) prefix_len = strlen(prefix); if (strncmp(filename, prefix, prefix_len) == 0) { gsize len = strlen(&filename[prefix_len]); gsize suffix_len = strlen(G_MODULE_SUFFIX) + 1; if (len > suffix_len && g_strcmp0(&filename[prefix_len + len - suffix_len], "." G_MODULE_SUFFIX) == 0) { module = g_strndup(&filename[prefix_len], len - suffix_len); module[len - suffix_len] = 0; } } if (!module) module = g_strdup(filename); retval->name = module; lt_mem_add_ref(&retval->parent, retval->name, (lt_destroy_func_t)g_free); g_free(filename); if (!lt_ext_module_load(retval)) { lt_ext_module_unref(retval); return NULL; } singleton_c = lt_ext_module_get_singleton(retval); if (singleton_c == ' ' || singleton_c == '*') { g_warning("Not allowed to override the internal handlers for special singleton."); lt_ext_module_unref(retval); return NULL; } singleton = lt_ext_module_singleton_char_to_int(singleton_c); if (singleton < 0) { g_warning("Invalid singleton: `%c' - `%s'", singleton_c, retval->name); lt_ext_module_unref(retval); return NULL; } if (__lt_ext_modules[singleton]) { g_warning("Duplicate extension module: %s", retval->name); lt_ext_module_unref(retval); return NULL; } __lt_ext_modules[singleton] = retval; lt_mem_add_weak_pointer(&retval->parent, (gpointer *)&__lt_ext_modules[singleton]); } return retval; }
static gboolean lt_ext_module_load(lt_ext_module_t *module) { gchar *filename = g_strdup_printf("liblangtag-ext-%s." G_MODULE_SUFFIX, module->name); gchar **path_list, *s, *path = NULL, *fullname = NULL; const gchar *env = g_getenv("LANGTAG_EXT_MODULE_PATH"); gint i; gboolean retval = FALSE; gsize len; if (!env) { path_list = g_strsplit( #ifdef GNOME_ENABLE_DEBUG BUILDDIR G_DIR_SEPARATOR_S "liblangtag" G_DIR_SEPARATOR_S "extensions" G_SEARCHPATH_SEPARATOR_S BUILDDIR G_DIR_SEPARATOR_S "liblangtag" G_DIR_SEPARATOR_S "extensions" G_DIR_SEPARATOR_S ".libs" G_SEARCHPATH_SEPARATOR_S #endif LANGTAG_EXT_MODULE_PATH, G_SEARCHPATH_SEPARATOR_S, -1); } else { path_list = g_strsplit(env, G_SEARCHPATH_SEPARATOR_S, -1); } for (i = 0; path_list[i] != NULL && !retval; i++) { s = path_list[i]; while (*s && g_ascii_isspace(*s)) s++; len = strlen(s); while (len > 0 && g_ascii_isspace(s[len - 1])) len--; g_free(path); path = g_strndup(s, len); if (path[0] != 0) { g_free(fullname); fullname = g_build_filename(path, filename, NULL); module->module = g_module_open(fullname, G_MODULE_BIND_LAZY|G_MODULE_BIND_LOCAL); if (module->module) { gpointer func; lt_mem_add_ref(&module->parent, module->module, (lt_destroy_func_t)g_module_close); g_module_symbol(module->module, "module_get_version", &func); if (!func) { g_warning(g_module_error()); break; } if (((lt_ext_module_version_func_t)func)() != LT_EXT_MODULE_VERSION) { g_warning("`%s' isn't satisfied the required module version.", filename); break; } g_module_symbol(module->module, "module_get_funcs", &func); if (!func) { g_warning(g_module_error()); break; } if (!(module->funcs = ((lt_ext_module_get_funcs_func_t)func)())) { g_warning("No function table for `%s'", filename); break; } g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading the external extension handler module: %s", fullname); retval = TRUE; } } } if (!retval) g_warning("No such modules: %s", module->name); g_free(fullname); g_free(path); g_free(filename); g_strfreev(path_list); return retval; }
static lt_bool_t lt_ext_module_load(lt_ext_module_t *module) { lt_bool_t retval = FALSE; lt_string_t *fullname = lt_string_new(NULL); char *filename = lt_strdup_printf("liblangtag-ext-%s." LT_MODULE_SUFFIX, module->name); char *path_list, *p, *s, *path; const char *env = getenv("LANGTAG_EXT_MODULE_PATH"); size_t len; if (!env) { path_list = strdup( #ifdef GNOME_ENABLE_DEBUG BUILDDIR LT_DIR_SEPARATOR_S "extensions" LT_SEARCHPATH_SEPARATOR_S BUILDDIR LT_DIR_SEPARATOR_S "extensions" LT_DIR_SEPARATOR_S ".libs" LT_SEARCHPATH_SEPARATOR_S #endif LANGTAG_EXT_MODULE_PATH); } else { path_list = strdup(env); } s = path_list; do { if (!s) break; p = strchr(s, LT_SEARCHPATH_SEPARATOR); if (p == s) { s++; continue; } path = s; if (p) { *p = 0; p++; } s = p; while (*path && isspace((int)*path)) path++; len = strlen(path); while (len > 0 && isspace((int)path[len - 1])) len--; path[len] = 0; if (path[0] != 0) { lt_string_clear(fullname); lt_string_append_filename(fullname, path, filename, NULL); module->module = dlopen(lt_string_value(fullname), RTLD_LAZY|RTLD_LOCAL); if (module->module) { lt_pointer_t func; lt_mem_add_ref(&module->parent, module->module, (lt_destroy_func_t)dlclose); func = dlsym(module->module, "module_get_version"); if (!func) { lt_warning(dlerror()); break; } if (((lt_ext_module_version_func_t)func)() != LT_EXT_MODULE_VERSION) { lt_warning("`%s' isn't satisfied the required module version.", filename); break; } func = dlsym(module->module, "module_get_funcs"); if (!func) { lt_warning(dlerror()); break; } if (!(module->funcs = ((lt_ext_module_get_funcs_func_t)func)())) { lt_warning("No function table for `%s'", filename); break; } lt_debug(LT_MSGCAT_MODULE, "Loading the external extension handler module: %s", lt_string_value(fullname)); retval = TRUE; } } } while (1); if (!retval) lt_warning("No such modules: %s", module->name); lt_string_unref(fullname); free(filename); free(path_list); return retval; }