2 * filetypes.c - this file is part of Geany, a fast and lightweight IDE
4 * Copyright 2005 The Geany contributors
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 2 of the License, or
9 * (at your option) any later version.
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.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23 * Filetype detection, file extensions and filetype menu items.
26 /* Note: we use GeanyFiletypeID for some function arguments, but GeanyFiletype is better; we should
27 * only use GeanyFiletype for API functions. */
33 #include "filetypes.h"
36 #include "callbacks.h" /* FIXME: for ignore_callback */
38 #include "filetypesprivate.h"
40 #include "geanyobject.h"
41 #include "highlighting.h"
42 #include "projectprivate.h"
43 #include "sciwrappers.h"
46 #include "tm_parser.h"
53 #include <glib/gstdio.h>
55 #define GEANY_FILETYPE_SEARCH_LINES 2 /* lines of file to search for filetype */
57 GPtrArray
*filetypes_array
= NULL
;
58 static GHashTable
*filetypes_hash
= NULL
; /* Hash of filetype pointers based on name keys */
59 GSList
*filetypes_by_title
= NULL
;
62 static void create_radio_menu_item(GtkWidget
*menu
, GeanyFiletype
*ftype
);
64 static gchar
*filetypes_get_conf_extension(const GeanyFiletype
*ft
);
65 static void read_filetype_config(void);
66 static void create_set_filetype_menu(gboolean config
);
67 static gchar
*filetypes_get_filename(GeanyFiletype
*ft
, gboolean user
);
79 /* Save adding many translation strings if the filetype name doesn't need translating */
80 static gchar
*filetype_make_title(const char *name
, enum TitleType type
)
82 g_return_val_if_fail(name
!= NULL
, NULL
);
86 case TITLE_SOURCE_FILE
: return g_strdup_printf(_("%s source file"), name
);
87 case TITLE_FILE
: return g_strdup_printf(_("%s file"), name
);
88 case TITLE_SCRIPT
: return g_strdup_printf(_("%s script"), name
);
89 case TITLE_DOCUMENT
: return g_strdup_printf(_("%s document"), name
);
90 case TITLE_NONE
: /* fall through */
91 default: return g_strdup(name
);
96 /* name argument (ie filetype name) must not be translated as it is used for
97 * filetype lookup. Use filetypes_get_display_name() instead.*/
98 static void ft_init(GeanyFiletypeID ft_id
, TMParserType lang
, const char *name
,
99 const char *title_name
, enum TitleType title_type
,
100 GeanyFiletypeGroupID group_id
)
102 GeanyFiletype
*ft
= filetypes
[ft_id
];
104 ft
->name
= g_strdup(name
);
105 ft
->title
= filetype_make_title((title_name
!= NULL
) ? title_name
: ft
->name
, title_type
);
106 ft
->group
= group_id
;
109 /* Evil macro to save typing and make init_builtin_filetypes() more readable */
110 #define FT_INIT(ft_id, parser_id, name, title_name, title_type, group_id) \
111 ft_init(GEANY_FILETYPES_##ft_id, TM_PARSER_##parser_id, name, title_name, \
112 TITLE_##title_type, GEANY_FILETYPE_GROUP_##group_id)
115 /* Note: remember to update HACKING if this function is renamed. */
116 static void init_builtin_filetypes(void)
119 * [0] = Filetype constant (GEANY_FILETYPES_*)
120 * [1] = CTags parser (TM_PARSER_*)
121 * [2] = Non-translated filetype name (*not* label for display)
122 * [3] = Translatable human filetype title prefix or NULL to use [2]
123 * [4] = Title type (TITLE_*) constant (ex. TITLE_SOURCE_FILE is 'source file' suffix)
124 * [5] = The filetype group constant (GEANY_FILETYPE_GROUP_*)
125 * --------------------------------------------------------------------------------------------------------------------------
126 * [0] [1] [2] [3] [4] [5] */
127 FT_INIT( NONE
, NONE
, "None", _("None"), NONE
, NONE
);
128 FT_INIT( C
, C
, "C", NULL
, SOURCE_FILE
, COMPILED
);
129 FT_INIT( CPP
, CPP
, "C++", NULL
, SOURCE_FILE
, COMPILED
);
130 FT_INIT( OBJECTIVEC
, OBJC
, "Objective-C", NULL
, SOURCE_FILE
, COMPILED
);
131 FT_INIT( CS
, CSHARP
, "C#", NULL
, SOURCE_FILE
, COMPILED
);
132 FT_INIT( VALA
, VALA
, "Vala", NULL
, SOURCE_FILE
, COMPILED
);
133 FT_INIT( D
, D
, "D", NULL
, SOURCE_FILE
, COMPILED
);
134 FT_INIT( JAVA
, JAVA
, "Java", NULL
, SOURCE_FILE
, COMPILED
);
135 FT_INIT( PASCAL
, PASCAL
, "Pascal", NULL
, SOURCE_FILE
, COMPILED
);
136 FT_INIT( ASM
, ASM
, "ASM", "Assembler", SOURCE_FILE
, COMPILED
);
137 FT_INIT( BASIC
, FREEBASIC
, "FreeBasic", NULL
, SOURCE_FILE
, COMPILED
);
138 FT_INIT( FORTRAN
, FORTRAN
, "Fortran", "Fortran (F90)", SOURCE_FILE
, COMPILED
);
139 FT_INIT( F77
, F77
, "F77", "Fortran (F77)", SOURCE_FILE
, COMPILED
);
140 FT_INIT( GLSL
, GLSL
, "GLSL", NULL
, SOURCE_FILE
, COMPILED
);
141 FT_INIT( CAML
, NONE
, "CAML", "(O)Caml", SOURCE_FILE
, COMPILED
);
142 FT_INIT( PERL
, PERL
, "Perl", NULL
, SOURCE_FILE
, SCRIPT
);
143 FT_INIT( PHP
, PHP
, "PHP", NULL
, SOURCE_FILE
, SCRIPT
);
144 FT_INIT( JS
, JAVASCRIPT
, "Javascript", NULL
, SOURCE_FILE
, SCRIPT
);
145 FT_INIT( PYTHON
, PYTHON
, "Python", NULL
, SOURCE_FILE
, SCRIPT
);
146 FT_INIT( RUBY
, RUBY
, "Ruby", NULL
, SOURCE_FILE
, SCRIPT
);
147 FT_INIT( TCL
, TCL
, "Tcl", NULL
, SOURCE_FILE
, SCRIPT
);
148 FT_INIT( LUA
, LUA
, "Lua", NULL
, SOURCE_FILE
, SCRIPT
);
149 FT_INIT( FERITE
, NONE
, "Ferite", NULL
, SOURCE_FILE
, SCRIPT
);
150 FT_INIT( HASKELL
, HASKELL
, "Haskell", NULL
, SOURCE_FILE
, COMPILED
);
151 FT_INIT( MARKDOWN
, MARKDOWN
, "Markdown", NULL
, SOURCE_FILE
, MARKUP
);
152 FT_INIT( TXT2TAGS
, TXT2TAGS
, "Txt2tags", NULL
, SOURCE_FILE
, MARKUP
);
153 FT_INIT( ABC
, ABC
, "Abc", NULL
, FILE, MISC
);
154 FT_INIT( SH
, SH
, "Sh", _("Shell"), SCRIPT
, SCRIPT
);
155 FT_INIT( MAKE
, MAKEFILE
, "Make", _("Makefile"), NONE
, SCRIPT
);
156 FT_INIT( XML
, NONE
, "XML", NULL
, DOCUMENT
, MARKUP
);
157 FT_INIT( DOCBOOK
, DOCBOOK
, "Docbook", NULL
, DOCUMENT
, MARKUP
);
158 FT_INIT( HTML
, HTML
, "HTML", NULL
, DOCUMENT
, MARKUP
);
159 FT_INIT( CSS
, CSS
, "CSS", _("Cascading Stylesheet"), NONE
, MARKUP
); /* not really markup but fit quite well to HTML */
160 FT_INIT( SQL
, SQL
, "SQL", NULL
, FILE, MISC
);
161 FT_INIT( COBOL
, COBOL
, "COBOL", NULL
, SOURCE_FILE
, COMPILED
);
162 FT_INIT( LATEX
, LATEX
, "LaTeX", NULL
, SOURCE_FILE
, MARKUP
);
163 FT_INIT( BIBTEX
, BIBTEX
, "BibTeX", NULL
, SOURCE_FILE
, MARKUP
);
164 FT_INIT( VHDL
, VHDL
, "VHDL", NULL
, SOURCE_FILE
, COMPILED
);
165 FT_INIT( VERILOG
, VERILOG
, "Verilog", NULL
, SOURCE_FILE
, COMPILED
);
166 FT_INIT( DIFF
, DIFF
, "Diff", NULL
, FILE, MISC
);
167 FT_INIT( LISP
, NONE
, "Lisp", NULL
, SOURCE_FILE
, SCRIPT
);
168 FT_INIT( ERLANG
, ERLANG
, "Erlang", NULL
, SOURCE_FILE
, COMPILED
);
169 FT_INIT( CONF
, CONF
, "Conf", _("Config"), FILE, MISC
);
170 FT_INIT( PO
, NONE
, "Po", _("Gettext translation"), FILE, MISC
);
171 FT_INIT( HAXE
, HAXE
, "Haxe", NULL
, SOURCE_FILE
, COMPILED
);
172 FT_INIT( AS
, ACTIONSCRIPT
, "ActionScript", NULL
, SOURCE_FILE
, SCRIPT
);
173 FT_INIT( R
, R
, "R", NULL
, SOURCE_FILE
, SCRIPT
);
174 FT_INIT( REST
, REST
, "reStructuredText", NULL
, SOURCE_FILE
, MARKUP
);
175 FT_INIT( MATLAB
, MATLAB
, "Matlab/Octave", NULL
, SOURCE_FILE
, SCRIPT
);
176 FT_INIT( YAML
, NONE
, "YAML", NULL
, FILE, MISC
);
177 FT_INIT( CMAKE
, NONE
, "CMake", NULL
, SOURCE_FILE
, SCRIPT
);
178 FT_INIT( NSIS
, NSIS
, "NSIS", NULL
, SOURCE_FILE
, SCRIPT
);
179 FT_INIT( ADA
, NONE
, "Ada", NULL
, SOURCE_FILE
, COMPILED
);
180 FT_INIT( FORTH
, NONE
, "Forth", NULL
, SOURCE_FILE
, SCRIPT
);
181 FT_INIT( ASCIIDOC
, ASCIIDOC
, "Asciidoc", NULL
, SOURCE_FILE
, MARKUP
);
182 FT_INIT( ABAQUS
, ABAQUS
, "Abaqus", NULL
, SOURCE_FILE
, SCRIPT
);
183 FT_INIT( BATCH
, NONE
, "Batch", NULL
, SCRIPT
, SCRIPT
);
184 FT_INIT( POWERSHELL
, POWERSHELL
, "PowerShell", NULL
, SOURCE_FILE
, SCRIPT
);
185 FT_INIT( RUST
, RUST
, "Rust", NULL
, SOURCE_FILE
, COMPILED
);
186 FT_INIT( COFFEESCRIPT
, NONE
, "CoffeeScript", NULL
, SOURCE_FILE
, SCRIPT
);
187 FT_INIT( GO
, GO
, "Go", NULL
, SOURCE_FILE
, COMPILED
);
188 FT_INIT( ZEPHIR
, ZEPHIR
, "Zephir", NULL
, SOURCE_FILE
, COMPILED
);
189 FT_INIT( SMALLTALK
, NONE
, "Smalltalk", NULL
, SOURCE_FILE
, SCRIPT
);
190 FT_INIT( JULIA
, JULIA
, "Julia", NULL
, SOURCE_FILE
, SCRIPT
);
191 FT_INIT( GDSCRIPT
, GDSCRIPT
, "GDScript", NULL
, SOURCE_FILE
, SCRIPT
);
195 /* initialize fields. */
196 static GeanyFiletype
*filetype_new(void)
198 GeanyFiletype
*ft
= g_new0(GeanyFiletype
, 1);
200 ft
->group
= GEANY_FILETYPE_GROUP_NONE
;
201 ft
->lang
= TM_PARSER_NONE
; /* assume no tagmanager parser */
202 /* pattern must not be null */
203 ft
->pattern
= g_new0(gchar
*, 1);
204 ft
->indent_width
= -1;
205 ft
->indent_type
= -1;
207 ft
->priv
= g_new0(GeanyFiletypePrivate
, 1);
208 ft
->priv
->project_list_entry
= -1; /* no entry */
214 static gint
cmp_filetype(gconstpointer pft1
, gconstpointer pft2
, gpointer data
)
216 gboolean by_name
= GPOINTER_TO_INT(data
);
217 const GeanyFiletype
*ft1
= pft1
, *ft2
= pft2
;
219 if (G_UNLIKELY(ft1
->id
== GEANY_FILETYPES_NONE
))
221 if (G_UNLIKELY(ft2
->id
== GEANY_FILETYPES_NONE
))
225 utils_str_casecmp(ft1
->name
, ft2
->name
) :
226 utils_str_casecmp(ft1
->title
, ft2
->title
);
230 /** Gets a list of filetype pointers sorted by name.
231 * The list does not change on subsequent calls.
232 * @return @elementtype{GeanyFiletype} @transfer{none} The list - do not free.
233 * @see filetypes_by_title. */
235 const GSList
*filetypes_get_sorted_by_name(void)
237 static GSList
*list
= NULL
;
239 g_return_val_if_fail(filetypes_by_title
, NULL
);
243 list
= g_slist_copy(filetypes_by_title
);
244 list
= g_slist_sort_with_data(list
, cmp_filetype
, GINT_TO_POINTER(TRUE
));
250 /* Add a filetype pointer to the lists of available filetypes,
251 * and set the filetype::id field. */
252 static void filetype_add(GeanyFiletype
*ft
)
254 g_return_if_fail(ft
);
255 g_return_if_fail(ft
->name
);
257 ft
->id
= filetypes_array
->len
; /* len will be the index for filetype_array */
258 g_ptr_array_add(filetypes_array
, ft
);
259 g_hash_table_insert(filetypes_hash
, ft
->name
, ft
);
261 /* list will be sorted later */
262 filetypes_by_title
= g_slist_prepend(filetypes_by_title
, ft
);
266 static void add_custom_filetype(const gchar
*filename
)
268 gchar
*fn
= utils_strdupa(strstr(filename
, ".") + 1);
269 gchar
*dot
= g_strrstr(fn
, ".conf");
272 g_return_if_fail(dot
);
276 if (g_hash_table_lookup(filetypes_hash
, fn
))
280 ft
->name
= g_strdup(fn
);
281 ft
->title
= filetype_make_title(ft
->name
, TITLE_FILE
);
282 ft
->priv
->custom
= TRUE
;
284 geany_debug("Added filetype %s (%d).", ft
->name
, ft
->id
);
288 static void init_custom_filetypes(const gchar
*path
)
291 const gchar
*filename
;
293 g_return_if_fail(path
);
295 dir
= g_dir_open(path
, 0, NULL
);
299 foreach_dir(filename
, dir
)
301 const gchar prefix
[] = "filetypes.";
303 if (g_str_has_prefix(filename
, prefix
) &&
304 g_str_has_suffix(filename
+ strlen(prefix
), ".conf"))
306 add_custom_filetype(filename
);
313 /* Create the filetypes array and fill it with the known filetypes.
314 * Warning: GTK isn't necessarily initialized yet. */
315 void filetypes_init_types(void)
317 GeanyFiletypeID ft_id
;
320 g_return_if_fail(filetypes_array
== NULL
);
321 g_return_if_fail(filetypes_hash
== NULL
);
323 filetypes_array
= g_ptr_array_sized_new(GEANY_MAX_BUILT_IN_FILETYPES
);
324 filetypes_hash
= g_hash_table_new(g_str_hash
, g_str_equal
);
326 /* Create built-in filetypes */
327 for (ft_id
= 0; ft_id
< GEANY_MAX_BUILT_IN_FILETYPES
; ft_id
++)
329 filetypes
[ft_id
] = filetype_new();
331 init_builtin_filetypes();
333 /* Add built-in filetypes to the hash now the name fields are set */
334 for (ft_id
= 0; ft_id
< GEANY_MAX_BUILT_IN_FILETYPES
; ft_id
++)
336 filetype_add(filetypes
[ft_id
]);
338 f
= g_build_filename(app
->datadir
, GEANY_FILEDEFS_SUBDIR
, NULL
);
339 init_custom_filetypes(f
);
341 f
= g_build_filename(app
->configdir
, GEANY_FILEDEFS_SUBDIR
, NULL
);
342 init_custom_filetypes(f
);
345 /* sort last instead of on insertion to prevent exponential time */
346 filetypes_by_title
= g_slist_sort_with_data(filetypes_by_title
,
347 cmp_filetype
, GINT_TO_POINTER(FALSE
));
349 read_filetype_config();
353 static void on_document_save(G_GNUC_UNUSED GObject
*object
, GeanyDocument
*doc
)
357 g_return_if_fail(!EMPTY(doc
->real_path
));
359 f
= g_build_filename(app
->configdir
, "filetype_extensions.conf", NULL
);
360 if (utils_str_equal(doc
->real_path
, f
))
361 filetypes_reload_extensions();
364 basename
= g_path_get_basename(doc
->real_path
);
365 if (g_str_has_prefix(basename
, "filetypes."))
369 for (i
= 0; i
< filetypes_array
->len
; i
++)
371 GeanyFiletype
*ft
= filetypes
[i
];
373 f
= filetypes_get_filename(ft
, TRUE
);
374 if (utils_str_equal(doc
->real_path
, f
))
378 /* Note: we don't reload other filetypes, even though the named styles may have changed.
379 * The user can do this manually with 'Tools->Reload Configuration' */
380 filetypes_load_config(i
, TRUE
);
383 document_reload_config(documents
[j
]);
395 static void setup_config_file_menus(void)
399 f
= g_build_filename(app
->configdir
, "filetype_extensions.conf", NULL
);
400 ui_add_config_file_menu_item(f
, NULL
, NULL
);
401 SETPTR(f
, g_build_filename(app
->configdir
, GEANY_FILEDEFS_SUBDIR
, "filetypes.common", NULL
));
402 ui_add_config_file_menu_item(f
, NULL
, NULL
);
405 create_set_filetype_menu(TRUE
);
407 g_signal_connect(geany_object
, "document-save", G_CALLBACK(on_document_save
), NULL
);
411 static GtkWidget
*create_sub_menu(GtkWidget
*parent
, const gchar
*title
)
413 GtkWidget
*menu
, *item
;
415 menu
= gtk_menu_new();
416 item
= gtk_menu_item_new_with_mnemonic((title
));
417 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item
), menu
);
418 gtk_container_add(GTK_CONTAINER(parent
), item
);
419 gtk_widget_show(item
);
425 static void create_set_filetype_menu(gboolean config
)
427 GtkWidget
*group_menus
[GEANY_FILETYPE_GROUP_COUNT
] = {NULL
};
431 menu
= config
? ui_widgets
.config_files_filetype_menu
:
432 ui_lookup_widget(main_widgets
.window
, "set_filetype1_menu");
434 group_menus
[GEANY_FILETYPE_GROUP_COMPILED
] = create_sub_menu(menu
, _("_Programming Languages"));
435 group_menus
[GEANY_FILETYPE_GROUP_SCRIPT
] = create_sub_menu(menu
, _("_Scripting Languages"));
436 group_menus
[GEANY_FILETYPE_GROUP_MARKUP
] = create_sub_menu(menu
, _("_Markup Languages"));
437 group_menus
[GEANY_FILETYPE_GROUP_MISC
] = create_sub_menu(menu
, _("M_iscellaneous"));
439 /* Append all filetypes to the menu */
440 foreach_slist(node
, filetypes_by_title
)
442 GeanyFiletype
*ft
= node
->data
;
443 GtkWidget
*parent
= (ft
->group
!= GEANY_FILETYPE_GROUP_NONE
) ? group_menus
[ft
->group
] : menu
;
445 /* we already have filetypes.common config entry */
446 if (config
&& ft
->id
== GEANY_FILETYPES_NONE
)
451 gchar
*filename
= filetypes_get_filename(ft
, TRUE
);
453 ui_add_config_file_menu_item(filename
, NULL
, GTK_CONTAINER(parent
));
457 create_radio_menu_item(parent
, ft
);
462 void filetypes_init(void)
464 filetypes_init_types();
465 create_set_filetype_menu(FALSE
);
466 setup_config_file_menus();
470 static guint
match_basename(const GeanyFiletype
*ft
, const gchar
*base_filename
)
472 if (G_UNLIKELY(ft
->id
== GEANY_FILETYPES_NONE
))
475 for (guint j
= 0; ft
->pattern
[j
] != NULL
; j
++)
477 gchar
*pat
= ft
->pattern
[j
];
479 if (g_pattern_match_simple(pat
, base_filename
))
488 static GeanyFiletype
*detect_filetype_conf_file(const gchar
*utf8_filename
)
492 gboolean found
= FALSE
;
495 /* use lower case basename */
496 lfn
= g_utf8_strdown(utf8_filename
, -1);
498 lfn
= g_strdup(utf8_filename
);
500 SETPTR(lfn
, utils_get_locale_from_utf8(lfn
));
502 path
= g_build_filename(app
->configdir
, GEANY_FILEDEFS_SUBDIR
, "filetypes.", NULL
);
503 if (g_str_has_prefix(lfn
, path
))
506 SETPTR(path
, g_build_filename(app
->datadir
, GEANY_FILEDEFS_SUBDIR
, "filetypes.", NULL
));
507 if (g_str_has_prefix(lfn
, path
))
512 return found
? filetypes
[GEANY_FILETYPES_CONF
] : NULL
;
516 /* Detect filetype only based on the filename extension.
517 * utf8_filename can include the full path. */
518 GeanyFiletype
*filetypes_detect_from_extension(const gchar
*utf8_filename
)
520 gchar
*base_filename
;
524 ft
= detect_filetype_conf_file(utf8_filename
);
528 /* to match against the basename of the file (because of Makefile*) */
529 base_filename
= g_path_get_basename(utf8_filename
);
531 /* use lower case basename */
532 SETPTR(base_filename
, g_utf8_strdown(base_filename
, -1));
535 for (guint i
= 0; i
< filetypes_array
->len
; i
++)
537 guint mlen
= match_basename(filetypes
[i
], base_filename
);
540 { // longest pattern match wins
544 else if (mlen
== plen
&& ft
&& !ft
->priv
->user_extensions
&&
545 filetypes
[i
]->priv
->user_extensions
)
546 { // user config overrides system if pattern len same
551 ft
= filetypes
[GEANY_FILETYPES_NONE
];
553 g_free(base_filename
);
558 /* This detects the filetype of the file pointed by 'utf8_filename' and a list of filetype id's,
560 * The detected filetype of the file is checked against every id in the passed list and if
561 * there is a match, TRUE is returned. */
562 static gboolean
shebang_find_and_match_filetype(const gchar
*utf8_filename
, gint first
, ...)
564 GeanyFiletype
*ft
= NULL
;
566 gboolean result
= FALSE
;
569 ft
= filetypes_detect_from_extension(utf8_filename
);
570 if (ft
== NULL
|| ft
->id
>= filetypes_array
->len
)
573 va_start(args
, first
);
580 if (ft
->id
== (guint
) test
)
585 test
= va_arg(args
, gint
);
593 static GeanyFiletype
*find_shebang(const gchar
*utf8_filename
, const gchar
*line
)
595 GeanyFiletype
*ft
= NULL
;
597 if (strlen(line
) > 2 && line
[0] == '#' && line
[1] == '!')
599 static const struct {
601 GeanyFiletypeID filetype
;
602 } intepreter_map
[] = {
603 { "sh", GEANY_FILETYPES_SH
},
604 { "bash", GEANY_FILETYPES_SH
},
605 { "dash", GEANY_FILETYPES_SH
},
606 { "perl", GEANY_FILETYPES_PERL
},
607 { "python", GEANY_FILETYPES_PYTHON
},
608 { "php", GEANY_FILETYPES_PHP
},
609 { "ruby", GEANY_FILETYPES_RUBY
},
610 { "tcl", GEANY_FILETYPES_TCL
},
611 { "make", GEANY_FILETYPES_MAKE
},
612 { "zsh", GEANY_FILETYPES_SH
},
613 { "ksh", GEANY_FILETYPES_SH
},
614 { "mksh", GEANY_FILETYPES_SH
},
615 { "csh", GEANY_FILETYPES_SH
},
616 { "tcsh", GEANY_FILETYPES_SH
},
617 { "ash", GEANY_FILETYPES_SH
},
618 { "dmd", GEANY_FILETYPES_D
},
619 { "wish", GEANY_FILETYPES_TCL
},
620 { "node", GEANY_FILETYPES_JS
},
621 { "rust", GEANY_FILETYPES_RUST
}
623 gchar
*tmp
= g_path_get_basename(line
+ 2);
624 gchar
*basename_interpreter
= tmp
;
627 if (g_str_has_prefix(tmp
, "env "))
628 { /* skip "env" and read the following interpreter */
629 basename_interpreter
+= 4;
632 for (i
= 0; ! ft
&& i
< G_N_ELEMENTS(intepreter_map
); i
++)
634 if (g_str_has_prefix(basename_interpreter
, intepreter_map
[i
].name
))
635 ft
= filetypes
[intepreter_map
[i
].filetype
];
639 /* detect HTML files */
640 if (g_str_has_prefix(line
, "<!DOCTYPE html") || g_str_has_prefix(line
, "<html"))
642 /* PHP, Perl and Python files might also start with <html, so detect them based on filename
643 * extension and use the detected filetype, else assume HTML */
644 if (! shebang_find_and_match_filetype(utf8_filename
,
645 GEANY_FILETYPES_PERL
, GEANY_FILETYPES_PHP
, GEANY_FILETYPES_PYTHON
, -1))
647 ft
= filetypes
[GEANY_FILETYPES_HTML
];
650 /* detect XML files */
651 else if (utf8_filename
&& g_str_has_prefix(line
, "<?xml"))
653 /* HTML and DocBook files might also start with <?xml, so detect them based on filename
654 * extension and use the detected filetype, else assume XML */
655 if (! shebang_find_and_match_filetype(utf8_filename
,
656 GEANY_FILETYPES_HTML
, GEANY_FILETYPES_DOCBOOK
,
657 /* Perl, Python and PHP only to be safe */
658 GEANY_FILETYPES_PERL
, GEANY_FILETYPES_PHP
, GEANY_FILETYPES_PYTHON
, -1))
660 ft
= filetypes
[GEANY_FILETYPES_XML
];
663 else if (g_str_has_prefix(line
, "<?php"))
665 ft
= filetypes
[GEANY_FILETYPES_PHP
];
671 /* Detect the filetype checking for a shebang, then filename extension.
672 * @lines: an strv of the lines to scan (must containing at least one line) */
673 static GeanyFiletype
*filetypes_detect_from_file_internal(const gchar
*utf8_filename
,
680 GError
*regex_error
= NULL
;
682 /* try to find a shebang and if found use it prior to the filename extension
683 * also checks for <?xml */
684 ft
= find_shebang(utf8_filename
, lines
[0]);
688 /* try to extract the filetype using a regex capture */
689 ft_regex
= g_regex_new(file_prefs
.extract_filetype_regex
,
690 G_REGEX_RAW
| G_REGEX_MULTILINE
, 0, ®ex_error
);
691 if (ft_regex
!= NULL
)
693 for (i
= 0; ft
== NULL
&& lines
[i
] != NULL
; i
++)
695 if (g_regex_match(ft_regex
, lines
[i
], 0, &match
))
697 gchar
*capture
= g_match_info_fetch(match
, 1);
700 ft
= filetypes_lookup_by_name(capture
);
704 g_match_info_free(match
);
706 g_regex_unref(ft_regex
);
708 else if (regex_error
!= NULL
)
710 geany_debug("Filetype extract regex ignored: %s", regex_error
->message
);
711 g_error_free(regex_error
);
716 if (utf8_filename
== NULL
)
717 return filetypes
[GEANY_FILETYPES_NONE
];
719 return filetypes_detect_from_extension(utf8_filename
);
723 /* Detect the filetype for the document, checking for a shebang, then filename extension. */
724 GeanyFiletype
*filetypes_detect_from_document(GeanyDocument
*doc
)
727 gchar
*lines
[GEANY_FILETYPE_SEARCH_LINES
+ 1];
730 g_return_val_if_fail(doc
== NULL
|| doc
->is_valid
, filetypes
[GEANY_FILETYPES_NONE
]);
733 return filetypes
[GEANY_FILETYPES_NONE
];
735 for (i
= 0; i
< GEANY_FILETYPE_SEARCH_LINES
; ++i
)
737 lines
[i
] = sci_get_line(doc
->editor
->sci
, i
);
740 ft
= filetypes_detect_from_file_internal(doc
->file_name
, lines
);
741 for (i
= 0; i
< GEANY_FILETYPE_SEARCH_LINES
; ++i
)
750 /* Currently only used by external plugins (e.g. geanyprj). */
752 * Detects filetype based on a shebang line in the file or the filename extension.
754 * @param utf8_filename The filename in UTF-8 encoding.
756 * @return @transfer{none} The detected filetype for @a utf8_filename or
757 * @c filetypes[GEANY_FILETYPES_NONE] if it could not be detected.
760 GeanyFiletype
*filetypes_detect_from_file(const gchar
*utf8_filename
)
765 gchar
*locale_name
= utils_get_locale_from_utf8(utf8_filename
);
767 f
= g_fopen(locale_name
, "r");
771 if (fgets(line
, sizeof(line
), f
) != NULL
)
776 return filetypes_detect_from_file_internal(utf8_filename
, lines
);
780 return filetypes_detect_from_extension(utf8_filename
);
785 void filetypes_select_radio_item(const GeanyFiletype
*ft
)
787 /* ignore_callback has to be set by the caller */
788 g_return_if_fail(ignore_callback
);
791 ft
= filetypes
[GEANY_FILETYPES_NONE
];
793 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ft
->priv
->menu_item
), TRUE
);
798 on_filetype_change(GtkCheckMenuItem
*menuitem
, gpointer user_data
)
800 GeanyDocument
*doc
= document_get_current();
801 if (ignore_callback
|| doc
== NULL
|| ! gtk_check_menu_item_get_active(menuitem
))
804 document_set_filetype(doc
, (GeanyFiletype
*)user_data
);
808 static void create_radio_menu_item(GtkWidget
*menu
, GeanyFiletype
*ftype
)
810 static GSList
*group
= NULL
;
813 tmp
= gtk_radio_menu_item_new_with_label(group
, ftype
->title
);
814 group
= gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(tmp
));
815 ftype
->priv
->menu_item
= tmp
;
816 gtk_widget_show(tmp
);
817 gtk_container_add(GTK_CONTAINER(menu
), tmp
);
818 g_signal_connect(tmp
, "activate", G_CALLBACK(on_filetype_change
), (gpointer
) ftype
);
822 static void filetype_free(gpointer data
, G_GNUC_UNUSED gpointer user_data
)
824 GeanyFiletype
*ft
= data
;
826 g_return_if_fail(ft
!= NULL
);
830 g_free(ft
->extension
);
831 g_free(ft
->mime_type
);
832 g_free(ft
->comment_open
);
833 g_free(ft
->comment_close
);
834 g_free(ft
->comment_single
);
835 g_free(ft
->context_action_cmd
);
836 g_free(ft
->priv
->filecmds
);
837 g_free(ft
->priv
->ftdefcmds
);
838 g_free(ft
->priv
->execcmds
);
839 g_free(ft
->error_regex_string
);
841 g_object_unref(ft
->icon
);
842 g_strfreev(ft
->pattern
);
844 if (ft
->priv
->error_regex
)
845 g_regex_unref(ft
->priv
->error_regex
);
846 g_slist_foreach(ft
->priv
->tag_files
, (GFunc
) g_free
, NULL
);
847 g_slist_free(ft
->priv
->tag_files
);
854 /* frees the array and all related pointers */
855 void filetypes_free_types(void)
857 g_return_if_fail(filetypes_array
!= NULL
);
858 g_return_if_fail(filetypes_hash
!= NULL
);
860 g_ptr_array_foreach(filetypes_array
, filetype_free
, NULL
);
861 g_ptr_array_free(filetypes_array
, TRUE
);
862 g_hash_table_destroy(filetypes_hash
);
866 static void load_indent_settings(GeanyFiletype
*ft
, GKeyFile
*config
, GKeyFile
*configh
)
868 ft
->indent_width
= utils_get_setting(integer
, configh
, config
, "indentation", "width", -1);
869 ft
->indent_type
= utils_get_setting(integer
, configh
, config
, "indentation", "type", -1);
870 /* check whether the indent type is OK */
871 switch (ft
->indent_type
)
873 case GEANY_INDENT_TYPE_TABS
:
874 case GEANY_INDENT_TYPE_SPACES
:
875 case GEANY_INDENT_TYPE_BOTH
:
880 g_warning("Invalid indent type %d in file type %s", ft
->indent_type
, ft
->name
);
881 ft
->indent_type
= -1;
887 static void load_settings(guint ft_id
, GKeyFile
*config
, GKeyFile
*configh
)
889 GeanyFiletype
*ft
= filetypes
[ft_id
];
892 /* default extension */
893 result
= utils_get_setting(string
, configh
, config
, "settings", "extension", NULL
);
896 SETPTR(filetypes
[ft_id
]->extension
, result
);
900 result
= utils_get_setting(string
, configh
, config
, "settings", "mime_type", "text/plain");
901 SETPTR(filetypes
[ft_id
]->mime_type
, result
);
903 /* read comment notes */
904 result
= utils_get_setting(string
, configh
, config
, "settings", "comment_open", NULL
);
907 SETPTR(filetypes
[ft_id
]->comment_open
, result
);
910 result
= utils_get_setting(string
, configh
, config
, "settings", "comment_close", NULL
);
913 SETPTR(filetypes
[ft_id
]->comment_close
, result
);
916 result
= utils_get_setting(string
, configh
, config
, "settings", "comment_single", NULL
);
919 SETPTR(filetypes
[ft_id
]->comment_single
, result
);
921 /* import correctly filetypes that use old-style single comments */
922 else if (EMPTY(filetypes
[ft_id
]->comment_close
))
924 SETPTR(filetypes
[ft_id
]->comment_single
, filetypes
[ft_id
]->comment_open
);
925 filetypes
[ft_id
]->comment_open
= NULL
;
928 filetypes
[ft_id
]->comment_use_indent
= utils_get_setting(boolean
, configh
, config
,
929 "settings", "comment_use_indent", FALSE
);
931 /* read context action */
932 result
= utils_get_setting(string
, configh
, config
, "settings", "context_action_cmd", NULL
);
935 SETPTR(filetypes
[ft_id
]->context_action_cmd
, result
);
938 result
= utils_get_setting(string
, configh
, config
, "settings", "tag_parser", NULL
);
941 ft
->lang
= tm_source_file_get_named_lang(result
);
942 if (ft
->lang
== TM_PARSER_NONE
)
943 geany_debug("Cannot find tags parser '%s' for custom filetype '%s'.", result
, ft
->name
);
947 result
= utils_get_setting(string
, configh
, config
, "settings", "lexer_filetype", NULL
);
950 ft
->lexer_filetype
= filetypes_lookup_by_name(result
);
951 if (!ft
->lexer_filetype
)
952 geany_debug("Cannot find lexer filetype '%s' for custom filetype '%s'.", result
, ft
->name
);
956 ft
->priv
->symbol_list_sort_mode
= utils_get_setting(integer
, configh
, config
, "settings",
957 "symbol_list_sort_mode", SYMBOLS_SORT_USE_PREVIOUS
);
958 ft
->priv
->xml_indent_tags
= utils_get_setting(boolean
, configh
, config
, "settings",
959 "xml_indent_tags", FALSE
);
961 /* read indent settings */
962 load_indent_settings(ft
, config
, configh
);
964 /* read build settings */
965 build_load_menu(config
, GEANY_BCS_FT
, (gpointer
)ft
);
966 build_load_menu(configh
, GEANY_BCS_HOME_FT
, (gpointer
)ft
);
970 static void copy_keys(GKeyFile
*dest
, const gchar
*dest_group
,
971 GKeyFile
*src
, const gchar
*src_group
)
973 gchar
**keys
= g_key_file_get_keys(src
, src_group
, NULL
, NULL
);
976 foreach_strv(ptr
, keys
)
979 gchar
*value
= g_key_file_get_value(src
, src_group
, key
, NULL
);
981 g_key_file_set_value(dest
, dest_group
, key
, value
);
988 static gchar
*filetypes_get_filename(GeanyFiletype
*ft
, gboolean user
)
990 gchar
*ext
= filetypes_get_conf_extension(ft
);
991 gchar
*base_name
= g_strconcat("filetypes.", ext
, NULL
);
995 file_name
= g_build_filename(app
->configdir
, GEANY_FILEDEFS_SUBDIR
, base_name
, NULL
);
997 file_name
= g_build_filename(app
->datadir
, GEANY_FILEDEFS_SUBDIR
, base_name
, NULL
);
1006 static void add_group_keys(GKeyFile
*kf
, const gchar
*group
, GeanyFiletype
*ft
)
1009 gboolean loaded
= FALSE
;
1012 files
[0] = filetypes_get_filename(ft
, FALSE
);
1013 files
[1] = filetypes_get_filename(ft
, TRUE
);
1015 for (i
= 0; i
< G_N_ELEMENTS(files
); i
++)
1017 GKeyFile
*src
= g_key_file_new();
1019 if (g_key_file_load_from_file(src
, files
[i
], G_KEY_FILE_NONE
, NULL
))
1021 copy_keys(kf
, group
, src
, group
);
1024 g_key_file_free(src
);
1028 geany_debug("Could not read config file %s for [%s=%s]!", files
[0], group
, ft
->name
);
1035 static void copy_ft_groups(GKeyFile
*kf
)
1037 gchar
**groups
= g_key_file_get_groups(kf
, NULL
);
1040 foreach_strv(ptr
, groups
)
1042 gchar
*group
= *ptr
;
1044 gchar
*name
= strchr(*ptr
, '=');
1047 if (!name
|| !name
[1]) /* no name or no parent name */
1050 old_group
= g_strdup(group
);
1052 /* terminate group at '=' */
1056 ft
= filetypes_lookup_by_name(name
);
1059 add_group_keys(kf
, group
, ft
);
1060 /* move old group keys (foo=bar) to proper group name (foo) */
1061 copy_keys(kf
, group
, kf
, old_group
);
1069 /* simple wrapper function to print file errors in DEBUG mode */
1070 static void load_system_keyfile(GKeyFile
*key_file
, const gchar
*file
, GKeyFileFlags flags
,
1073 GError
*error
= NULL
;
1074 gboolean done
= g_key_file_load_from_file(key_file
, file
, flags
, &error
);
1078 if (!done
&& !ft
->priv
->custom
)
1079 geany_debug("Failed to open %s (%s)", file
, error
->message
);
1081 g_error_free(error
);
1087 /* Load the configuration file for the associated filetype id.
1088 * This should only be called when the filetype is needed, to save loading
1089 * 20+ configuration files all at once. */
1090 void filetypes_load_config(guint ft_id
, gboolean reload
)
1092 GKeyFile
*config
, *config_home
;
1093 GeanyFiletypePrivate
*pft
;
1096 g_return_if_fail(ft_id
< filetypes_array
->len
);
1098 ft
= filetypes
[ft_id
];
1101 /* when reloading, proceed only if the settings were already loaded */
1102 if (G_UNLIKELY(reload
&& ! pft
->keyfile_loaded
))
1105 /* when not reloading, load the settings only once */
1106 if (G_LIKELY(! reload
&& pft
->keyfile_loaded
))
1108 pft
->keyfile_loaded
= TRUE
;
1110 config
= g_key_file_new();
1111 config_home
= g_key_file_new();
1113 /* highlighting uses GEANY_FILETYPES_NONE for common settings */
1116 f
= filetypes_get_filename(ft
, FALSE
);
1117 load_system_keyfile(config
, f
, G_KEY_FILE_KEEP_COMMENTS
, ft
);
1119 SETPTR(f
, filetypes_get_filename(ft
, TRUE
));
1120 g_key_file_load_from_file(config_home
, f
, G_KEY_FILE_KEEP_COMMENTS
, NULL
);
1123 /* Copy keys for any groups with [group=C] from system keyfile */
1124 copy_ft_groups(config
);
1125 copy_ft_groups(config_home
);
1127 load_settings(ft_id
, config
, config_home
);
1128 highlighting_init_styles(ft_id
, config
, config_home
);
1131 g_object_unref(ft
->icon
);
1132 ft
->icon
= ui_get_mime_icon(ft
->mime_type
);
1134 g_key_file_free(config
);
1135 g_key_file_free(config_home
);
1139 static gchar
*filetypes_get_conf_extension(const GeanyFiletype
*ft
)
1143 if (ft
->priv
->custom
)
1144 return g_strconcat(ft
->name
, ".conf", NULL
);
1146 /* Handle any special extensions different from lowercase filetype->name */
1149 case GEANY_FILETYPES_CPP
: result
= g_strdup("cpp"); break;
1150 case GEANY_FILETYPES_CS
: result
= g_strdup("cs"); break;
1151 case GEANY_FILETYPES_MAKE
: result
= g_strdup("makefile"); break;
1152 case GEANY_FILETYPES_NONE
: result
= g_strdup("common"); break;
1153 /* name is Matlab/Octave */
1154 case GEANY_FILETYPES_MATLAB
: result
= g_strdup("matlab"); break;
1155 /* name is Objective-C, and we don't want the hyphen */
1156 case GEANY_FILETYPES_OBJECTIVEC
: result
= g_strdup("objectivec"); break;
1158 result
= g_ascii_strdown(ft
->name
, -1);
1165 void filetypes_save_commands(GeanyFiletype
*ft
)
1167 GKeyFile
*config_home
;
1168 gchar
*fname
, *data
;
1170 fname
= filetypes_get_filename(ft
, TRUE
);
1171 config_home
= g_key_file_new();
1172 g_key_file_load_from_file(config_home
, fname
, G_KEY_FILE_KEEP_COMMENTS
, NULL
);
1173 build_save_menu(config_home
, ft
, GEANY_BCS_HOME_FT
);
1174 data
= g_key_file_to_data(config_home
, NULL
, NULL
);
1175 utils_write_file(fname
, data
);
1177 g_key_file_free(config_home
);
1182 /* create one file filter which has each file pattern of each filetype */
1183 GtkFileFilter
*filetypes_create_file_filter_all_source(void)
1185 GtkFileFilter
*new_filter
;
1188 new_filter
= gtk_file_filter_new();
1189 gtk_file_filter_set_name(new_filter
, _("All Source"));
1191 for (i
= 0; i
< filetypes_array
->len
; i
++)
1193 if (G_UNLIKELY(i
== GEANY_FILETYPES_NONE
))
1196 for (j
= 0; filetypes
[i
]->pattern
[j
]; j
++)
1198 gtk_file_filter_add_pattern(new_filter
, filetypes
[i
]->pattern
[j
]);
1205 GtkFileFilter
*filetypes_create_file_filter(const GeanyFiletype
*ft
)
1207 GtkFileFilter
*new_filter
;
1211 g_return_val_if_fail(ft
!= NULL
, NULL
);
1213 new_filter
= gtk_file_filter_new();
1214 title
= ft
->id
== GEANY_FILETYPES_NONE
? _("All files") : ft
->title
;
1215 gtk_file_filter_set_name(new_filter
, title
);
1217 for (i
= 0; ft
->pattern
[i
]; i
++)
1219 gtk_file_filter_add_pattern(new_filter
, ft
->pattern
[i
]);
1226 /* Indicates whether there is a tag parser for the filetype or not.
1227 * Only works for custom filetypes if the filetype settings have been loaded. */
1228 gboolean
filetype_has_tags(GeanyFiletype
*ft
)
1230 g_return_val_if_fail(ft
!= NULL
, FALSE
);
1232 return ft
->lang
!= TM_PARSER_NONE
;
1236 /** Finds a filetype pointer from its @a name field.
1237 * @param name Filetype name.
1238 * @return @transfer{none} @nullable The filetype found, or @c NULL.
1243 GeanyFiletype
*filetypes_lookup_by_name(const gchar
*name
)
1247 g_return_val_if_fail(!EMPTY(name
), NULL
);
1249 ft
= g_hash_table_lookup(filetypes_hash
, name
);
1250 if (G_UNLIKELY(ft
== NULL
))
1251 geany_debug("Could not find filetype '%s'.", name
);
1256 static void compile_regex(GeanyFiletype
*ft
, gchar
*regstr
)
1258 GError
*error
= NULL
;
1259 GRegex
*regex
= g_regex_new(regstr
, 0, 0, &error
);
1263 ui_set_statusbar(TRUE
, _("Bad regex for filetype %s: %s"),
1264 filetypes_get_display_name(ft
), error
->message
);
1265 g_error_free(error
);
1267 if (ft
->priv
->error_regex
)
1268 g_regex_unref(ft
->priv
->error_regex
);
1269 ft
->priv
->error_regex
= regex
;
1273 gboolean
filetypes_parse_error_message(GeanyFiletype
*ft
, const gchar
*message
,
1274 gchar
**filename
, gint
*line
)
1280 gint i
, n_match_groups
;
1281 gchar
*first
, *second
;
1285 doc
= document_get_current();
1287 ft
= doc
->file_type
;
1289 tmp
= build_get_regex(build_info
.grp
, ft
, NULL
);
1297 if (G_UNLIKELY(EMPTY(regstr
)))
1300 if (!ft
->priv
->error_regex
|| regstr
!= ft
->priv
->last_error_pattern
)
1302 compile_regex(ft
, regstr
);
1303 ft
->priv
->last_error_pattern
= regstr
;
1305 if (!ft
->priv
->error_regex
)
1308 if (!g_regex_match(ft
->priv
->error_regex
, message
, 0, &minfo
))
1310 g_match_info_free(minfo
);
1314 n_match_groups
= g_match_info_get_match_count(minfo
);
1315 first
= second
= NULL
;
1317 for (i
= 1; i
< n_match_groups
; i
++)
1321 g_match_info_fetch_pos(minfo
, i
, &start_pos
, NULL
);
1322 if (start_pos
!= -1)
1325 first
= g_match_info_fetch(minfo
, i
);
1328 second
= g_match_info_fetch(minfo
, i
);
1339 l
= strtol(first
, &end
, 10);
1340 if (*end
== '\0') /* first is purely decimals */
1348 l
= strtol(second
, &end
, 10);
1365 g_match_info_free(minfo
);
1366 return *filename
!= NULL
;
1371 static void convert_filetype_extensions_to_lower_case(gchar
**patterns
, gsize len
)
1374 for (i
= 0; i
< len
; i
++)
1376 SETPTR(patterns
[i
], g_ascii_strdown(patterns
[i
], -1));
1382 static void read_extensions(GKeyFile
*sysconfig
, GKeyFile
*userconfig
)
1388 for (i
= 0; i
< filetypes_array
->len
; i
++)
1391 g_key_file_has_key(userconfig
, "Extensions", filetypes
[i
]->name
, NULL
);
1392 gchar
**list
= g_key_file_get_string_list(
1393 (userset
) ? userconfig
: sysconfig
, "Extensions", filetypes
[i
]->name
, &len
, NULL
);
1395 filetypes
[i
]->priv
->user_extensions
= userset
;
1396 g_strfreev(filetypes
[i
]->pattern
);
1397 /* Note: we allow 'Foo=' to remove all patterns */
1399 list
= g_new0(gchar
*, 1);
1400 filetypes
[i
]->pattern
= list
;
1403 convert_filetype_extensions_to_lower_case(filetypes
[i
]->pattern
, len
);
1409 static void read_group(GKeyFile
*config
, const gchar
*group_name
, GeanyFiletypeGroupID group_id
)
1411 gchar
**names
= g_key_file_get_string_list(config
, "Groups", group_name
, NULL
, NULL
);
1414 foreach_strv(name
, names
)
1416 GeanyFiletype
*ft
= filetypes_lookup_by_name(*name
);
1420 ft
->group
= group_id
;
1421 if (ft
->priv
->custom
&&
1422 (group_id
== GEANY_FILETYPE_GROUP_COMPILED
|| group_id
== GEANY_FILETYPE_GROUP_SCRIPT
))
1424 SETPTR(ft
->title
, filetype_make_title(ft
->name
, TITLE_SOURCE_FILE
));
1428 geany_debug("Filetype '%s' not found for group '%s'!", *name
, group_name
);
1434 static void read_groups(GKeyFile
*config
)
1436 read_group(config
, "Programming", GEANY_FILETYPE_GROUP_COMPILED
);
1437 read_group(config
, "Script", GEANY_FILETYPE_GROUP_SCRIPT
);
1438 read_group(config
, "Markup", GEANY_FILETYPE_GROUP_MARKUP
);
1439 read_group(config
, "Misc", GEANY_FILETYPE_GROUP_MISC
);
1440 read_group(config
, "None", GEANY_FILETYPE_GROUP_NONE
);
1444 static void read_filetype_config(void)
1446 gchar
*sysconfigfile
= g_build_filename(app
->datadir
, "filetype_extensions.conf", NULL
);
1447 gchar
*userconfigfile
= g_build_filename(app
->configdir
, "filetype_extensions.conf", NULL
);
1448 GKeyFile
*sysconfig
= g_key_file_new();
1449 GKeyFile
*userconfig
= g_key_file_new();
1451 g_key_file_load_from_file(sysconfig
, sysconfigfile
, G_KEY_FILE_NONE
, NULL
);
1452 g_key_file_load_from_file(userconfig
, userconfigfile
, G_KEY_FILE_NONE
, NULL
);
1454 read_extensions(sysconfig
, userconfig
);
1455 read_groups(sysconfig
);
1456 read_groups(userconfig
);
1458 g_free(sysconfigfile
);
1459 g_free(userconfigfile
);
1460 g_key_file_free(sysconfig
);
1461 g_key_file_free(userconfig
);
1465 void filetypes_reload_extensions(void)
1469 read_filetype_config();
1471 /* Redetect filetype of any documents with none set */
1474 GeanyDocument
*doc
= documents
[i
];
1475 if (doc
->file_type
->id
!= GEANY_FILETYPES_NONE
)
1477 document_set_filetype(doc
, filetypes_detect_from_document(doc
));
1482 /** Accessor function for @ref GeanyData::filetypes_array items.
1483 * Example: @code ft = filetypes_index(GEANY_FILETYPES_C); @endcode
1484 * @param idx @c filetypes_array index.
1485 * @return @transfer{none} @nullable The filetype, or @c NULL if @a idx is out of range.
1490 GeanyFiletype
*filetypes_index(gint idx
)
1492 return (idx
>= 0 && idx
< (gint
) filetypes_array
->len
) ? filetypes
[idx
] : NULL
;
1496 void filetypes_reload(void)
1499 GeanyDocument
*current_doc
;
1501 /* reload filetype configs */
1502 for (i
= 0; i
< filetypes_array
->len
; i
++)
1504 /* filetypes_load_config() will skip not loaded filetypes */
1505 filetypes_load_config(i
, TRUE
);
1508 current_doc
= document_get_current();
1512 /* update document styling */
1515 if (current_doc
!= documents
[i
])
1516 document_reload_config(documents
[i
]);
1518 /* process the current document at last */
1519 document_reload_config(current_doc
);
1523 /** Gets @c ft->name or a translation for filetype None.
1526 * @since Geany 0.20 */
1528 const gchar
*filetypes_get_display_name(GeanyFiletype
*ft
)
1530 return ft
->id
== GEANY_FILETYPES_NONE
? _("None") : ft
->name
;
1534 /* gets comment_open/comment_close/comment_single strings from the filetype
1535 * @param single_first: whether single comment is preferred if both available
1536 * returns true if at least comment_open is set, false otherwise */
1537 gboolean
filetype_get_comment_open_close(const GeanyFiletype
*ft
, gboolean single_first
,
1538 const gchar
**co
, const gchar
**cc
)
1540 g_return_val_if_fail(ft
!= NULL
, FALSE
);
1541 g_return_val_if_fail(co
!= NULL
, FALSE
);
1542 g_return_val_if_fail(cc
!= NULL
, FALSE
);
1546 *co
= ft
->comment_single
;
1551 *co
= ft
->comment_open
;
1552 *cc
= ft
->comment_close
;
1557 *co
= ft
->comment_open
;
1559 *cc
= ft
->comment_close
;
1562 *co
= ft
->comment_single
;
1570 static void *copy_(void *src
) { return src
; }
1571 static void free_(void *doc
) { }
1574 * Gets the GType of GeanyFiletype
1576 * @return the GeanyFiletype type */
1578 GType
filetype_get_type (void);
1580 G_DEFINE_BOXED_TYPE(GeanyFiletype
, filetype
, copy_
, free_
);