Debian Codegraph @

geanygendoc/src/ggd-file-type-manager.c

raw
1 /*
2 *
3 * GeanyGenDoc, a Geany plugin to ease generation of source code documentation
4 * Copyright (C) 2010-2011 Colomban Wendling <[email protected]>
5 *
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21
22 #ifdef HAVE_CONFIG_H
23 # include "config.h" /* for the gettext domain */
24 #endif
25
26 #include "ggd-file-type-manager.h"
27
28 #include <glib.h>
29 #include <glib/gi18n-lib.h>
30 #include <geanyplugin.h>
31
32 #include "ggd-plugin.h" /* to be able to use Geany data */
33 #include "ggd-file-type.h"
34 #include "ggd-file-type-loader.h"
35 #include "ggd-utils.h"
36
37
38 /**
39 * SECTION: ggd-file-type-manager
40 * @include ggd-file-type-manager.h
41 *
42 * The file type manager. It manages a set of file type, caching them and
43 * loading them when needed.
44 *
45 * Use ggd_file_type_manager_init() to initialize the file type manager, and
46 * ggd_file_type_manager_uninit() to de-initialize it, releasing the resources
47 * allocated for it. A re-initialization can be done be de-initializing and the
48 * re-initializing the file type manager. This can be useful to e.g. flush the
49 * caches and the for reloading of file types.
50 *
51 * To get a file type from the file type manager, simply use
52 * ggd_file_type_manager_get_file_type(). If the requested file type must be
53 * loaded first, it will be done transparently.
54 */
55
56
57 /* Hash table holding the loaded #GgdFileType<!-- -->s */
58 static GHashTable *GGD_ft_table = NULL;
59
60 /* checks whether the file type manager is initialized */
61 #define ggd_file_type_manager_is_initialized() (GGD_ft_table != NULL)
62
63 /**
64 * ggd_file_type_manager_init:
65 *
66 * Initializes the file type manager. This must be called before any other file
67 * type manager functions.
68 */
69 void
70 ggd_file_type_manager_init (void)
71 {
72 g_return_if_fail (! ggd_file_type_manager_is_initialized ());
73
74 GGD_ft_table = g_hash_table_new_full (g_direct_hash, g_direct_equal,
75 NULL,
76 (GDestroyNotify)ggd_file_type_unref);
77 }
78
79 /**
80 * ggd_file_type_manager_uninit:
81 *
82 * De-initializes the file type manager, releasing memory allocated by it.
83 * It may also be used to force reloading of file type descriptions: simply call
84 * it and then re-initialize it with ggd_file_type_manager_init().
85 */
86 void
87 ggd_file_type_manager_uninit (void)
88 {
89 g_return_if_fail (ggd_file_type_manager_is_initialized ());
90
91 g_hash_table_destroy (GGD_ft_table);
92 GGD_ft_table = NULL;
93 }
94
95 /**
96 * ggd_file_type_manager_add_file_type:
97 * @filetype: A #GgdFileType
98 *
99 * Adds a file type to the file type manager.
100 */
101 void
102 ggd_file_type_manager_add_file_type (GgdFileType *filetype)
103 {
104 g_return_if_fail (ggd_file_type_manager_is_initialized ());
105 g_return_if_fail (filetype != NULL);
106
107 g_hash_table_insert (GGD_ft_table,
108 GINT_TO_POINTER (filetype->geany_ft),
109 ggd_file_type_ref (filetype));
110 }
111
112 /* Same as ggd_file_type_manager_get_conf_path() but uses a #GeanyFiletype and
113 * don't do some safety checks.
114 * Returns filename encoded in GLib file names encoding */
115 static gchar *
116 ggd_file_type_manager_get_conf_path_intern (GeanyFiletype *geany_ft,
117 GgdPerms prems_req,
118 GError **error)
119 {
120 gchar *ft_name_down;
121 gchar *ft_name_conf;
122 gchar *filename;
123
124 ft_name_down = g_ascii_strdown (geany_ft->name, -1);
125 ft_name_conf = g_strconcat (ft_name_down, ".conf", NULL);
126 g_free (ft_name_down);
127 filename = ggd_get_config_file (ft_name_conf, "filetypes", prems_req, error);
128 g_free (ft_name_conf);
129
130 return filename;
131 }
132
133 /**
134 * ggd_file_type_manager_get_conf_path:
135 * @id: The ID of a #GeanyFiletype
136 * @prems_req: Required permissions on the file
137 * @error: Return location for errors, or %NULL to ignore them
138 *
139 * Gets the path to the configuration file of a file type from a given
140 * #GeanyFiletype ID.
141 *
142 * Returns: A newly allocated path to the requested configuration file in the
143 * GLib file names encoding that should be freed with g_free(), or
144 * %NULL on error.
145 */
146 gchar *
147 ggd_file_type_manager_get_conf_path (GeanyFiletypeID id,
148 GgdPerms perms_req,
149 GError **error)
150 {
151 g_return_val_if_fail (id >= 0 && id < geany->filetypes_array->len, NULL);
152
153 return ggd_file_type_manager_get_conf_path_intern (filetypes[id], perms_req,
154 error);
155 }
156
157 /**
158 * ggd_file_type_manager_load_file_type:
159 * @id: A #GeanyFiletype ID
160 *
161 * Loads the #GgdFileType corresponding to a Geany's file type.
162 *
163 * Returns: The loaded #GgdFileType, that should not be unref'd, or %NULL on
164 * failure.
165 */
166 GgdFileType *
167 ggd_file_type_manager_load_file_type (GeanyFiletypeID id)
168 {
169 GeanyFiletype *geany_ft;
170 GgdFileType *ft = NULL;
171 gchar *filename;
172 GError *err = NULL;
173
174 g_return_val_if_fail (ggd_file_type_manager_is_initialized (), NULL);
175 g_return_val_if_fail (id >= 0 && id < geany->filetypes_array->len, NULL);
176
177 geany_ft = filetypes[id];
178 filename = ggd_file_type_manager_get_conf_path_intern (geany_ft, GGD_PERM_R,
179 &err);
180 if (! filename) {
181 msgwin_status_add (_("File type configuration file for language \"%s\" not "
182 "found: %s"),
183 geany_ft->name, err->message);
184 g_error_free (err);
185 } else {
186 ft = ggd_file_type_new (id);
187 if (! ggd_file_type_load (ft, filename, &err)) {
188 gchar *display_filename;
189
190 display_filename = g_filename_display_name (filename);
191 msgwin_status_add (_("Failed to load file type \"%s\" from file \"%s\": "
192 "%s"),
193 geany_ft->name, display_filename, err->message);
194 g_free (display_filename);
195 g_error_free (err);
196 ggd_file_type_unref (ft), ft = NULL;
197 } else {
198 ggd_file_type_manager_add_file_type (ft);
199 ggd_file_type_unref (ft);
200 }
201 g_free (filename);
202 }
203
204 return ft;
205 }
206
207 /**
208 * ggd_file_type_manager_get_file_type:
209 * @id: A #GeanyFiletype ID
210 *
211 * Gets a #GgdFileType from the file type manager by its Geany's file type ID.
212 * If the file type isn't already known, it will be transparently loaded.
213 *
214 * Returns: A #GgdFileType that shouldn't be unref'd, or %NULL if the requested
215 * file type neither can be found on the loaded file type nor can be
216 * loaded.
217 */
218 GgdFileType *
219 ggd_file_type_manager_get_file_type (GeanyFiletypeID id)
220 {
221 GgdFileType *ft;
222
223 g_return_val_if_fail (ggd_file_type_manager_is_initialized (), NULL);
224
225 ft = g_hash_table_lookup (GGD_ft_table, GINT_TO_POINTER (id));
226 if (! ft) {
227 /* if the filetype isn't loaded, try to load it
228 * FIXME: it might be useful to have a way to know if a filetype loading
229 * had already failed not to retry again and again on each query? */
230 ft = ggd_file_type_manager_load_file_type (id);
231 }
232
233 return ft;
234 }
235
236 /**
237 * ggd_file_type_manager_get_doc_type:
238 * @ft: A #GeanyFiletype ID
239 * @docname: The documentation type identifier
240 *
241 * Gets the #GgdDocType for a file type and a documentation type identifier.
242 *
243 * Returns: The #GgdDocType corresponding to the file and documentation type,
244 * or %NULL on failure.
245 */
246 GgdDocType *
247 ggd_file_type_manager_get_doc_type (GeanyFiletypeID ft,
248 const gchar *docname)
249 {
250 GgdDocType *doctype = NULL;
251 GgdFileType *filetype;
252
253 filetype = ggd_file_type_manager_get_file_type (ft);
254 if (filetype) {
255 doctype = ggd_file_type_get_doc (filetype, docname);
256 }
257
258 return doctype;
259 }