path: root/modules/text-highlight/languages.c

/*
 * languages.c
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with the program; if not, see <http://www.gnu.org/licenses/>
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "languages.h"

#include <glib/gi18n-lib.h>

static const gchar **mime_types = NULL;
G_LOCK_DEFINE_STATIC (mime_types);

static Language languages[] = {

    { "txt", N_("_Plain text"),
      (const gchar *[]) { (gchar[]) { "text" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/plain" },
                  (gchar[]) { "text/*" }, NULL }
    },

    { "assembler", N_("_Assembler"),
      (const gchar *[]) { (gchar[]) { "asm" } , NULL },
      (const gchar *[]) { (gchar[]) { "text/x-asm" }, NULL }
    },

    { "sh", N_("_Bash"),
      (const gchar *[]) { (gchar[]) { "bash" }, (gchar[]) { "sh" },
                  (gchar[]) { "ebuild" },  (gchar[])  {"eclass" },
                  NULL },
      (const gchar *[]) { (gchar[]) { "application/x-bsh" },
                  (gchar[]) { "application/x-sh" },
                  (gchar[]) { "application/x-shar" },
                  (gchar[]) { "application/x-shellscript" },
                  (gchar[]) { "text/x-script.sh" }, NULL }
    },

    { "c", N_("_C/C++"),
      (const gchar *[]) { (gchar[]) { "c" }, (gchar[]) { "c++" },
                  (gchar[]) { "cc" }, (gchar[]) { "cpp" },
                  (gchar[]) { "cu" }, (gchar[]) { "cxx" },
                  (gchar[]) { "h" }, (gchar[]) { "hh" },
                  (gchar[]) { "hpp" }, (gchar[]) { "hxx" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-c" }, NULL }
    },

    { "csharp", N_("_C#"),
      (const gchar *[]) { (gchar[]) { "cs" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-csharp" }, NULL }
    },

    { "css", N_("_Cascade Style Sheet"),
      (const gchar *[]) { (gchar[]) { "css" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/css" }, NULL }
    },

    { "html", N_("_HTML"),
      (const gchar *[]) { (gchar[]) { "html" }, (gchar[]) { "html" },
                  (gchar[]) { "xhtml" }, (gchar[]) { "dhtml" }, NULL },
      (const gchar *[]) { NULL } /* Don't register text-highlight as formatter
                    or parser of text / html as it would break
                    all text / html emails. */
    },

    { "java", N_("_Java"),
      (const gchar *[]) { (gchar[]) { "java" }, (gchar[]) { "groovy" },
                  (gchar[]) { "grv" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/java-source" }, NULL }
    },

    { "js", N_("_JavaScript"),
      (const gchar *[]) { (gchar[]) { "js" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/javascript" },
                  (gchar[]) { "application/x-javascript" }, NULL }
    },

    { "diff", N_("_Patch/diff"),
      (const gchar *[]) { (gchar[]) { "diff" }, (gchar[]) { "patch" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-diff" },
                  (gchar[]) { "text/x-patch" }, NULL }
    },

    { "perl", N_("_Perl"),
      (const gchar *[]) { (gchar[]) { "perl" }, (gchar[]) { "cgi"},
                  (gchar[]) { "perl" }, (gchar[]) { "pl" },
                  (gchar[]) { "plex" }, (gchar[]) { "plx" },
                  (gchar[]) { "pm" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-script.perl" },
                  (gchar[]) { "text/x-script.perl-module" },
                  (gchar[]) { "application/x-pixclscript" },
                  (gchar[]) { "application/x-xpixmap" }, NULL }
    },

    { "php", N_("_PHP"),
      (const gchar *[]) { (gchar[]) { "php" }, (gchar[]) { "php3" },
                  (gchar[]) { "php4" }, (gchar[]) { "php5" },
                  (gchar[]) { "php6" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/php" },
                  (gchar[]) { "text/x-php" },
                  (gchar[]) { "application/php" },
                  (gchar[]) { "application/x-php" },
                  (gchar[]) { "application/x-httpd-php" },
                  (gchar[]) { "application/x-httpd-php-source" },
                  NULL }
    },

    { "python", N_("_Python"),
      (const gchar *[]) { (gchar[]) { "py" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-script.python" }, NULL }
    },

    { "ruby", N_("_Ruby"),
      (const gchar *[]) { (gchar[]) { "ruby" }, (gchar[]) { "pp" },
                  (gchar[]) { "rb" }, (gchar[]) { "rjs" },
                  (gchar[]) { "ruby" }, NULL },
      (const gchar *[]) { (gchar[]) { "application/x-ruby" }, NULL }
    },

    { "tcl", N_("_Tcl/Tk"),
      (const gchar *[]) { (gchar[]) { "tcl" }, (gchar[]) { "ictl" },
                  (gchar[]) { "wish" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-tcl" }, NULL }
    },

    { "tex", N_("_TeX/LaTeX"),
      (const gchar *[]) { (gchar[]) { "tex" }, (gchar[]) { "csl" },
                  (gchar[]) { "sty" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-tex" }, NULL }
    },

    { "vala", N_("_Vala"),
      (const gchar *[]) { (gchar[]) { "vala" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-vala" }, NULL }
    },

    { "vb", N_("_Visual Basic"),
      (const gchar *[]) { (gchar[]) { "vb" }, (gchar[]) { "bas" },
                  (gchar[]) { "basic" }, (gchar[]) { "bi" },
                  (gchar[]) { "vbs" }, NULL },
      (const gchar *[]) { NULL }
    },

    { "xml", N_("_XML"),
      (const gchar *[]) { (gchar[]) { "xml" }, (gchar[]) { "dtd" },
                  (gchar[]) { "ecf" }, (gchar[]) { "ent" },
                  (gchar[]) { "hdr" }, (gchar[]) { "hub" },
                  (gchar[]) { "jnlp" }, (gchar[]) { "nrm" },
                  (gchar[]) { "resx" }, (gchar[]) { "sgm" },
                  (gchar[]) { "sgml" }, (gchar[]) { "svg" },
                  (gchar[]) { "tld" }, (gchar[]) { "vxml" },
                  (gchar[]) { "wml" }, (gchar[]) { "xsd" },
                  (gchar[]) { "xsl" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/xml" },
                  (gchar[]) { "application/xml" },
                  (gchar[]) { "application/x-xml" }, NULL }
    }
};

static struct Language other_languages[] = {

    { "actionscript", N_("_ActionScript"),
      (const gchar *[]) { (gchar[]) { "as" }, NULL },
      (const gchar *[]) { NULL }
    },

    { "ada", N_("_ADA95"),
      (const gchar *[]) { (gchar[]) { "a" }, (gchar[]) { "adb" },
                  (gchar[]) { "ads" }, (gchar[]) { "gnad" },
                  NULL },
      (const gchar *[]) { (gchar[]) { "text/x-adasrc" }, NULL }
    },

    { "algol", N_("_ALGOL 68"),
      (const gchar *[]) { (gchar[]) { "alg" }, NULL },
      (const gchar *[]) { NULL }
    },

    { "awk", N_("(_G)AWK"),
      (const gchar *[]) { (gchar[]) { "awk" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-awk" }, NULL }
    },

    { "cobol", N_("_COBOL"),
      (const gchar *[]) { (gchar[]) { "cbl" }, (gchar[]) { "cob" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-cobol" }, NULL }
    },

    { "bat", N_("_DOS Batch"),
      (const gchar *[]) { (gchar[]) { "bat" }, (gchar[]) { "cmd" }, NULL },
      (const gchar *[]) { NULL }
    },

    { "d", N_("_D"),
      (const gchar *[]) { (gchar[]) { "d" }, NULL },
      (const gchar *[]) { NULL }
    },

    { "erlang", N_("_Erlang"),
      (const gchar *[]) { (gchar[]) { "erl" }, (gchar[]) { "hrl" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-erlang" }, NULL }
    },

    { "fortran77", N_("_FORTRAN 77"),
      (const gchar *[]) { (gchar[]) { "f" }, (gchar[]) { "for" },
                  (gchar[]) { "ftn" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-fortran" }, NULL }
    },

    { "fortran90", N_("_FORTRAN 90"),
      (const gchar *[]) { (gchar[]) { "f90" }, (gchar[]) { "f95" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-fortran" }, NULL }
    },

    { "fsharp", N_("_F#"),
      (const gchar *[]) { (gchar[]) { "fs" }, (gchar[]) { "fsx" }, NULL },
      (const gchar *[]) { NULL }
    },

    { "go", N_("_Go"),
      (const gchar *[]) { (gchar[]) { "go" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-go" }, NULL }
    },

    { "haskell", N_("_Haskell"),
      (const gchar *[]) { (gchar[]) { "hs" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-haskell" }, NULL }
    },

    { "jsp", N_("_JSP"),
      (const gchar *[]) { (gchar[]) { "jsp" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-jsp" }, NULL }
    },

    { "lisp", N_("_Lisp"),
      (const gchar *[]) { (gchar[]) { "cl" }, (gchar[]) { "clisp" },
                  (gchar[]) { "el" }, (gchar[]) { "lsp" },
                  (gchar[]) { "sbcl"}, (gchar[]) { "scom" },
                  NULL },
      (const gchar *[]) { (gchar[]) { "text/x-emacs-lisp" }, NULL }
    },

    { "lotus", N_("_Lotus"),
      (const gchar *[]) { (gchar[]) { "ls" }, NULL },
      (const gchar *[]) { (gchar[]) { "application/vnd.lotus-1-2-3" }, NULL }
    },

    { "lua", N_("_Lua"),
      (const gchar *[]) { (gchar[]) { "lua" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-lua" }, NULL }
    },

    { "maple", N_("_Maple"),
      (const gchar *[]) { (gchar[]) { "mpl" }, NULL },
      (const gchar *[]) { NULL }
    },

    { "matlab", N_("_Matlab"),
      (const gchar *[]) { (gchar[]) { "m" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-matlab" }, NULL }
    },

    { "maya", N_("_Maya"),
      (const gchar *[]) { (gchar[]) { "mel" }, NULL },
      (const gchar *[]) { NULL }
    },

    { "oberon", N_("_Oberon"),
      (const gchar *[]) { (gchar[]) { "ooc" }, NULL },
      (const gchar *[]) { NULL }
    },

    { "objc", N_("_Objective C"),
      (const gchar *[]) { (gchar[]) { "objc" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-objchdr" },
                  (gchar[]) { "text/x-objcsrc" }, NULL }
    },

    { "ocaml", N_("_OCaml"),
      (const gchar *[]) { (gchar[]) { "ml" }, (gchar[]) { "mli" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-ocaml" }, NULL }
    },

    { "octave", N_("_Octave"),
      (const gchar *[]) { (gchar[]) { "octave" }, NULL },
      (const gchar *[]) { NULL }
    },

    { "os", N_("_Object Script"),
      (const gchar *[]) { (gchar[]) { "os" }, NULL },
      (const gchar *[]) { NULL }
    },

    { "pascal", N_("_Pascal"),
      (const gchar *[]) { (gchar[]) { "pas" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-pascal" }, NULL }
    },

    { "pov", N_("_POV-Ray"),
      (const gchar *[]) { (gchar[]) { "pov" }, NULL },
      (const gchar *[]) { NULL }
    },

    { "pro", N_("_Prolog"),
      (const gchar *[]) { (gchar[]) { "pro" }, NULL },
      (const gchar *[]) { NULL }
    },

    { "ps", N_("_PostScript"),
      (const gchar *[]) { (gchar[]) { "ps" } , NULL },
      (const gchar *[]) { (gchar[]) { "application/postscript" }, NULL }
    },

    { "r", N_("_R"),
      (const gchar *[]) { (gchar[]) { "r" }, NULL },
      (const gchar *[]) { NULL }
    },

    { "spec", N_("_RPM Spec"),
      (const gchar *[]) { (gchar[]) { "spec" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-rpm-spec" }, NULL }
    },

    { "scala", N_("_Scala"),
      (const gchar *[]) { (gchar[]) { "scala" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-scala" }, NULL }
    },

    { "smalltalk", N_("_Smalltalk"),
      (const gchar *[]) { (gchar[]) { "gst" }, (gchar[]) { "sq" },
                  (gchar[]) { "st" }, NULL },
      (const gchar *[]) { NULL }
    },

    { "tcsh", N_("_TCSH"),
      (const gchar *[]) { (gchar[]) { "tcsh" }, NULL },
      (const gchar *[]) { NULL }
    },

    { "vhd", N_("_VHDL"),
      (const gchar *[]) { (gchar[]) { "vhd" }, NULL },
      (const gchar *[]) { (gchar[]) { "text/x-vhdl" }, NULL }
    }
};

Language *
get_default_langauges (gsize *len)
{
    if (len) {
        *len = G_N_ELEMENTS (languages);
    }

    return languages;
}

Language *
get_additinal_languages (gsize *len)
{
    if (len) {
        *len = G_N_ELEMENTS (other_languages);
    }

    return other_languages;
}

const gchar *
get_syntax_for_ext (const gchar *extension)
{
    gint i;
    gint j;

    for (i = 0; i < G_N_ELEMENTS (languages); i++) {

        Language *lang = &languages[i];
        const gchar *ext;

        j = 0;
        ext = lang->extensions[j];
        while (ext) {
            if (g_ascii_strncasecmp (ext, extension, strlen (ext)) == 0) {
                return lang->action_name;
            }

            j++;
            ext = lang->extensions[j];
        }
    }

    for (i = 0; i < G_N_ELEMENTS (other_languages); i++) {

        Language *lang = &other_languages[i];
        const gchar *ext;

        j = 0;
        ext = lang->extensions[j];
        while (ext) {
            if (g_ascii_strncasecmp (ext, extension, strlen (ext)) == 0) {
                return lang->action_name;
            }

            j++;
            ext = lang->extensions[j];
        }
    }

    return NULL;
}

const gchar *
get_syntax_for_mime_type (const gchar *mime_type)
{
    gint i;
    gint j;

    for (i = 0; i < G_N_ELEMENTS (languages); i++) {

        Language *lang = &languages[i];
        const gchar *mt;

        j = 0;
        mt = lang->mime_types[j];
        while (mt) {
            if (g_ascii_strncasecmp (mt, mime_type, strlen (mt)) == 0) {
                return lang->action_name;
            }

            j++;
            mt = lang->mime_types[j];
        }
    }

    for (i = 0; i < G_N_ELEMENTS (other_languages); i++) {

        Language *lang = &other_languages[i];
        const gchar *mt;

        j = 0;
        mt = lang->mime_types[j];
        while (mt) {
            if (g_ascii_strncasecmp (mt, mime_type, strlen (mt)) == 0) {
                return lang->action_name;
            }

            j++;
            mt = lang->mime_types[j];
        }
    }

    return NULL;
}

const gchar **
get_mime_types (void)
{
    G_LOCK (mime_types);
    if (mime_types == NULL) {
        gchar **list;
        gsize array_len;
        gint i, pos;

        array_len = G_N_ELEMENTS (languages);
        pos = 0;

        list = g_malloc (array_len * sizeof (gchar *));

        for (i = 0; i < G_N_ELEMENTS (languages); i++) {
            Language *lang = &languages[i];

            gint j = 0;
            while (lang->mime_types[j] != NULL) {
                if (pos == array_len) {
                    array_len += 10;
                    list = g_realloc (list, array_len * sizeof (gchar *));
                }

                list[pos] = (gchar *) lang->mime_types[j];
                pos++;
                j++;
            }
        }

        for (i = 0; i < G_N_ELEMENTS (other_languages); i++) {
            Language *lang = &other_languages[i];

            gint j = 0;
            while (lang->mime_types[j] != NULL) {
                if (pos == array_len) {
                    array_len += 10;
                    list = g_realloc (list, array_len * sizeof (gchar *));
                }

                list[pos] = (gchar *) lang->mime_types[j];
                pos++;
                j++;
            }
        }

        if (pos == array_len) {
            array_len += 1;
            list = g_realloc (list, array_len * sizeof (gchar *));
        }

        /* Ensure the array is null-terminated */
        for (i = pos; i < array_len; i++) {
            list[i] = NULL;
        }

        mime_types = (const gchar **) list;
    }
    G_UNLOCK (mime_types);

    return mime_types;
}