Example #1
0
} TEND

TDEF (lt_trie_unref) {
	lt_trie_t *t;

	t = lt_trie_new();
	lt_mem_add_weak_pointer((lt_mem_t *)t, (lt_pointer_t *)&t);
	lt_trie_unref(t);
	fail_unless(t == NULL, "Not registered as a weak pointer properly");
} TEND
Example #2
0
/**
 * lt_ext_modules_load:
 *
 * Load all of the modules on the system, including the internal accessor.
 * This has to be invoked before processing something with #lt_extension_t.
 * or lt_db_initialize() does.
 */
void
lt_ext_modules_load(void)
{
#ifdef ENABLE_GMODULE
	const gchar *env = g_getenv("LANGTAG_EXT_MODULE_PATH");
	gchar **path_list;
	gint i;
	gsize suffix_len = strlen(G_MODULE_SUFFIX) + 1;

	if (__lt_ext_module_initialized)
		return;
	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; i++) {
		DIR *dir;

		dir = opendir(path_list[i]);
		if (dir) {
			struct dirent dent, *dresult;
			gsize len;

			while (1) {
				if (readdir_r(dir, &dent, &dresult) || dresult == NULL)
					break;

				len = strlen(dent.d_name);
				if (len > suffix_len &&
				    g_strcmp0(&dent.d_name[len - suffix_len],
					      "." G_MODULE_SUFFIX) == 0) {
					lt_ext_module_new(dent.d_name);
				}
			}
			closedir(dir);
		}
	}
	g_strfreev(path_list);
#endif /* ENABLE_GMODULE */
	__lt_ext_default_handler = lt_ext_module_new_with_data("default",
							       &__default_funcs);
	lt_mem_add_weak_pointer(&__lt_ext_default_handler->parent,
				(gpointer *)&__lt_ext_default_handler);
	__lt_ext_modules[LT_MAX_EXT_MODULES - 2] = lt_ext_module_new_with_data("empty",
									       &__empty_and_wildcard_funcs);
	lt_mem_add_weak_pointer(&__lt_ext_modules[LT_MAX_EXT_MODULES - 2]->parent,
				(gpointer *)&__lt_ext_modules[LT_MAX_EXT_MODULES - 2]);
	__lt_ext_modules[LT_MAX_EXT_MODULES - 1] = lt_ext_module_new_with_data("wildcard",
									   &__empty_and_wildcard_funcs);
	lt_mem_add_weak_pointer(&__lt_ext_modules[LT_MAX_EXT_MODULES - 1]->parent,
				(gpointer *)&__lt_ext_modules[LT_MAX_EXT_MODULES - 1]);
	__lt_ext_module_initialized = TRUE;
}
Example #3
0
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;
}
Example #4
0
/*< public >*/
lt_xml_t *
lt_xml_new(void)
{
	GError *err = NULL;

	G_LOCK (lt_xml);

	if (__xml) {
		G_UNLOCK (lt_xml);

		return lt_xml_ref(__xml);
	}

	__xml = lt_mem_alloc_object(sizeof (lt_xml_t));
	if (__xml) {
		lt_mem_add_weak_pointer(&__xml->parent, (gpointer *)&__xml);
		if (!lt_xml_read_subtag_registry(__xml, &err))
			goto bail;
		if (!lt_xml_read_cldr_bcp47(__xml, "calendar.xml",
					    &__xml->cldr_bcp47_calendar,
					    &err))
			goto bail;
		if (!lt_xml_read_cldr_bcp47(__xml, "collation.xml",
					    &__xml->cldr_bcp47_collation,
					    &err))
			goto bail;
		if (!lt_xml_read_cldr_bcp47(__xml, "currency.xml",
					    &__xml->cldr_bcp47_currency,
					    &err))
			goto bail;
		if (!lt_xml_read_cldr_bcp47(__xml, "number.xml",
					    &__xml->cldr_bcp47_number,
					    &err))
			goto bail;
		if (!lt_xml_read_cldr_bcp47(__xml, "timezone.xml",
					    &__xml->cldr_bcp47_timezone,
					    &err))
			goto bail;
		if (!lt_xml_read_cldr_bcp47(__xml, "transform.xml",
					    &__xml->cldr_bcp47_transform,
					    &err))
			goto bail;
		if (!lt_xml_read_cldr_bcp47(__xml, "variant.xml",
					    &__xml->cldr_bcp47_variant,
					    &err))
			goto bail;
		if (!lt_xml_read_cldr_supplemental(__xml, "likelySubtags.xml",
						   &__xml->cldr_supplemental_likelysubtags,
						   &err))
			goto bail;
	}

  bail:
	if (err) {
		g_warning(err->message);
		g_error_free(err);
		lt_xml_unref(__xml);
	}

	G_UNLOCK (lt_xml);

	return __xml;
}
/**
 * lt_ext_modules_load:
 *
 * Load all of the modules on the system, including the internal accessor.
 * This has to be invoked before processing something with #lt_extension_t.
 * or lt_db_initialize() does.
 */
void
lt_ext_modules_load(void)
{
#if ENABLE_MODULE
	const char *env = getenv("LANGTAG_EXT_MODULE_PATH");
	char *path_list, *s, *p, *path;
	size_t suffix_len = strlen(LT_MODULE_SUFFIX) + 1;

	if (__lt_ext_module_initialized)
		return;
	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 {
		DIR *dir;

		if (!s)
			break;
		p = strchr(s, LT_SEARCHPATH_SEPARATOR);
		if (s == p) {
			s++;
			continue;
		}
		path = s;
		if (p) {
			*p = 0;
			p++;
		}
		s = p;

		dir = opendir(path);
		if (dir) {
			struct dirent dent, *dresult;
			size_t len;

			while (1) {
				if (readdir_r(dir, &dent, &dresult) || dresult == NULL)
					break;

				len = strlen(dent.d_name);
				if (len > suffix_len &&
				    lt_strcmp0(&dent.d_name[len - suffix_len],
					       "." LT_MODULE_SUFFIX) == 0) {
					lt_ext_module_new(dent.d_name);
				}
			}
			closedir(dir);
		}
	} while (1);

	free(path_list);
#else /* !ENABLE_MODULE */
	const lt_ext_module_funcs_t *f;
	int c;

#define REGISTER(_ext_)							\
	f = LT_MODULE_SYMBOL_ (lt_module_ext_##_ext_, get_funcs) ();	\
	c = lt_ext_module_singleton_char_to_int(f->get_singleton());	\
	__lt_ext_modules[c] = lt_ext_module_new_with_data(#_ext_, f);	\
	lt_mem_add_weak_pointer(&__lt_ext_modules[c]->parent,		\
				(lt_pointer_t *)&__lt_ext_modules[c]);

	REGISTER (t);
	REGISTER (u);

#undef REGISTER
#endif /* ENABLE_MODULE */
	__lt_ext_default_handler = lt_ext_module_new_with_data("default",
							       &__default_funcs);
	lt_mem_add_weak_pointer(&__lt_ext_default_handler->parent,
				(lt_pointer_t *)&__lt_ext_default_handler);
	__lt_ext_modules[LT_MAX_EXT_MODULES - 2] = lt_ext_module_new_with_data("empty",
									       &__empty_and_wildcard_funcs);
	lt_mem_add_weak_pointer(&__lt_ext_modules[LT_MAX_EXT_MODULES - 2]->parent,
				(lt_pointer_t *)&__lt_ext_modules[LT_MAX_EXT_MODULES - 2]);
	__lt_ext_modules[LT_MAX_EXT_MODULES - 1] = lt_ext_module_new_with_data("wildcard",
									   &__empty_and_wildcard_funcs);
	lt_mem_add_weak_pointer(&__lt_ext_modules[LT_MAX_EXT_MODULES - 1]->parent,
				(lt_pointer_t *)&__lt_ext_modules[LT_MAX_EXT_MODULES - 1]);
	__lt_ext_module_initialized = TRUE;
}