/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; coding: utf-8 -*- */
/* gtksourcelanguagemanager.c
* This file is part of GtkSourceView
*
* Copyright (C) 2003-2007 - Paolo Maggi <paolo.maggi@polito.it>
*
* GtkSourceView 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.1 of the License, or (at your option) any later version.
*
* GtkSourceView 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
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "gtksourcelanguagemanager.h"
#include <string.h>
#include <gio/gio.h>
#include "gtksourcelanguage.h"
#include "gtksourcelanguage-private.h"
#include "gtksourceview-utils.h"
#include "gtksourceview-i18n.h"
/**
* SECTION:languagemanager
* @Short_description: Provides access to GtkSourceLanguages
* @Title: GtkSourceLanguageManager
* @See_also: #GtkSourceLanguage
*
* #GtkSourceLanguageManager is an object which processes language description
* files and creates and stores #GtkSourceLanguage objects, and provides API to
* access them.
* Use gtk_source_language_manager_get_default() to retrieve the default
* instance of #GtkSourceLanguageManager, and
* gtk_source_language_manager_guess_language() to get a #GtkSourceLanguage for
* given file name and content type.
*/
#define RNG_SCHEMA_FILE "language2.rng"
#define LANGUAGE_DIR "language-specs"
#define LANG_FILE_SUFFIX ".lang"
enum {
PROP_0,
PROP_SEARCH_PATH,
PROP_LANGUAGE_IDS
};
struct _GtkSourceLanguageManagerPrivate
{
GHashTable *language_ids;
gchar **lang_dirs;
gchar *rng_file;
gchar **ids; /* Cache the IDs of the available languages */
};
static GtkSourceLanguageManager *default_instance;
G_DEFINE_TYPE_WITH_PRIVATE (GtkSourceLanguageManager, gtk_source_language_manager, G_TYPE_OBJECT)
static void
gtk_source_language_manager_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkSourceLanguageManager *lm;
lm = GTK_SOURCE_LANGUAGE_MANAGER (object);
switch (prop_id)
{
case PROP_SEARCH_PATH:
gtk_source_language_manager_set_search_path (lm, g_value_get_boxed (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gtk_source_language_manager_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkSourceLanguageManager *lm;
lm = GTK_SOURCE_LANGUAGE_MANAGER (object);
switch (prop_id)
{
case PROP_SEARCH_PATH:
g_value_set_boxed (value, gtk_source_language_manager_get_search_path (lm));
break;
case PROP_LANGUAGE_IDS:
g_value_set_boxed (value, gtk_source_language_manager_get_language_ids (lm));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gtk_source_language_manager_finalize (GObject *object)
{
GtkSourceLanguageManager *lm;
lm = GTK_SOURCE_LANGUAGE_MANAGER (object);
if (lm->priv->language_ids)
g_hash_table_destroy (lm->priv->language_ids);
g_strfreev (lm->priv->ids);
g_strfreev (lm->priv->lang_dirs);
g_free (lm->priv->rng_file);
G_OBJECT_CLASS (gtk_source_language_manager_parent_class)->finalize (object);
}
static void
gtk_source_language_manager_class_init (GtkSourceLanguageManagerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gtk_source_language_manager_finalize;
object_class->set_property = gtk_source_language_manager_set_property;
object_class->get_property = gtk_source_language_manager_get_property;
g_object_class_install_property (object_class,
PROP_SEARCH_PATH,
g_param_spec_boxed ("search-path",
"Language specification directories",
"List of directories where the "
"language specification files (.lang) "
"are located",
G_TYPE_STRV,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (object_class,
PROP_LANGUAGE_IDS,
g_param_spec_boxed ("language-ids",
"Language ids",
"List of the ids of the available languages",
G_TYPE_STRV,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS));
}
static void
gtk_source_language_manager_init (GtkSourceLanguageManager *lm)
{
lm->priv = gtk_source_language_manager_get_instance_private (lm);
lm->priv->language_ids = NULL;
lm->priv->ids = NULL;
lm->priv->lang_dirs = NULL;
lm->priv->rng_file = NULL;
}
/**
* gtk_source_language_manager_new:
*
* Creates a new language manager. If you do not need more than one language
* manager or a private language manager instance then use
* gtk_source_language_manager_get_default() instead.
*
* Returns: a new #GtkSourceLanguageManager.
*/
GtkSourceLanguageManager *
gtk_source_language_manager_new (void)
{
return g_object_new (GTK_SOURCE_TYPE_LANGUAGE_MANAGER, NULL);
}
/**
* gtk_source_language_manager_get_default:
*
* Returns the default #GtkSourceLanguageManager instance.
*
* Returns: (transfer none): a #GtkSourceLanguageManager.
* Return value is owned by GtkSourceView library and must not be unref'ed.
*/
GtkSourceLanguageManager *
gtk_source_language_manager_get_default (void)
{
if (default_instance == NULL)
{
default_instance = gtk_source_language_manager_new ();
g_object_add_weak_pointer (G_OBJECT (default_instance),
(gpointer) &default_instance);
}
return default_instance;
}
GtkSourceLanguageManager *
_gtk_source_language_manager_peek_default (void)
{
return default_instance;
}
static void
notify_search_path (GtkSourceLanguageManager *mgr)
{
g_object_notify (G_OBJECT (mgr), "search-path");
g_object_notify (G_OBJECT (mgr), "language-ids");
}
/**
* gtk_source_language_manager_set_search_path:
* @lm: a #GtkSourceLanguageManager.
* @dirs: (nullable) (array zero-terminated=1):
* a %NULL-terminated array of strings or %NULL.
*
* Sets the list of directories where the @lm looks for
* language files.
* If @dirs is %NULL, the search path is reset to default.
*
* <note>
* <para>
* At the moment this function can be called only before the
* language files are loaded for the first time. In practice
* to set a custom search path for a #GtkSourceLanguageManager,
* you have to call this function right after creating it.
* </para>
* </note>
*/
void
gtk_source_language_manager_set_search_path (GtkSourceLanguageManager *lm,
gchar **dirs)
{
gchar **tmp;
g_return_if_fail (GTK_SOURCE_IS_LANGUAGE_MANAGER (lm));
/* Search path cannot be changed in the list of available languages
* as been already computed */
g_return_if_fail (lm->priv->ids == NULL);
tmp = lm->priv->lang_dirs;
if (dirs == NULL)
lm->priv->lang_dirs = _gtk_source_view_get_default_dirs (LANGUAGE_DIR, TRUE);
else
lm->priv->lang_dirs = g_strdupv (dirs);
g_strfreev (tmp);
notify_search_path (lm);
}
/**
* gtk_source_language_manager_get_search_path:
* @lm: a #GtkSourceLanguageManager.
*
* Gets the list directories where @lm looks for language files.
*
* Returns: (array zero-terminated=1) (transfer none): %NULL-terminated array
* containg a list of language files directories.
* The array is owned by @lm and must not be modified.
*/
const gchar * const *
gtk_source_language_manager_get_search_path (GtkSourceLanguageManager *lm)
{
g_return_val_if_fail (GTK_SOURCE_IS_LANGUAGE_MANAGER (lm), NULL);
if (lm->priv->lang_dirs == NULL)
lm->priv->lang_dirs = _gtk_source_view_get_default_dirs (LANGUAGE_DIR, TRUE);
return (const gchar * const *)lm->priv->lang_dirs;
}
/**
* _gtk_source_language_manager_get_rng_file:
* @lm: a #GtkSourceLanguageManager.
*
* Returns location of the RNG schema file for lang files version 2.
*
* Returns: path to RNG file. It belongs to %lm and must not be freed or modified.
*/
const char *
_gtk_source_language_manager_get_rng_file (GtkSourceLanguageManager *lm)
{
g_return_val_if_fail (GTK_SOURCE_IS_LANGUAGE_MANAGER (lm), NULL);
if (lm->priv->rng_file == NULL)
{
const gchar * const *dirs;
for (dirs = gtk_source_language_manager_get_search_path (lm);
dirs != NULL && *dirs != NULL;
++dirs)
{
gchar *file;
file = g_build_filename (*dirs, RNG_SCHEMA_FILE, NULL);
if (g_file_test (file, G_FILE_TEST_EXISTS))
{
lm->priv->rng_file = file;
break;
}
g_free (file);
}
}
return lm->priv->rng_file;
}
static gint
language_compare (const gchar **id1, const gchar **id2, GHashTable *language_ids)
{
GtkSourceLanguage *lang1, *lang2;
const gchar *name1, *name2;
lang1 = g_hash_table_lookup (language_ids, *id1);
lang2 = g_hash_table_lookup (language_ids, *id2);
name1 = gtk_source_language_get_name (lang1);
name2 = gtk_source_language_get_name (lang2);
return g_utf8_collate (name1, name2);
}
static void
ensure_languages (GtkSourceLanguageManager *lm)
{
GSList *filenames, *l;
GPtrArray *ids_array = NULL;
if (lm->priv->language_ids != NULL)
return;
lm->priv->language_ids = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, g_object_unref);
filenames = _gtk_source_view_get_file_list ((gchar **)gtk_source_language_manager_get_search_path (lm),
LANG_FILE_SUFFIX,
TRUE);
for (l = filenames; l != NULL; l = l->next)
{
GtkSourceLanguage *lang;
gchar *filename;
filename = l->data;
lang = _gtk_source_language_new_from_file (filename, lm);
if (lang == NULL)
{
g_warning ("Error reading language specification file '%s'", filename);
continue;
}
if (g_hash_table_lookup (lm->priv->language_ids, lang->priv->id) == NULL)
{
g_hash_table_insert (lm->priv->language_ids,
g_strdup (lang->priv->id),
lang);
if (ids_array == NULL)
ids_array = g_ptr_array_new ();
g_ptr_array_add (ids_array, g_strdup (lang->priv->id));
}
else
{
g_object_unref (lang);
}
}
if (ids_array != NULL)
{
/* Sort the array alphabetically so that it
* is ready to use in a list of a GUI */
g_ptr_array_sort_with_data (ids_array,
(GCompareDataFunc)language_compare,
lm->priv->language_ids);
/* Ensure the array is NULL terminated */
g_ptr_array_add (ids_array, NULL);
lm->priv->ids = (gchar **)g_ptr_array_free (ids_array, FALSE);
}
g_slist_free_full (filenames, g_free);
}
/**
* gtk_source_language_manager_get_language_ids:
* @lm: a #GtkSourceLanguageManager.
*
* Returns the ids of the available languages.
*
* Returns: (nullable) (array zero-terminated=1) (transfer none):
* a %NULL-terminated array of strings containing the ids of the available
* languages or %NULL if no language is available.
* The array is sorted alphabetically according to the language name.
* The array is owned by @lm and must not be modified.
*/
const gchar * const *
gtk_source_language_manager_get_language_ids (GtkSourceLanguageManager *lm)
{
g_return_val_if_fail (GTK_SOURCE_IS_LANGUAGE_MANAGER (lm), NULL);
ensure_languages (lm);
return (const gchar * const *)lm->priv->ids;
}
/**
* gtk_source_language_manager_get_language:
* @lm: a #GtkSourceLanguageManager.
* @id: a language id.
*
* Gets the #GtkSourceLanguage identified by the given @id in the language
* manager.
*
* Returns: (nullable) (transfer none): a #GtkSourceLanguage, or %NULL
* if there is no language identified by the given @id. Return value is
* owned by @lm and should not be freed.
*/
GtkSourceLanguage *
gtk_source_language_manager_get_language (GtkSourceLanguageManager *lm,
const gchar *id)
{
g_return_val_if_fail (GTK_SOURCE_IS_LANGUAGE_MANAGER (lm), NULL);
g_return_val_if_fail (id != NULL, NULL);
ensure_languages (lm);
return g_hash_table_lookup (lm->priv->language_ids, id);
}
static GSList *
pick_langs_for_filename (GtkSourceLanguageManager *lm,
const gchar *filename)
{
char *filename_utf8;
const gchar* const * p;
GSList *langs = NULL;
/* Use g_filename_display_name() instead of g_filename_to_utf8() because
* g_filename_display_name() doesn't fail and replaces non-convertible
* characters to unicode substitution symbol. */
filename_utf8 = g_filename_display_name (filename);
for (p = gtk_source_language_manager_get_language_ids (lm);
p != NULL && *p != NULL;
p++)
{
GtkSourceLanguage *lang;
gchar **globs, **gptr;
lang = gtk_source_language_manager_get_language (lm, *p);
globs = gtk_source_language_get_globs (lang);
for (gptr = globs; gptr != NULL && *gptr != NULL; gptr++)
{
/* FIXME g_pattern_match is wrong: there are no '[...]'
* character ranges and '*' and '?' can not be escaped
* to include them literally in a pattern. */
if (g_pattern_match_simple (*gptr, filename_utf8))
{
langs = g_slist_prepend (langs, lang);
}
}
g_strfreev (globs);
}
g_free (filename_utf8);
return langs;
}
static GtkSourceLanguage *
pick_lang_for_mime_type_pass (GtkSourceLanguageManager *lm,
const char *mime_type,
gboolean exact_match)
{
const gchar* const * id_ptr;
for (id_ptr = gtk_source_language_manager_get_language_ids (lm);
id_ptr != NULL && *id_ptr != NULL;
id_ptr++)
{
GtkSourceLanguage *lang;
gchar **mime_types, **mptr;
lang = gtk_source_language_manager_get_language (lm, *id_ptr);
mime_types = gtk_source_language_get_mime_types (lang);
for (mptr = mime_types; mptr != NULL && *mptr != NULL; mptr++)
{
gboolean matches;
if (exact_match)
matches = strcmp (mime_type, *mptr) == 0;
else
matches = g_content_type_is_a (mime_type, *mptr);
if (matches)
{
g_strfreev (mime_types);
return lang;
}
}
g_strfreev (mime_types);
}
return NULL;
}
static GtkSourceLanguage *
pick_lang_for_mime_type_real (GtkSourceLanguageManager *lm,
const char *mime_type)
{
GtkSourceLanguage *lang;
lang = pick_lang_for_mime_type_pass (lm, mime_type, TRUE);
if (!lang)
lang = pick_lang_for_mime_type_pass (lm, mime_type, FALSE);
return lang;
}
#ifdef G_OS_WIN32
static void
grok_win32_content_type (const gchar *content_type,
gchar **alt_filename,
gchar **mime_type)
{
*alt_filename = NULL;
*mime_type = NULL;
/* If it contains slash, then it's probably a mime type.
* Otherwise treat is an extension. */
if (strchr (content_type, '/') != NULL)
*mime_type = g_strdup (content_type);
else
*alt_filename = g_strjoin ("filename", content_type, NULL);
}
#endif
static GtkSourceLanguage *
pick_lang_for_mime_type (GtkSourceLanguageManager *lm,
const gchar *content_type)
{
GtkSourceLanguage *lang = NULL;
#ifndef G_OS_WIN32
/* On Unix "content type" is mime type */
lang = pick_lang_for_mime_type_real (lm, content_type);
#else
/* On Windows "content type" is an extension, but user may pass a mime type too */
gchar *mime_type;
gchar *alt_filename;
grok_win32_content_type (content_type, &alt_filename, &mime_type);
if (alt_filename != NULL)
{
GSList *langs;
langs = pick_langs_for_filename (lm, alt_filename);
if (langs != NULL)
lang = GTK_SOURCE_LANGUAGE (langs->data);
}
if (lang == NULL && mime_type != NULL)
lang = pick_lang_for_mime_type_real (lm, mime_type);
g_free (mime_type);
g_free (alt_filename);
#endif
return lang;
}
/**
* gtk_source_language_manager_guess_language:
* @lm: a #GtkSourceLanguageManager.
* @filename: (nullable): a filename in Glib filename encoding, or %NULL.
* @content_type: (nullable): a content type (as in GIO API), or %NULL.
*
* Picks a #GtkSourceLanguage for given file name and content type,
* according to the information in lang files. Either @filename or
* @content_type may be %NULL. This function can be used as follows:
*
* <informalexample><programlisting>
* GtkSourceLanguage *lang;
* lang = gtk_source_language_manager_guess_language (filename, NULL);
* gtk_source_buffer_set_language (buffer, lang);
* </programlisting></informalexample>
*
* or
*
* <informalexample><programlisting>
* GtkSourceLanguage *lang = NULL;
* gboolean result_uncertain;
* gchar *content_type;
*
* content_type = g_content_type_guess (filename, NULL, 0, &result_uncertain);
* if (result_uncertain)
* {
* g_free (content_type);
* content_type = NULL;
* }
*
* lang = gtk_source_language_manager_guess_language (manager, filename, content_type);
* gtk_source_buffer_set_language (buffer, lang);
*
* g_free (content_type);
* </programlisting></informalexample>
*
* etc. Use gtk_source_language_get_mime_types() and gtk_source_language_get_globs()
* if you need full control over file -> language mapping.
*
* Returns: (nullable) (transfer none): a #GtkSourceLanguage, or %NULL if there
* is no suitable language for given @filename and/or @content_type. Return
* value is owned by @lm and should not be freed.
*
* Since: 2.4
*/
GtkSourceLanguage *
gtk_source_language_manager_guess_language (GtkSourceLanguageManager *lm,
const gchar *filename,
const gchar *content_type)
{
GtkSourceLanguage *lang = NULL;
GSList *langs = NULL;
g_return_val_if_fail (GTK_SOURCE_IS_LANGUAGE_MANAGER (lm), NULL);
g_return_val_if_fail ((filename != NULL && *filename != '\0') ||
(content_type != NULL && *content_type != '\0'), NULL);
ensure_languages (lm);
/* Glob take precedence over mime match. Mime match is used in the
following cases:
- to pick among the list of glob matches
- to refine a glob match (e.g. glob is xml and mime is an xml dialect)
- no glob matches
*/
if (filename != NULL && *filename != '\0')
langs = pick_langs_for_filename (lm, filename);
if (langs != NULL)
{
/* Use mime to pick among glob matches */
if (content_type != NULL)
{
GSList *l;
for (l = langs; l != NULL; l = g_slist_next (l))
{
gchar **mime_types, **gptr;
lang = GTK_SOURCE_LANGUAGE (l->data);
mime_types = gtk_source_language_get_mime_types (lang);
for (gptr = mime_types; gptr != NULL && *gptr != NULL; gptr++)
{
gchar *content;
content = g_content_type_from_mime_type (*gptr);
if (content != NULL && g_content_type_is_a (content_type, content))
{
if (!g_content_type_equals (content_type, content))
{
GtkSourceLanguage *mimelang;
mimelang = pick_lang_for_mime_type (lm, content_type);
if (mimelang != NULL)
lang = mimelang;
}
g_strfreev (mime_types);
g_slist_free (langs);
g_free (content);
return lang;
}
g_free (content);
}
g_strfreev (mime_types);
}
}
lang = GTK_SOURCE_LANGUAGE (langs->data);
g_slist_free (langs);
}
/* No glob match */
else if (langs == NULL && content_type != NULL)
{
lang = pick_lang_for_mime_type (lm, content_type);
}
return lang;
}