src/filetypes.c

   1 /*
   2  *      filetypes.c - this file is part of Geany, a fast and lightweight IDE
   3  *
   4  *      Copyright 2005-2010 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
   5  *      Copyright 2006-2010 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
   6  *
   7  *      This program is free software; you can redistribute it and/or modify
   8  *      it under the terms of the GNU General Public License as published by
   9  *      the Free Software Foundation; either version 2 of the License, or
  10  *      (at your option) any later version.
  11  *
  12  *      This program is distributed in the hope that it will be useful,
  13  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *      GNU General Public License for more details.
  16  *
  17  *      You should have received a copy of the GNU General Public License
  18  *      along with this program; if not, write to the Free Software
  19  *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  *
  21  * $Id$
  22  */
  23
  24 /**
  25  * @file filetypes.h
  26  * Filetype detection, file extensions and filetype menu items.
  27  */
  28
  29 /* Note: we use filetype_id for some function arguments, but GeanyFiletype is better; we should
  30  * only use GeanyFiletype for API functions. */
  31
  32 #include <string.h>
  33 #include <glib/gstdio.h>
  34
  35 #include "geany.h"
  36 #include "filetypes.h"
  37 #include "highlighting.h"
  38 #include "support.h"
  39 #include "templates.h"
  40 #include "document.h"
  41 #include "editor.h"
  42 #include "msgwindow.h"
  43 #include "utils.h"
  44 #include "sciwrappers.h"
  45 #include "ui_utils.h"
  46
  47 #include <stdlib.h>
  48
  49 #ifdef HAVE_REGCOMP
  50 # ifdef HAVE_REGEX_H
  51 #  include <regex.h>
  52 # else
  53 #  include "gnuregex.h"
  54 # endif
  55 #endif
  56
  57
  58 /* Private GeanyFiletype fields */
  59 typedef struct GeanyFiletypePrivate
  60 {
  61         GtkWidget       *menu_item;                     /* holds a pointer to the menu item for this filetype */
  62         gboolean        keyfile_loaded;
  63 #ifdef HAVE_REGCOMP
  64         regex_t         error_regex;
  65         gboolean        error_regex_compiled;
  66         gchar           *last_string; /* last one compiled */
  67 #endif
  68         gboolean        custom;
  69 }
  70 GeanyFiletypePrivate;
  71
  72
  73 GPtrArray *filetypes_array = NULL;      /* Dynamic array of filetype pointers */
  74
  75 static GHashTable *filetypes_hash = NULL;       /* Hash of filetype pointers based on name keys */
  76
  77 /** List of filetype pointers sorted by name, but with @c filetypes_index(GEANY_FILETYPES_NONE)
  78  * first, as this is usually treated specially.
  79  * The list does not change (after filetypes have been initialized), so you can use
  80  * @code g_slist_nth_data(filetypes_by_title, n) @endcode and expect the same result at different times. */
  81 GSList *filetypes_by_title = NULL;
  82
  83
  84 static void create_radio_menu_item(GtkWidget *menu, GeanyFiletype *ftype);
  85
  86
  87 enum TitleType
  88 {
  89         TITLE_SOURCE_FILE,
  90         TITLE_FILE
  91 };
  92
  93 /* Save adding many translation strings if the filetype name doesn't need translating */
  94 static void filetype_make_title(GeanyFiletype *ft, enum TitleType type)
  95 {
  96         const gchar *fmt = NULL;
  97
  98         switch (type)
  99         {
 100                 default:
 101                 case TITLE_SOURCE_FILE: fmt = _("%s source file"); break;
 102                 case TITLE_FILE:                fmt = _("%s file"); break;
 103         }
 104         g_assert(!ft->title);
 105         g_assert(ft->name);
 106         ft->title = g_strdup_printf(fmt, ft->name);
 107 }
 108
 109
 110 /* Note: remember to update HACKING if this function is renamed. */
 111 static void init_builtin_filetypes(void)
 112 {
 113         GeanyFiletype *ft;
 114
 115 #define NONE    /* these macros are only to ease navigation */
 116         ft = filetypes[GEANY_FILETYPES_NONE];
 117         ft->lang = -2;
 118         ft->name = g_strdup(_("None"));
 119         ft->title = g_strdup(_("None"));
 120         ft->extension = NULL;
 121         ft->pattern = utils_strv_new("*", NULL);
 122         ft->comment_open = NULL;
 123         ft->comment_close = NULL;
 124         ft->group = GEANY_FILETYPE_GROUP_NONE;
 125
 126 #define C
 127         ft = filetypes[GEANY_FILETYPES_C];
 128         ft->lang = 0;
 129         ft->name = g_strdup("C");
 130         filetype_make_title(ft, TITLE_SOURCE_FILE);
 131         ft->extension = g_strdup("c");
 132         ft->pattern = utils_strv_new("*.c", "*.h", NULL);
 133         ft->comment_open = g_strdup("/*");
 134         ft->comment_close = g_strdup("*/");
 135         ft->group = GEANY_FILETYPE_GROUP_COMPILED;
 136
 137 #define CPP
 138         ft = filetypes[GEANY_FILETYPES_CPP];
 139         ft->lang = 1;
 140         ft->name = g_strdup("C++");
 141         filetype_make_title(ft, TITLE_FILE);
 142         ft->extension = g_strdup("cpp");
 143         ft->pattern = utils_strv_new("*.cpp", "*.cxx", "*.c++", "*.cc",
 144                 "*.h", "*.hpp", "*.hxx", "*.h++", "*.hh", "*.C", NULL);
 145         ft->comment_open = g_strdup("//");
 146         ft->comment_close = NULL;
 147         ft->group = GEANY_FILETYPE_GROUP_COMPILED;
 148
 149 #define CS
 150         ft = filetypes[GEANY_FILETYPES_CS];
 151         ft->lang = 25;
 152         ft->name = g_strdup("C#");
 153         filetype_make_title(ft, TITLE_FILE);
 154         ft->extension = g_strdup("cs");
 155         ft->pattern = utils_strv_new("*.cs", NULL);
 156         ft->comment_open = g_strdup("//");
 157         ft->comment_close = NULL;
 158         ft->group = GEANY_FILETYPE_GROUP_COMPILED;
 159
 160 #define VALA
 161         ft = filetypes[GEANY_FILETYPES_VALA];
 162         ft->lang = 33;
 163         ft->name = g_strdup("Vala");
 164         filetype_make_title(ft, TITLE_SOURCE_FILE);
 165         ft->extension = g_strdup("vala");
 166         ft->pattern = utils_strv_new("*.vala", "*.vapi", NULL);
 167         ft->comment_open = g_strdup("//");
 168         ft->comment_close = NULL;
 169         ft->group = GEANY_FILETYPE_GROUP_COMPILED;
 170
 171 #define D
 172         ft = filetypes[GEANY_FILETYPES_D];
 173         ft->lang = 17;
 174         ft->name = g_strdup("D");
 175         filetype_make_title(ft, TITLE_SOURCE_FILE);
 176         ft->extension = g_strdup("d");
 177         ft->pattern = utils_strv_new("*.d", "*.di", NULL);
 178         ft->comment_open = g_strdup("//");
 179         ft->comment_close = NULL;
 180         ft->group = GEANY_FILETYPE_GROUP_COMPILED;
 181
 182 #define JAVA
 183         ft = filetypes[GEANY_FILETYPES_JAVA];
 184         ft->lang = 2;
 185         ft->name = g_strdup("Java");
 186         filetype_make_title(ft, TITLE_SOURCE_FILE);
 187         ft->extension = g_strdup("java");
 188         ft->pattern = utils_strv_new("*.java", "*.jsp", NULL);
 189         ft->comment_open = g_strdup("/*");
 190         ft->comment_close = g_strdup("*/");
 191         ft->group = GEANY_FILETYPE_GROUP_COMPILED;
 192
 193 #define PAS /* to avoid warnings when building under Windows, the symbol PASCAL is there defined */
 194         ft = filetypes[GEANY_FILETYPES_PASCAL];
 195         ft->lang = 4;
 196         ft->name = g_strdup("Pascal");
 197         filetype_make_title(ft, TITLE_SOURCE_FILE);
 198         ft->extension = g_strdup("pas");
 199         ft->pattern = utils_strv_new("*.pas", "*.pp", "*.inc", "*.dpr",
 200                 "*.dpk", NULL);
 201         ft->comment_open = g_strdup("{");
 202         ft->comment_close = g_strdup("}");
 203         ft->group = GEANY_FILETYPE_GROUP_COMPILED;
 204
 205 #define ASM
 206         ft = filetypes[GEANY_FILETYPES_ASM];
 207         ft->lang = 9;
 208         ft->name = g_strdup("ASM");
 209         ft->title = g_strdup_printf(_("%s source file"), "Assembler");
 210         ft->extension = g_strdup("asm");
 211         ft->pattern = utils_strv_new("*.asm", NULL);
 212         ft->comment_open = g_strdup(";");
 213         ft->comment_close = NULL;
 214         ft->group = GEANY_FILETYPE_GROUP_COMPILED;
 215
 216 #define BASIC
 217         ft = filetypes[GEANY_FILETYPES_BASIC];
 218         ft->lang = 26;
 219         ft->name = g_strdup("FreeBasic");
 220         filetype_make_title(ft, TITLE_SOURCE_FILE);
 221         ft->extension = g_strdup("bas");
 222         ft->pattern = utils_strv_new("*.bas", "*.bi", NULL);
 223         ft->comment_open = g_strdup("'");
 224         ft->comment_close = NULL;
 225         ft->group = GEANY_FILETYPE_GROUP_COMPILED;
 226
 227 #define FORTRAN
 228         ft = filetypes[GEANY_FILETYPES_FORTRAN];
 229         ft->lang = 18;
 230         ft->name = g_strdup("Fortran");
 231         ft->title = g_strdup_printf(_("%s source file"), "Fortran (F90)");
 232         ft->extension = g_strdup("f90");
 233         ft->pattern = utils_strv_new("*.f90", "*.f95", "*.f03", NULL);
 234         ft->comment_open = g_strdup("!");
 235         ft->comment_close = NULL;
 236         ft->group = GEANY_FILETYPE_GROUP_COMPILED;
 237
 238 #define F77
 239         ft = filetypes[GEANY_FILETYPES_F77];
 240         ft->lang = 30;
 241         ft->name = g_strdup("F77");
 242         ft->title = g_strdup_printf(_("%s source file"), "Fortran (F77)");
 243         ft->extension = g_strdup("f");
 244         ft->pattern = utils_strv_new("*.f", "*.for", "*.ftn", "*.f77", NULL);
 245         ft->comment_open = g_strdup("c");
 246         ft->comment_close = NULL;
 247         ft->group = GEANY_FILETYPE_GROUP_COMPILED;
 248
 249 #define GLSL
 250         ft = filetypes[GEANY_FILETYPES_GLSL];
 251         ft->lang = 31;
 252         ft->name = g_strdup("GLSL");
 253         filetype_make_title(ft, TITLE_SOURCE_FILE);
 254         ft->extension = g_strdup("glsl");
 255         ft->pattern = utils_strv_new("*.glsl", "*.frag", "*.vert", NULL);
 256         ft->comment_open = g_strdup("/*");
 257         ft->comment_close = g_strdup("*/");
 258         ft->group = GEANY_FILETYPE_GROUP_COMPILED;
 259
 260 #define CAML
 261         ft = filetypes[GEANY_FILETYPES_CAML];
 262         ft->lang = -2;
 263         ft->name = g_strdup("CAML");
 264         ft->title = g_strdup_printf(_("%s source file"), "(O)Caml");
 265         ft->extension = g_strdup("ml");
 266         ft->pattern = utils_strv_new("*.ml", "*.mli", NULL);
 267         ft->comment_open = g_strdup("(*");
 268         ft->comment_close = g_strdup("*)");
 269         ft->group = GEANY_FILETYPE_GROUP_COMPILED;
 270
 271 #define PERL
 272         ft = filetypes[GEANY_FILETYPES_PERL];
 273         ft->lang = 5;
 274         ft->name = g_strdup("Perl");
 275         filetype_make_title(ft, TITLE_SOURCE_FILE);
 276         ft->extension = g_strdup("pl");
 277         ft->pattern = utils_strv_new("*.pl", "*.perl", "*.pm", "*.agi",
 278                 "*.pod", NULL);
 279         ft->comment_open = g_strdup("#");
 280         ft->comment_close = NULL;
 281         ft->group = GEANY_FILETYPE_GROUP_SCRIPT;
 282
 283 #define PHP
 284         ft = filetypes[GEANY_FILETYPES_PHP];
 285         ft->lang = 6;
 286         ft->name = g_strdup("PHP");
 287         filetype_make_title(ft, TITLE_SOURCE_FILE);
 288         ft->extension = g_strdup("php");
 289         ft->pattern = utils_strv_new("*.php", "*.php3", "*.php4", "*.php5",
 290                 "*.phtml", NULL);
 291         ft->comment_open = g_strdup("//");
 292         ft->comment_close = NULL;
 293         ft->group = GEANY_FILETYPE_GROUP_SCRIPT;
 294
 295 #define JAVASCRIPT
 296         ft = filetypes[GEANY_FILETYPES_JS];
 297         ft->lang = 23;
 298         ft->name = g_strdup("Javascript");
 299         filetype_make_title(ft, TITLE_SOURCE_FILE);
 300         ft->extension = g_strdup("js");
 301         ft->pattern = utils_strv_new("*.js", NULL);
 302         ft->comment_open = g_strdup("//");
 303         ft->comment_close = NULL;
 304         ft->group = GEANY_FILETYPE_GROUP_SCRIPT;
 305
 306 #define PYTHON
 307         ft = filetypes[GEANY_FILETYPES_PYTHON];
 308         ft->lang = 7;
 309         ft->name = g_strdup("Python");
 310         filetype_make_title(ft, TITLE_SOURCE_FILE);
 311         ft->extension = g_strdup("py");
 312         ft->pattern = utils_strv_new("*.py", "*.pyw", NULL);
 313         ft->comment_open = g_strdup("#");
 314         ft->comment_close = NULL;
 315         ft->group = GEANY_FILETYPE_GROUP_SCRIPT;
 316
 317 #define RUBY
 318         ft = filetypes[GEANY_FILETYPES_RUBY];
 319         ft->lang = 14;
 320         ft->name = g_strdup("Ruby");
 321         filetype_make_title(ft, TITLE_SOURCE_FILE);
 322         ft->extension = g_strdup("rb");
 323         ft->pattern = utils_strv_new("*.rb", "*.rhtml", "*.ruby", NULL);
 324         ft->comment_open = g_strdup("#");
 325         ft->comment_close = NULL;
 326         ft->group = GEANY_FILETYPE_GROUP_SCRIPT;
 327
 328 #define TCL
 329         ft = filetypes[GEANY_FILETYPES_TCL];
 330         ft->lang = 15;
 331         ft->name = g_strdup("Tcl");
 332         filetype_make_title(ft, TITLE_SOURCE_FILE);
 333         ft->extension = g_strdup("tcl");
 334         ft->pattern = utils_strv_new("*.tcl", "*.tk", "*.wish", NULL);
 335         ft->comment_open = g_strdup("#");
 336         ft->comment_close = NULL;
 337         ft->group = GEANY_FILETYPE_GROUP_SCRIPT;
 338
 339 #define LUA
 340         ft = filetypes[GEANY_FILETYPES_LUA];
 341         ft->lang = 22;
 342         ft->name = g_strdup("Lua");
 343         filetype_make_title(ft, TITLE_SOURCE_FILE);
 344         ft->extension = g_strdup("lua");
 345         ft->pattern = utils_strv_new("*.lua", NULL);
 346         ft->comment_open = g_strdup("--");
 347         ft->comment_close = NULL;
 348         ft->group = GEANY_FILETYPE_GROUP_SCRIPT;
 349
 350 #define FERITE
 351         ft = filetypes[GEANY_FILETYPES_FERITE];
 352         ft->lang = 19;
 353         ft->name = g_strdup("Ferite");
 354         filetype_make_title(ft, TITLE_SOURCE_FILE);
 355         ft->extension = g_strdup("fe");
 356         ft->pattern = utils_strv_new("*.fe", NULL);
 357         ft->comment_open = g_strdup("/*");
 358         ft->comment_close = g_strdup("*/");
 359         ft->group = GEANY_FILETYPE_GROUP_SCRIPT;
 360
 361 #define HASKELL
 362         ft = filetypes[GEANY_FILETYPES_HASKELL];
 363         ft->lang = 24;
 364         ft->name = g_strdup("Haskell");
 365         filetype_make_title(ft, TITLE_SOURCE_FILE);
 366         ft->extension = g_strdup("hs");
 367         ft->pattern = utils_strv_new("*.hs", "*.lhs", NULL);
 368         ft->comment_open = g_strdup("--");
 369         ft->comment_close = NULL;
 370         ft->group = GEANY_FILETYPE_GROUP_COMPILED;
 371
 372 #define MARKDOWN
 373         ft = filetypes[GEANY_FILETYPES_MARKDOWN];
 374         ft->lang = 36;
 375         ft->name = g_strdup("Markdown");
 376         filetype_make_title(ft, TITLE_SOURCE_FILE);
 377         ft->extension = g_strdup("md");
 378         ft->pattern = utils_strv_new("*.mdml", "*.mdwn", "*.markdown", "*.md", NULL);
 379         ft->comment_open = NULL;
 380         ft->comment_close = NULL;
 381         ft->group = GEANY_FILETYPE_GROUP_MISC;
 382
 383 #define TXT2TAGS
 384         ft = filetypes[GEANY_FILETYPES_TXT2TAGS];
 385         ft->lang = 37;
 386         ft->name = g_strdup("Txt2tags");
 387         filetype_make_title(ft, TITLE_SOURCE_FILE);
 388         ft->extension = g_strdup("t2t");
 389         ft->pattern = utils_strv_new("*.t2t", "*.txt2tags", NULL);
 390         ft->comment_open = NULL;
 391         ft->comment_close = NULL;
 392         ft->group = GEANY_FILETYPE_GROUP_MISC;
 393
 394 #define ABC
 395         ft = filetypes[GEANY_FILETYPES_ABC];
 396         ft->lang = 38;
 397         ft->name = g_strdup("Abc");
 398         filetype_make_title(ft, TITLE_SOURCE_FILE);
 399         ft->extension = g_strdup("abc");
 400         ft->pattern = utils_strv_new("*.abc", "*.abp", NULL);
 401         ft->comment_open = NULL;
 402         ft->comment_close = NULL;
 403         ft->group = GEANY_FILETYPE_GROUP_MISC;
 404
 405 #define SH
 406         ft = filetypes[GEANY_FILETYPES_SH];
 407         ft->lang = 16;
 408         ft->name = g_strdup("Sh");
 409         ft->title = g_strdup(_("Shell script file"));
 410         ft->extension = g_strdup("sh");
 411         ft->pattern = utils_strv_new("*.sh", "configure", "configure.in",
 412                 "configure.in.in", "configure.ac", "*.ksh", "*.zsh", "*.ash", "*.bash", NULL);
 413         ft->comment_open = g_strdup("#");
 414         ft->comment_close = NULL;
 415         ft->group = GEANY_FILETYPE_GROUP_SCRIPT;
 416
 417 #define MAKE
 418         ft = filetypes[GEANY_FILETYPES_MAKE];
 419         ft->lang = 3;
 420         ft->name = g_strdup("Make");
 421         ft->title = g_strdup(_("Makefile"));
 422         ft->extension = g_strdup("mak");
 423         ft->pattern = utils_strv_new(
 424                 "*.mak", "*.mk", "GNUmakefile", "makefile", "Makefile", "makefile.*", "Makefile.*", NULL);
 425         ft->comment_open = g_strdup("#");
 426         ft->comment_close = NULL;
 427         ft->group = GEANY_FILETYPE_GROUP_SCRIPT;
 428
 429 #define XML
 430         ft = filetypes[GEANY_FILETYPES_XML];
 431         ft->lang = -2;
 432         ft->name = g_strdup("XML");
 433         ft->title = g_strdup(_("XML document"));
 434         ft->extension = g_strdup("xml");
 435         ft->pattern = utils_strv_new(
 436                 "*.xml", "*.sgml", "*.xsl", "*.xslt", "*.xsd", "*.xhtml", NULL);
 437         ft->comment_open = g_strdup("<!--");
 438         ft->comment_close = g_strdup("-->");
 439         ft->group = GEANY_FILETYPE_GROUP_MARKUP;
 440
 441 #define DOCBOOK
 442         ft = filetypes[GEANY_FILETYPES_DOCBOOK];
 443         ft->lang = 12;
 444         ft->name = g_strdup("Docbook");
 445         filetype_make_title(ft, TITLE_SOURCE_FILE);
 446         ft->extension = g_strdup("docbook");
 447         ft->pattern = utils_strv_new("*.docbook", NULL);
 448         ft->comment_open = g_strdup("<!--");
 449         ft->comment_close = g_strdup("-->");
 450         ft->group = GEANY_FILETYPE_GROUP_MARKUP;
 451
 452 #define HTML
 453         ft = filetypes[GEANY_FILETYPES_HTML];
 454         ft->lang = 29;
 455         ft->name = g_strdup("HTML");
 456         filetype_make_title(ft, TITLE_SOURCE_FILE);
 457         ft->extension = g_strdup("html");
 458         ft->pattern = utils_strv_new(
 459                 "*.htm", "*.html", "*.shtml", "*.hta", "*.htd", "*.htt", "*.cfm", NULL);
 460         ft->comment_open = g_strdup("<!--");
 461         ft->comment_close = g_strdup("-->");
 462         ft->group = GEANY_FILETYPE_GROUP_MARKUP;
 463
 464 #define CSS
 465         ft = filetypes[GEANY_FILETYPES_CSS];
 466         ft->lang = 13;
 467         ft->name = g_strdup("CSS");
 468         ft->title = g_strdup(_("Cascading StyleSheet"));
 469         ft->extension = g_strdup("css");
 470         ft->pattern = utils_strv_new("*.css", NULL);
 471         ft->comment_open = g_strdup("/*");
 472         ft->comment_close = g_strdup("*/");
 473         ft->group = GEANY_FILETYPE_GROUP_MARKUP;        /* not really markup but fit quite well to HTML */
 474
 475 #define SQL
 476         ft = filetypes[GEANY_FILETYPES_SQL];
 477         ft->lang = 11;
 478         ft->name = g_strdup("SQL");
 479         ft->title = g_strdup(_("SQL Dump file"));
 480         ft->extension = g_strdup("sql");
 481         ft->pattern = utils_strv_new("*.sql", NULL);
 482         ft->comment_open = g_strdup("/*");
 483         ft->comment_close = g_strdup("*/");
 484         ft->group = GEANY_FILETYPE_GROUP_MISC;
 485
 486 #define LATEX
 487         ft = filetypes[GEANY_FILETYPES_LATEX];
 488         ft->lang = 8;
 489         ft->name = g_strdup("LaTeX");
 490         filetype_make_title(ft, TITLE_SOURCE_FILE);
 491         ft->extension = g_strdup("tex");
 492         ft->pattern = utils_strv_new("*.tex", "*.sty", "*.idx", "*.ltx", NULL);
 493         ft->comment_open = g_strdup("%");
 494         ft->comment_close = NULL;
 495         ft->group = GEANY_FILETYPE_GROUP_MISC;
 496
 497 #define VHDL
 498         ft = filetypes[GEANY_FILETYPES_VHDL];
 499         ft->lang = 21;
 500         ft->name = g_strdup("VHDL");
 501         filetype_make_title(ft, TITLE_SOURCE_FILE);
 502         ft->extension = g_strdup("vhd");
 503         ft->pattern = utils_strv_new("*.vhd", "*.vhdl", NULL);
 504         ft->comment_open = g_strdup("--");
 505         ft->comment_close = NULL;
 506         ft->group = GEANY_FILETYPE_GROUP_COMPILED;
 507
 508 #define VERILOG
 509         ft = filetypes[GEANY_FILETYPES_VERILOG];
 510         ft->lang = 39;
 511         ft->name = g_strdup("Verilog");
 512         filetype_make_title(ft, TITLE_SOURCE_FILE);
 513         ft->extension = g_strdup("v");
 514         ft->pattern = utils_strv_new("*.v", "*.verilog", NULL);
 515         ft->comment_open = g_strdup("/*");
 516         ft->comment_close = g_strdup("*/");
 517         ft->group = GEANY_FILETYPE_GROUP_COMPILED;
 518
 519 #define DIFF
 520         ft = filetypes[GEANY_FILETYPES_DIFF];
 521         ft->lang = 20;
 522         ft->name = g_strdup("Diff");
 523         filetype_make_title(ft, TITLE_FILE);
 524         ft->extension = g_strdup("diff");
 525         ft->pattern = utils_strv_new("*.diff", "*.patch", "*.rej", NULL);
 526         ft->comment_open = g_strdup("#");
 527         ft->comment_close = NULL;
 528         ft->group = GEANY_FILETYPE_GROUP_MISC;
 529
 530 #define CONF
 531         ft = filetypes[GEANY_FILETYPES_CONF];
 532         ft->lang = 10;
 533         ft->name = g_strdup("Conf");
 534         ft->title = g_strdup(_("Config file"));
 535         ft->extension = g_strdup("conf");
 536         ft->pattern = utils_strv_new("*.conf", "*.ini", "config", "*rc",
 537                 "*.cfg", "*.desktop", NULL);
 538         ft->comment_open = g_strdup("#");
 539         ft->comment_close = NULL;
 540         ft->group = GEANY_FILETYPE_GROUP_MISC;
 541
 542 #define PO
 543         ft = filetypes[GEANY_FILETYPES_PO];
 544         ft->lang = -2;
 545         ft->name = g_strdup("Po");
 546         ft->title = g_strdup(_("Gettext translation file"));
 547         ft->extension = g_strdup("po");
 548         ft->pattern = utils_strv_new("*.po", "*.pot", NULL);
 549         ft->comment_open = g_strdup("#");
 550         ft->comment_close = NULL;
 551         ft->group = GEANY_FILETYPE_GROUP_MISC;
 552
 553 #define HAXE
 554         ft = filetypes[GEANY_FILETYPES_HAXE];
 555         ft->lang = 27;
 556         ft->name = g_strdup("Haxe");
 557         filetype_make_title(ft, TITLE_SOURCE_FILE);
 558         ft->extension = g_strdup("hx");
 559         ft->pattern = utils_strv_new("*.hx", NULL);
 560         ft->comment_open = g_strdup("//");
 561         ft->comment_close = NULL;
 562         ft->group = GEANY_FILETYPE_GROUP_COMPILED;
 563
 564 #define ACTIONSCRIPT
 565         ft = filetypes[GEANY_FILETYPES_AS];
 566         ft->lang = 34;
 567         ft->name = g_strdup("ActionScript");
 568         filetype_make_title(ft, TITLE_SOURCE_FILE);
 569         ft->extension = g_strdup("as");
 570         ft->pattern = utils_strv_new("*.as", NULL);
 571         ft->comment_open = g_strdup("//");
 572         ft->comment_close = NULL;
 573         ft->group = GEANY_FILETYPE_GROUP_SCRIPT;
 574
 575 #define R
 576         ft = filetypes[GEANY_FILETYPES_R];
 577         ft->lang = 40;
 578         ft->name = g_strdup("R");
 579         ft->title = g_strdup_printf(_("%s script file"), "R");
 580         ft->extension = g_strdup("R");
 581         ft->pattern = utils_strv_new("*.R", "*.r", NULL);
 582         ft->comment_open = g_strdup("#");
 583         ft->comment_close = NULL;
 584         ft->group = GEANY_FILETYPE_GROUP_SCRIPT;
 585
 586 #define REST
 587         ft = filetypes[GEANY_FILETYPES_REST];
 588         ft->lang = 28;
 589         ft->name = g_strdup("reStructuredText");
 590         filetype_make_title(ft, TITLE_FILE);
 591         ft->extension = g_strdup("rst");
 592         ft->pattern = utils_strv_new(
 593                 "*.rest", "*.reST", "*.rst", NULL);
 594         ft->comment_open = NULL;
 595         ft->comment_close = NULL;
 596         ft->group = GEANY_FILETYPE_GROUP_MISC;
 597
 598 #define MATLAB
 599         ft = filetypes[GEANY_FILETYPES_MATLAB];
 600         ft->lang = 32;
 601         ft->name = g_strdup("Matlab");
 602         filetype_make_title(ft, TITLE_SOURCE_FILE);
 603         ft->extension = g_strdup("m");
 604         ft->pattern = utils_strv_new("*.m", NULL);
 605         ft->comment_open = g_strdup("%");
 606         ft->comment_close = NULL;
 607         ft->group = GEANY_FILETYPE_GROUP_SCRIPT;
 608
 609 #define YAML
 610         ft = filetypes[GEANY_FILETYPES_YAML];
 611         ft->lang = -2;
 612         ft->name = g_strdup("YAML");
 613         filetype_make_title(ft, TITLE_SOURCE_FILE);
 614         ft->extension = g_strdup("yaml");
 615         ft->pattern = utils_strv_new("*.yaml", "*.yml", NULL);
 616         ft->comment_open = g_strdup("#");
 617         ft->comment_close = NULL;
 618         ft->group = GEANY_FILETYPE_GROUP_MISC;
 619
 620 #define CMAKE
 621         ft = filetypes[GEANY_FILETYPES_CMAKE];
 622         ft->lang = -2;
 623         ft->name = g_strdup("CMake");
 624         filetype_make_title(ft, TITLE_SOURCE_FILE);
 625         ft->extension = g_strdup("cmake");
 626         ft->pattern = utils_strv_new("CMakeLists.txt", "*.cmake", "*.ctest", NULL);
 627         ft->comment_open = g_strdup("#");
 628         ft->comment_close = NULL;
 629         ft->group = GEANY_FILETYPE_GROUP_MISC;
 630
 631 #define NSIS
 632         ft = filetypes[GEANY_FILETYPES_NSIS];
 633         ft->lang = 35;
 634         ft->name = g_strdup("NSIS");
 635         filetype_make_title(ft, TITLE_SOURCE_FILE);
 636         ft->extension = g_strdup("nsis");
 637         ft->pattern = utils_strv_new("*.nsi", "*.nsh", NULL);
 638         ft->comment_open = g_strdup(";");
 639         ft->comment_close = NULL;
 640         ft->group = GEANY_FILETYPE_GROUP_MISC;
 641
 642 #define ADA
 643         ft = filetypes[GEANY_FILETYPES_ADA];
 644         ft->lang = -2;
 645         ft->name = g_strdup("Ada");
 646         filetype_make_title(ft, TITLE_SOURCE_FILE);
 647         ft->extension = g_strdup("adb");
 648         ft->pattern = utils_strv_new("*.adb", "*.ads", NULL);
 649         ft->comment_open = g_strdup("--");
 650         ft->comment_close = NULL;
 651         ft->group = GEANY_FILETYPE_GROUP_COMPILED;
 652 }
 653
 654
 655 /* initialize fields. */
 656 static GeanyFiletype *filetype_new(void)
 657 {
 658         GeanyFiletype *ft = g_new0(GeanyFiletype, 1);
 659
 660         ft->lang = -2;  /* assume no tagmanager parser */
 661         ft->project_list_entry = -1; /* no entry */
 662
 663         ft->priv = g_new0(GeanyFiletypePrivate, 1);
 664         return ft;
 665 }
 666
 667
 668 static gint cmp_filetype(gconstpointer pft1, gconstpointer pft2)
 669 {
 670         const GeanyFiletype *ft1 = pft1, *ft2 = pft2;
 671
 672         if (G_UNLIKELY(ft1->id == GEANY_FILETYPES_NONE))
 673                 return -1;
 674         if (G_UNLIKELY(ft2->id == GEANY_FILETYPES_NONE))
 675                 return 1;
 676
 677         return utils_str_casecmp(ft1->title, ft2->title);
 678 }
 679
 680
 681 /* Add a filetype pointer to the lists of available filetypes,
 682  * and set the filetype::id field. */
 683 static void filetype_add(GeanyFiletype *ft)
 684 {
 685         g_return_if_fail(ft);
 686         g_return_if_fail(ft->name);
 687
 688         ft->id = filetypes_array->len;  /* len will be the index for filetype_array */
 689         g_ptr_array_add(filetypes_array, ft);
 690         g_hash_table_insert(filetypes_hash, ft->name, ft);
 691
 692         filetypes_by_title = g_slist_insert_sorted(filetypes_by_title, ft, cmp_filetype);
 693 }
 694
 695
 696 static void add_custom_filetype(const gchar *filename)
 697 {
 698         gchar *fn = utils_strdupa(strstr(filename, ".") + 1);
 699         gchar *dot = g_strrstr(fn, ".conf");
 700         GeanyFiletype *ft;
 701
 702         g_return_if_fail(dot);
 703
 704         *dot = 0x0;
 705
 706         if (g_hash_table_lookup(filetypes_hash, fn))
 707                 return;
 708
 709         ft = filetype_new();
 710         ft->name = g_strdup(fn);
 711         filetype_make_title(ft, TITLE_FILE);
 712         ft->pattern = g_new0(gchar*, 1);
 713         ft->group = GEANY_FILETYPE_GROUP_CUSTOM;
 714         ft->priv->custom = TRUE;
 715         filetype_add(ft);
 716         geany_debug("Added filetype %s (%d).", ft->name, ft->id);
 717 }
 718
 719
 720 static void init_custom_filetypes(const gchar *path)
 721 {
 722         GDir *dir;
 723         const gchar *filename;
 724
 725         g_return_if_fail(path);
 726
 727         dir = g_dir_open(path, 0, NULL);
 728         if (dir == NULL)
 729                 return;
 730
 731         foreach_dir(filename, dir)
 732         {
 733                 const gchar prefix[] = "filetypes.";
 734
 735                 if (g_str_has_prefix(filename, prefix) &&
 736                         g_str_has_suffix(filename + strlen(prefix), ".conf"))
 737                 {
 738                         add_custom_filetype(filename);
 739                 }
 740         }
 741         g_dir_close(dir);
 742 }
 743
 744
 745 /* Create the filetypes array and fill it with the known filetypes. */
 746 void filetypes_init_types()
 747 {
 748         filetype_id ft_id;
 749
 750         g_return_if_fail(filetypes_array == NULL);
 751         g_return_if_fail(filetypes_hash == NULL);
 752
 753         filetypes_array = g_ptr_array_sized_new(GEANY_MAX_BUILT_IN_FILETYPES);
 754         filetypes_hash = g_hash_table_new(g_str_hash, g_str_equal);
 755
 756         /* Create built-in filetypes */
 757         for (ft_id = 0; ft_id < GEANY_MAX_BUILT_IN_FILETYPES; ft_id++)
 758         {
 759                 filetypes[ft_id] = filetype_new();
 760         }
 761         init_builtin_filetypes();
 762
 763         /* Add built-in filetypes to the hash now the name fields are set */
 764         for (ft_id = 0; ft_id < GEANY_MAX_BUILT_IN_FILETYPES; ft_id++)
 765         {
 766                 filetype_add(filetypes[ft_id]);
 767         }
 768         init_custom_filetypes(app->datadir);
 769         init_custom_filetypes(utils_build_path(app->configdir, GEANY_FILEDEFS_SUBDIR, NULL));
 770 }
 771
 772
 773 static void on_document_save(G_GNUC_UNUSED GObject *object, GeanyDocument *doc)
 774 {
 775         g_return_if_fail(NZV(doc->real_path));
 776
 777         if (utils_str_equal(doc->real_path,
 778                 utils_build_path(app->configdir, "filetype_extensions.conf", NULL)))
 779                 filetypes_read_extensions();
 780         else if (utils_str_equal(doc->real_path,
 781                 utils_build_path(app->configdir, GEANY_FILEDEFS_SUBDIR, "filetypes.common", NULL)))
 782         {
 783                 guint i;
 784
 785                 /* Note: we don't reload other filetypes, even though the named styles may have changed.
 786                  * The user can do this manually with 'Tools->Reload Configuration' */
 787                 filetypes_load_config(GEANY_FILETYPES_NONE, TRUE);
 788
 789                 foreach_document(i)
 790                         document_reload_config(documents[i]);
 791         }
 792 }
 793
 794
 795 static void setup_config_file_menus(void)
 796 {
 797         ui_add_config_file_menu_item(
 798                 utils_build_path(app->configdir, "filetype_extensions.conf", NULL), NULL, NULL);
 799         ui_add_config_file_menu_item(
 800                 utils_build_path(app->configdir, GEANY_FILEDEFS_SUBDIR, "filetypes.common", NULL), NULL, NULL);
 801
 802         g_signal_connect(geany_object, "document-save", G_CALLBACK(on_document_save), NULL);
 803 }
 804
 805
 806 static GtkWidget *group_menus[GEANY_FILETYPE_GROUP_COUNT] = {NULL};
 807
 808 static void create_sub_menu(GtkWidget *parent, gsize group_id, const gchar *title)
 809 {
 810         GtkWidget *menu, *item;
 811
 812         menu = gtk_menu_new();
 813         item = gtk_menu_item_new_with_mnemonic((title));
 814         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu);
 815         gtk_container_add(GTK_CONTAINER(parent), item);
 816         gtk_widget_show(item);
 817         group_menus[group_id] = menu;
 818 }
 819
 820
 821 static void create_set_filetype_menu(void)
 822 {
 823         GSList *node;
 824         GtkWidget *filetype_menu = ui_lookup_widget(main_widgets.window, "set_filetype1_menu");
 825
 826         create_sub_menu(filetype_menu, GEANY_FILETYPE_GROUP_COMPILED, _("_Programming Languages"));
 827         create_sub_menu(filetype_menu, GEANY_FILETYPE_GROUP_SCRIPT, _("_Scripting Languages"));
 828         create_sub_menu(filetype_menu, GEANY_FILETYPE_GROUP_MARKUP, _("_Markup Languages"));
 829         create_sub_menu(filetype_menu, GEANY_FILETYPE_GROUP_MISC, _("M_iscellaneous Languages"));
 830         create_sub_menu(filetype_menu, GEANY_FILETYPE_GROUP_CUSTOM, _("_Custom Filetypes"));
 831
 832         /* Append all filetypes to the filetype menu */
 833         foreach_slist(node, filetypes_by_title)
 834         {
 835                 GeanyFiletype *ft = node->data;
 836
 837                 if (ft->group != GEANY_FILETYPE_GROUP_NONE)
 838                         create_radio_menu_item(group_menus[ft->group], ft);
 839                 else
 840                         create_radio_menu_item(filetype_menu, ft);
 841         }
 842 }
 843
 844
 845 void filetypes_init()
 846 {
 847         filetypes_init_types();
 848
 849         create_set_filetype_menu();
 850         setup_config_file_menus();
 851 }
 852
 853
 854 /* Find a filetype that predicate returns TRUE for, otherwise return NULL. */
 855 GeanyFiletype *filetypes_find(GCompareFunc predicate, gpointer user_data)
 856 {
 857         guint i;
 858
 859         for (i = 0; i < filetypes_array->len; i++)
 860         {
 861                 GeanyFiletype *ft = filetypes[i];
 862
 863                 if (predicate(ft, user_data))
 864                         return ft;
 865         }
 866         return NULL;
 867 }
 868
 869
 870 static gboolean match_basename(gconstpointer pft, gconstpointer user_data)
 871 {
 872         const GeanyFiletype *ft = pft;
 873         const gchar *base_filename = user_data;
 874         gint j;
 875         gboolean ret = FALSE;
 876
 877         if (G_UNLIKELY(ft->id == GEANY_FILETYPES_NONE))
 878                 return FALSE;
 879
 880         for (j = 0; ft->pattern[j] != NULL; j++)
 881         {
 882                 GPatternSpec *pattern = g_pattern_spec_new(ft->pattern[j]);
 883
 884                 if (g_pattern_match_string(pattern, base_filename))
 885                 {
 886                         ret = TRUE;
 887                         g_pattern_spec_free(pattern);
 888                         break;
 889                 }
 890                 g_pattern_spec_free(pattern);
 891         }
 892         return ret;
 893 }
 894
 895
 896 /* Detect filetype only based on the filename extension.
 897  * utf8_filename can include the full path. */
 898 GeanyFiletype *filetypes_detect_from_extension(const gchar *utf8_filename)
 899 {
 900         gchar *base_filename;
 901         GeanyFiletype *ft;
 902
 903         /* to match against the basename of the file (because of Makefile*) */
 904         base_filename = g_path_get_basename(utf8_filename);
 905 #ifdef G_OS_WIN32
 906         /* use lower case basename */
 907         setptr(base_filename, g_utf8_strdown(base_filename, -1));
 908 #endif
 909
 910         ft = filetypes_find(match_basename, base_filename);
 911         if (ft == NULL)
 912                 ft = filetypes[GEANY_FILETYPES_NONE];
 913
 914         g_free(base_filename);
 915         return ft;
 916 }
 917
 918
 919 /* This detects the filetype of the file pointed by 'utf8_filename' and a list of filetype id's,
 920  * terminated by -1.
 921  * The detected filetype of the file is checked against every id in the passed list and if
 922  * there is a match, TRUE is returned. */
 923 static gboolean shebang_find_and_match_filetype(const gchar *utf8_filename, gint first, ...)
 924 {
 925         GeanyFiletype *ft = NULL;
 926         gint test;
 927         gboolean result = FALSE;
 928         va_list args;
 929
 930         ft = filetypes_detect_from_extension(utf8_filename);
 931         if (ft == NULL || ft->id >= filetypes_array->len)
 932                 return FALSE;
 933
 934         va_start(args, first);
 935         test = first;
 936         while (1)
 937         {
 938                 if (test == -1)
 939                         break;
 940
 941                 if (ft->id == (guint) test)
 942                 {
 943                         result = TRUE;
 944                         break;
 945                 }
 946                 test = va_arg(args, gint);
 947         }
 948         va_end(args);
 949
 950         return result;
 951 }
 952
 953
 954 static GeanyFiletype *find_shebang(const gchar *utf8_filename, const gchar *line)
 955 {
 956         GeanyFiletype *ft = NULL;
 957
 958         if (strlen(line) > 2 && line[0] == '#' && line[1] == '!')
 959         {
 960                 gchar *tmp = g_path_get_basename(line + 2);
 961                 gchar *basename_interpreter = tmp;
 962
 963                 if (strncmp(tmp, "env ", 4) == 0 && strlen(tmp) > 4)
 964                 {       /* skip "env" and read the following interpreter */
 965                         basename_interpreter += 4;
 966                 }
 967
 968                 if (strncmp(basename_interpreter, "sh", 2) == 0)
 969                         ft = filetypes[GEANY_FILETYPES_SH];
 970                 else if (strncmp(basename_interpreter, "bash", 4) == 0)
 971                         ft = filetypes[GEANY_FILETYPES_SH];
 972                 else if (strncmp(basename_interpreter, "perl", 4) == 0)
 973                         ft = filetypes[GEANY_FILETYPES_PERL];
 974                 else if (strncmp(basename_interpreter, "python", 6) == 0)
 975                         ft = filetypes[GEANY_FILETYPES_PYTHON];
 976                 else if (strncmp(basename_interpreter, "php", 3) == 0)
 977                         ft = filetypes[GEANY_FILETYPES_PHP];
 978                 else if (strncmp(basename_interpreter, "ruby", 4) == 0)
 979                         ft = filetypes[GEANY_FILETYPES_RUBY];
 980                 else if (strncmp(basename_interpreter, "tcl", 3) == 0)
 981                         ft = filetypes[GEANY_FILETYPES_TCL];
 982                 else if (strncmp(basename_interpreter, "make", 4) == 0)
 983                         ft = filetypes[GEANY_FILETYPES_MAKE];
 984                 else if (strncmp(basename_interpreter, "zsh", 3) == 0)
 985                         ft = filetypes[GEANY_FILETYPES_SH];
 986                 else if (strncmp(basename_interpreter, "ksh", 3) == 0)
 987                         ft = filetypes[GEANY_FILETYPES_SH];
 988                 else if (strncmp(basename_interpreter, "csh", 3) == 0)
 989                         ft = filetypes[GEANY_FILETYPES_SH];
 990                 else if (strncmp(basename_interpreter, "ash", 3) == 0)
 991                         ft = filetypes[GEANY_FILETYPES_SH];
 992                 else if (strncmp(basename_interpreter, "dmd", 3) == 0)
 993                         ft = filetypes[GEANY_FILETYPES_D];
 994                 else if (strncmp(basename_interpreter, "wish", 4) == 0)
 995                         ft = filetypes[GEANY_FILETYPES_TCL];
 996
 997                 g_free(tmp);
 998         }
 999         /* detect HTML files */
1000         if (strncmp(line, "<!DOCTYPE html", 14) == 0 || strncmp(line, "<html", 5) == 0)
1001         {
1002                 /* PHP, Perl and Python files might also start with <html, so detect them based on filename
1003                  * extension and use the detected filetype, else assume HTML */
1004                 if (! shebang_find_and_match_filetype(utf8_filename,
1005                                 GEANY_FILETYPES_PERL, GEANY_FILETYPES_PHP, GEANY_FILETYPES_PYTHON, -1))
1006                 {
1007                         ft = filetypes[GEANY_FILETYPES_HTML];
1008                 }
1009         }
1010         /* detect XML files */
1011         else if (utf8_filename && strncmp(line, "<?xml", 5) == 0)
1012         {
1013                 /* HTML and DocBook files might also start with <?xml, so detect them based on filename
1014                  * extension and use the detected filetype, else assume XML */
1015                 if (! shebang_find_and_match_filetype(utf8_filename,
1016                                 GEANY_FILETYPES_HTML, GEANY_FILETYPES_DOCBOOK,
1017                                 /* Perl, Python and PHP only to be safe */
1018                                 GEANY_FILETYPES_PERL, GEANY_FILETYPES_PHP, GEANY_FILETYPES_PYTHON, -1))
1019                 {
1020                         ft = filetypes[GEANY_FILETYPES_XML];
1021                 }
1022         }
1023         else if (strncmp(line, "<?php", 5) == 0)
1024         {
1025                 ft = filetypes[GEANY_FILETYPES_PHP];
1026         }
1027
1028         return ft;
1029 }
1030
1031
1032 /* Detect the filetype checking for a shebang, then filename extension. */
1033 static GeanyFiletype *filetypes_detect_from_file_internal(const gchar *utf8_filename,
1034                                                                                                                   const gchar *line)
1035 {
1036         GeanyFiletype *ft;
1037
1038         /* try to find a shebang and if found use it prior to the filename extension
1039          * also checks for <?xml */
1040         ft = find_shebang(utf8_filename, line);
1041         if (ft != NULL)
1042                 return ft;
1043
1044         if (utf8_filename == NULL)
1045                 return filetypes[GEANY_FILETYPES_NONE];
1046
1047         return filetypes_detect_from_extension(utf8_filename);
1048 }
1049
1050
1051 /* Detect the filetype for the document, checking for a shebang, then filename extension. */
1052 GeanyFiletype *filetypes_detect_from_document(GeanyDocument *doc)
1053 {
1054         GeanyFiletype *ft;
1055         gchar *line;
1056
1057         if (doc == NULL)
1058                 return filetypes[GEANY_FILETYPES_NONE];
1059
1060         line = sci_get_line(doc->editor->sci, 0);
1061         ft = filetypes_detect_from_file_internal(doc->file_name, line);
1062         g_free(line);
1063         return ft;
1064 }
1065
1066
1067 #ifdef HAVE_PLUGINS
1068 /* Currently only used by external plugins (e.g. geanyprj). */
1069 /**
1070  *  Detects filetype based on a shebang line in the file or the filename extension.
1071  *
1072  *  @param utf8_filename The filename in UTF-8 encoding.
1073  *
1074  *  @return The detected filetype for @a utf8_filename or @c filetypes[GEANY_FILETYPES_NONE]
1075  *          if it could not be detected.
1076  **/
1077 GeanyFiletype *filetypes_detect_from_file(const gchar *utf8_filename)
1078 {
1079         gchar line[1024];
1080         FILE *f;
1081         gchar *locale_name = utils_get_locale_from_utf8(utf8_filename);
1082
1083         f = g_fopen(locale_name, "r");
1084         g_free(locale_name);
1085         if (f != NULL)
1086         {
1087                 if (fgets(line, sizeof(line), f) != NULL)
1088                 {
1089                         fclose(f);
1090                         return filetypes_detect_from_file_internal(utf8_filename, line);
1091                 }
1092                 fclose(f);
1093         }
1094         return filetypes_detect_from_extension(utf8_filename);
1095 }
1096 #endif
1097
1098
1099 void filetypes_select_radio_item(const GeanyFiletype *ft)
1100 {
1101         /* ignore_callback has to be set by the caller */
1102         g_return_if_fail(ignore_callback);
1103
1104         if (ft == NULL)
1105                 ft = filetypes[GEANY_FILETYPES_NONE];
1106
1107         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ft->priv->menu_item), TRUE);
1108 }
1109
1110
1111 static void
1112 on_filetype_change                     (GtkCheckMenuItem     *menuitem,
1113                                         gpointer         user_data)
1114 {
1115         GeanyDocument *doc = document_get_current();
1116         if (ignore_callback || doc == NULL || ! gtk_check_menu_item_get_active(menuitem))
1117                 return;
1118
1119         document_set_filetype(doc, (GeanyFiletype*)user_data);
1120 }
1121
1122
1123 static void create_radio_menu_item(GtkWidget *menu, GeanyFiletype *ftype)
1124 {
1125         static GSList *group = NULL;
1126         GtkWidget *tmp;
1127
1128         tmp = gtk_radio_menu_item_new_with_label(group, ftype->title);
1129         group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(tmp));
1130         ftype->priv->menu_item = tmp;
1131         gtk_widget_show(tmp);
1132         gtk_container_add(GTK_CONTAINER(menu), tmp);
1133         g_signal_connect(tmp, "activate", G_CALLBACK(on_filetype_change), (gpointer) ftype);
1134 }
1135
1136
1137 #if 0
1138 /* Remove a filetype pointer from the list of available filetypes. */
1139 static void filetype_remove(GeanyFiletype *ft)
1140 {
1141         g_return_if_fail(ft);
1142
1143         g_ptr_array_remove(filetypes_array, ft);
1144
1145         if (!g_hash_table_remove(filetypes_hash, ft))
1146                 g_warning("Could not remove filetype %p!", ft);
1147 }
1148 #endif
1149
1150
1151 static void set_error_regex(GeanyFiletype *ft, gchar *string)
1152 {
1153         setptr(ft->error_regex_string, string);
1154
1155 #ifdef HAVE_REGCOMP
1156         if (ft->priv->error_regex_compiled)
1157                 regfree(&ft->priv->error_regex);
1158
1159         ft->priv->error_regex_compiled = FALSE;
1160         /* regex will be compiled when needed */
1161 #endif
1162 }
1163
1164
1165 static void filetype_free(gpointer data, G_GNUC_UNUSED gpointer user_data)
1166 {
1167         GeanyFiletype *ft = data;
1168
1169         g_return_if_fail(ft != NULL);
1170
1171         g_free(ft->name);
1172         g_free(ft->title);
1173         g_free(ft->extension);
1174         g_free(ft->comment_open);
1175         g_free(ft->comment_close);
1176         g_free(ft->context_action_cmd);
1177         g_free(ft->filecmds);
1178         g_free(ft->ftdefcmds);
1179         g_free(ft->execcmds);
1180         set_error_regex(ft, NULL);
1181
1182         g_strfreev(ft->pattern);
1183         g_free(ft->priv);
1184         g_free(ft);
1185 }
1186
1187
1188 /* frees the array and all related pointers */
1189 void filetypes_free_types(void)
1190 {
1191         g_return_if_fail(filetypes_array != NULL);
1192         g_return_if_fail(filetypes_hash != NULL);
1193
1194         g_ptr_array_foreach(filetypes_array, filetype_free, NULL);
1195         g_ptr_array_free(filetypes_array, TRUE);
1196         g_hash_table_destroy(filetypes_hash);
1197 }
1198
1199
1200 static void load_settings(gint ft_id, GKeyFile *config, GKeyFile *configh)
1201 {
1202         GeanyFiletype *ft = filetypes[ft_id];
1203         gchar *result;
1204         GError *error = NULL;
1205         gboolean tmp;
1206
1207         /* default extension */
1208         result = g_key_file_get_string(configh, "settings", "extension", NULL);
1209         if (result == NULL) result = g_key_file_get_string(config, "settings", "extension", NULL);
1210         if (G_LIKELY(result != NULL))
1211         {
1212                 setptr(filetypes[ft_id]->extension, result);
1213         }
1214
1215         /* read comment notes */
1216         result = g_key_file_get_string(configh, "settings", "comment_open", NULL);
1217         if (result == NULL) result = g_key_file_get_string(config, "settings", "comment_open", NULL);
1218         if (G_LIKELY(result != NULL))
1219         {
1220                 g_free(filetypes[ft_id]->comment_open);
1221                 filetypes[ft_id]->comment_open = result;
1222         }
1223
1224         result = g_key_file_get_string(configh, "settings", "comment_close", NULL);
1225         if (result == NULL) result = g_key_file_get_string(config, "settings", "comment_close", NULL);
1226         if (G_LIKELY(result != NULL))
1227         {
1228                 g_free(filetypes[ft_id]->comment_close);
1229                 filetypes[ft_id]->comment_close = result;
1230         }
1231
1232         tmp = g_key_file_get_boolean(configh, "settings", "comment_use_indent", &error);
1233         if (error)
1234         {
1235                 g_error_free(error);
1236                 error = NULL;
1237                 tmp = g_key_file_get_boolean(config, "settings", "comment_use_indent", &error);
1238                 if (error) g_error_free(error);
1239                 else filetypes[ft_id]->comment_use_indent = tmp;
1240         }
1241         else filetypes[ft_id]->comment_use_indent = tmp;
1242
1243         /* read context action */
1244         result = g_key_file_get_string(configh, "settings", "context_action_cmd", NULL);
1245         if (result == NULL) result = g_key_file_get_string(config, "settings", "context_action_cmd", NULL);
1246         if (G_LIKELY(result != NULL))
1247         {
1248                 filetypes[ft_id]->context_action_cmd = result;
1249         }
1250
1251         result = utils_get_setting_string(configh, "settings", "tag_parser", NULL);
1252         if (!result)
1253                 result = utils_get_setting_string(config, "settings", "tag_parser", NULL);
1254         if (result)
1255         {
1256                 ft->lang = tm_source_file_get_named_lang(result);
1257                 if (ft->lang < 0)
1258                         geany_debug("Cannot find tag parser '%s' for custom filetype '%s'.", result, ft->name);
1259                 g_free(result);
1260         }
1261
1262         result = utils_get_setting_string(configh, "settings", "lexer_filetype", NULL);
1263         if (!result)
1264                 result = utils_get_setting_string(config, "settings", "lexer_filetype", NULL);
1265         if (result)
1266         {
1267                 ft->lexer_filetype = filetypes_lookup_by_name(result);
1268                 if (!ft->lexer_filetype)
1269                         geany_debug("Cannot find lexer filetype '%s' for custom filetype '%s'.", result, ft->name);
1270                 g_free(result);
1271         }
1272
1273         /* read build settings */
1274         build_load_menu(config, GEANY_BCS_FT, (gpointer)ft);
1275         build_load_menu(configh, GEANY_BCS_HOME_FT, (gpointer)ft);
1276 }
1277
1278
1279 /* simple wrapper function to print file errors in DEBUG mode */
1280 static void load_system_keyfile(GKeyFile *key_file, const gchar *file, GKeyFileFlags flags,
1281                 GeanyFiletype *ft)
1282 {
1283         GError *error = NULL;
1284         gboolean done = g_key_file_load_from_file(key_file, file, flags, &error);
1285
1286         if (error != NULL)
1287         {
1288                 if (!done && !ft->priv->custom)
1289                         geany_debug("Failed to open %s (%s)", file, error->message);
1290
1291                 g_error_free(error);
1292                 error = NULL;
1293         }
1294 }
1295
1296
1297 /* Load the configuration file for the associated filetype id.
1298  * This should only be called when the filetype is needed, to save loading
1299  * 20+ configuration files all at once. */
1300 void filetypes_load_config(gint ft_id, gboolean reload)
1301 {
1302         GKeyFile *config, *config_home;
1303         GeanyFiletypePrivate *pft;
1304         GeanyFiletype *ft;
1305
1306         g_return_if_fail(ft_id >= 0 && ft_id < (gint) filetypes_array->len);
1307
1308         ft = filetypes[ft_id];
1309         pft = ft->priv;
1310
1311         /* when reloading, proceed only if the settings were already loaded */
1312         if (reload && G_UNLIKELY(! pft->keyfile_loaded))
1313                 return;
1314
1315         /* when not reloading, load the settings only once */
1316         if (! reload && G_LIKELY(pft->keyfile_loaded))
1317                 return;
1318         pft->keyfile_loaded = TRUE;
1319
1320         config = g_key_file_new();
1321         config_home = g_key_file_new();
1322         {
1323                 /* highlighting uses GEANY_FILETYPES_NONE for common settings */
1324                 gchar *ext = (ft_id != GEANY_FILETYPES_NONE) ?
1325                         filetypes_get_conf_extension(ft_id) : g_strdup("common");
1326                 gchar *f0 = g_strconcat(app->datadir, G_DIR_SEPARATOR_S "filetypes.", ext, NULL);
1327                 gchar *f = g_strconcat(app->configdir,
1328                         G_DIR_SEPARATOR_S GEANY_FILEDEFS_SUBDIR G_DIR_SEPARATOR_S "filetypes.", ext, NULL);
1329
1330                 load_system_keyfile(config, f0, G_KEY_FILE_KEEP_COMMENTS, ft);
1331                 g_key_file_load_from_file(config_home, f, G_KEY_FILE_KEEP_COMMENTS, NULL);
1332
1333                 g_free(ext);
1334                 g_free(f);
1335                 g_free(f0);
1336         }
1337
1338         load_settings(ft_id, config, config_home);
1339         highlighting_init_styles(ft_id, config, config_home);
1340
1341         g_key_file_free(config);
1342         g_key_file_free(config_home);
1343 }
1344
1345
1346 gchar *filetypes_get_conf_extension(gint filetype_idx)
1347 {
1348         gchar *result;
1349         GeanyFiletype *ft = filetypes[filetype_idx];
1350
1351         if (ft->priv->custom)
1352                 return g_strconcat(ft->name, ".conf", NULL);
1353
1354         /* Handle any special extensions different from lowercase filetype->name */
1355         switch (filetype_idx)
1356         {
1357                 case GEANY_FILETYPES_CPP: result = g_strdup("cpp"); break;
1358                 case GEANY_FILETYPES_CS: result = g_strdup("cs"); break;
1359                 case GEANY_FILETYPES_MAKE: result = g_strdup("makefile"); break;
1360                 default: result = g_ascii_strdown(ft->name, -1); break;
1361         }
1362         return result;
1363 }
1364
1365
1366 void filetypes_save_commands(void)
1367 {
1368         gchar *conf_prefix = g_strconcat(app->configdir,
1369                 G_DIR_SEPARATOR_S GEANY_FILEDEFS_SUBDIR G_DIR_SEPARATOR_S "filetypes.", NULL);
1370         guint i;
1371
1372         for (i = 1; i < filetypes_array->len; i++)
1373         {
1374                 GKeyFile *config_home;
1375                 gchar *fname, *ext, *data;
1376
1377                 if (filetypes[i]->home_save_needed)
1378                 {
1379                         ext = filetypes_get_conf_extension(i);
1380                         fname = g_strconcat(conf_prefix, ext, NULL);
1381                         g_free(ext);
1382                         config_home = g_key_file_new();
1383                         g_key_file_load_from_file(config_home, fname, G_KEY_FILE_KEEP_COMMENTS, NULL);
1384                         build_save_menu(config_home, (gpointer)(filetypes[i]), GEANY_BCS_HOME_FT);
1385                         data = g_key_file_to_data(config_home, NULL, NULL);
1386                         utils_write_file(fname, data);
1387                         g_free(data);
1388                         g_key_file_free(config_home);
1389                         g_free(fname);
1390                 }
1391         }
1392         g_free(conf_prefix);
1393 }
1394
1395
1396 /* create one file filter which has each file pattern of each filetype */
1397 GtkFileFilter *filetypes_create_file_filter_all_source(void)
1398 {
1399         GtkFileFilter *new_filter;
1400         guint i, j;
1401
1402         new_filter = gtk_file_filter_new();
1403         gtk_file_filter_set_name(new_filter, _("All Source"));
1404
1405         for (i = 0; i < filetypes_array->len; i++)
1406         {
1407                 if (G_UNLIKELY(i == GEANY_FILETYPES_NONE))
1408                         continue;
1409
1410                 for (j = 0; filetypes[i]->pattern[j]; j++)
1411                 {
1412                         gtk_file_filter_add_pattern(new_filter, filetypes[i]->pattern[j]);
1413                 }
1414         }
1415         return new_filter;
1416 }
1417
1418
1419 GtkFileFilter *filetypes_create_file_filter(const GeanyFiletype *ft)
1420 {
1421         GtkFileFilter *new_filter;
1422         gint i;
1423         const gchar *title;
1424
1425         g_return_val_if_fail(ft != NULL, NULL);
1426
1427         new_filter = gtk_file_filter_new();
1428         title = ft->id == GEANY_FILETYPES_NONE ? _("All files") : ft->title;
1429         gtk_file_filter_set_name(new_filter, title);
1430
1431         for (i = 0; ft->pattern[i]; i++)
1432         {
1433                 gtk_file_filter_add_pattern(new_filter, ft->pattern[i]);
1434         }
1435
1436         return new_filter;
1437 }
1438
1439
1440 /* Indicates whether there is a tag parser for the filetype or not.
1441  * Only works for custom filetypes if the filetype settings have been loaded. */
1442 gboolean filetype_has_tags(GeanyFiletype *ft)
1443 {
1444         g_return_val_if_fail(ft != NULL, FALSE);
1445
1446         return ft->lang >= 0;
1447 }
1448
1449
1450 /** Finds a filetype pointer from its @a name field.
1451  * @param name Filetype name.
1452  * @return The filetype found, or @c NULL.
1453  *
1454  * @since 0.15
1455  **/
1456 GeanyFiletype *filetypes_lookup_by_name(const gchar *name)
1457 {
1458         GeanyFiletype *ft;
1459
1460         g_return_val_if_fail(NZV(name), NULL);
1461
1462         ft = g_hash_table_lookup(filetypes_hash, name);
1463         if (G_UNLIKELY(ft == NULL))
1464                 geany_debug("Could not find filetype '%s'.", name);
1465         return ft;
1466 }
1467
1468
1469 #ifdef HAVE_REGCOMP
1470 static gchar *get_regex_match_string(const gchar *message, regmatch_t *pmatch, gint match_idx)
1471 {
1472         return g_strndup(&message[pmatch[match_idx].rm_so],
1473                 pmatch[match_idx].rm_eo - pmatch[match_idx].rm_so);
1474 }
1475
1476
1477 static void compile_regex(GeanyFiletype *ft, regex_t *regex, gchar *regstr)
1478 {
1479         gint retval = regcomp(regex, regstr, REG_EXTENDED);
1480
1481         ft->priv->error_regex_compiled = (retval == 0); /* prevent recompilation */
1482
1483         if (G_UNLIKELY(retval != 0))
1484         {
1485                 gchar buf[256];
1486                 regerror(retval, regex, buf, sizeof buf);
1487                 ui_set_statusbar(TRUE, _("Bad regex for filetype %s: %s"),
1488                         ft->name, buf);
1489         }
1490         /* regex will be freed in set_error_regex(). */
1491 }
1492 #endif
1493
1494
1495 gboolean filetypes_parse_error_message(GeanyFiletype *ft, const gchar *message,
1496                 gchar **filename, gint *line)
1497 {
1498         gchar *regstr;
1499         gchar **tmp;
1500         GeanyDocument *doc;
1501 #ifdef HAVE_REGCOMP
1502         regex_t *regex;
1503         regmatch_t pmatch[3];
1504 #endif
1505         if (ft == NULL)
1506         {
1507                 doc = document_get_current();
1508                 if (doc != NULL)
1509                         ft = doc->file_type;
1510         }
1511         tmp = build_get_regex(build_info.grp, ft, NULL);
1512         if (tmp == NULL)
1513                 return FALSE;
1514         regstr = *tmp;
1515 #ifndef HAVE_REGCOMP
1516         if (!NZV(regstr))
1517                 geany_debug("No regex support - maybe you should configure with --enable-gnu-regex!");
1518         return FALSE;
1519 #else
1520         regex = &ft->priv->error_regex;
1521
1522         *filename = NULL;
1523         *line = -1;
1524
1525         if (!NZV(regstr))
1526                 return FALSE;
1527
1528         if (!ft->priv->error_regex_compiled || regstr != ft->priv->last_string)
1529         {
1530                 compile_regex(ft, regex, regstr);
1531                 ft->priv->last_string = regstr;
1532         }
1533         if (!ft->priv->error_regex_compiled)    /* regex error */
1534                 return FALSE;
1535
1536         if (regexec(regex, message, G_N_ELEMENTS(pmatch), pmatch, 0) != 0)
1537                 return FALSE;
1538
1539         if (pmatch[0].rm_so != -1 && pmatch[1].rm_so != -1 && pmatch[2].rm_so != -1)
1540         {
1541                 gchar *first, *second, *end;
1542                 glong l;
1543
1544                 first = get_regex_match_string(message, pmatch, 1);
1545                 second = get_regex_match_string(message, pmatch, 2);
1546                 l = strtol(first, &end, 10);
1547                 if (*end == '\0')       /* first is purely decimals */
1548                 {
1549                         *line = l;
1550                         g_free(first);
1551                         *filename = second;
1552                 }
1553                 else
1554                 {
1555                         l = strtol(second, &end, 10);
1556                         if (*end == '\0')
1557                         {
1558                                 *line = l;
1559                                 g_free(second);
1560                                 *filename = first;
1561                         }
1562                         else
1563                         {
1564                                 g_free(first);
1565                                 g_free(second);
1566                         }
1567                 }
1568         }
1569         return *filename != NULL;
1570 #endif
1571 }
1572
1573
1574 void filetypes_read_extensions(void)
1575 {
1576         guint i;
1577         gsize len = 0;
1578         gchar *sysconfigfile = g_strconcat(app->datadir, G_DIR_SEPARATOR_S,
1579                 "filetype_extensions.conf", NULL);
1580         gchar *userconfigfile = g_strconcat(app->configdir, G_DIR_SEPARATOR_S,
1581                 "filetype_extensions.conf", NULL);
1582         GKeyFile *sysconfig = g_key_file_new();
1583         GKeyFile *userconfig = g_key_file_new();
1584
1585         g_key_file_load_from_file(sysconfig, sysconfigfile, G_KEY_FILE_NONE, NULL);
1586         g_key_file_load_from_file(userconfig, userconfigfile, G_KEY_FILE_NONE, NULL);
1587
1588         /* read the keys */
1589         for (i = 0; i < filetypes_array->len; i++)
1590         {
1591                 gboolean userset =
1592                         g_key_file_has_key(userconfig, "Extensions", filetypes[i]->name, NULL);
1593                 gchar **list = g_key_file_get_string_list(
1594                         (userset) ? userconfig : sysconfig, "Extensions", filetypes[i]->name, &len, NULL);
1595
1596                 if (G_LIKELY(list) && G_LIKELY(len > 0))
1597                 {
1598                         g_strfreev(filetypes[i]->pattern);
1599                         filetypes[i]->pattern = list;
1600                 }
1601                 else
1602                         g_strfreev(list);
1603         }
1604
1605         g_free(sysconfigfile);
1606         g_free(userconfigfile);
1607         g_key_file_free(sysconfig);
1608         g_key_file_free(userconfig);
1609
1610         foreach_document(i)
1611         {
1612                 GeanyDocument *doc = documents[i];
1613                 if (doc->file_type->id != GEANY_FILETYPES_NONE)
1614                         continue;
1615                 document_set_filetype(doc, filetypes_detect_from_document(doc));
1616         }
1617 }
1618
1619
1620 /** Accessor function for @ref GeanyData::filetypes_array items.
1621  * Example: @code ft = filetypes_index(GEANY_FILETYPES_C); @endcode
1622  * @param idx @c filetypes_array index.
1623  * @return The filetype, or @c NULL if @a idx is out of range.
1624  *
1625  *  @since 0.16
1626  */
1627 GeanyFiletype *filetypes_index(gint idx)
1628 {
1629         return (idx >= 0 && idx < (gint) filetypes_array->len) ? filetypes[idx] : NULL;
1630 }
1631
1632
1633 void filetypes_reload(void)
1634 {
1635         guint i;
1636         GeanyDocument *current_doc;
1637
1638         /* save possibly changed commands before re-reading them */
1639         filetypes_save_commands();
1640
1641         /* reload filetype configs */
1642         for (i = 0; i < filetypes_array->len; i++)
1643         {
1644                 /* filetypes_load_config() will skip not loaded filetypes */
1645                 filetypes_load_config(i, TRUE);
1646         }
1647         /* update document styling */
1648         current_doc = document_get_current();
1649         foreach_document(i)
1650         {
1651                 if (current_doc != documents[i])
1652                         document_reload_config(documents[i]);
1653         }
1654         /* process the current document at last */
1655         document_reload_config(current_doc);
1656 }
1657
1658