Improve tag-goto popup

[geany-mirror.git] / src / utils.c

/*
 *      utils.c - this file is part of Geany, a fast and lightweight IDE
 *
 *      Copyright 2005 The Geany contributors
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License as published by
 *      the Free Software Foundation; either version 2 of the License, or
 *      (at your option) any later version.
 *
 *      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 General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License along
 *      with this program; if not, write to the Free Software Foundation, Inc.,
 *      51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

/*
 * General utility functions, non-GTK related.
 */

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include "utils.h"

#include "app.h"
#include "dialogs.h"
#include "document.h"
#include "prefs.h"
#include "prefix.h"
#include "sciwrappers.h"
#include "spawn.h"
#include "support.h"
#include "tm_source_file.h" // for tm_get_real_path()
#include "templates.h"
#include "ui_utils.h"
#include "win32.h"
#include "osx.h"

#include <stdlib.h>
#include <ctype.h>
#include <math.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <stdarg.h>

#ifdef HAVE_SYS_STAT_H
# include <sys/stat.h>
#endif
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif

#include <glib/gstdio.h>
#include <gio/gio.h>


/**
 *  Tries to open the given URI in a browser.
 *  On Windows, the system's default browser is opened.
 *  On non-Windows systems, the browser command set in the preferences dialog is used. In case
 *  that fails or it is unset, the user is asked to correct or fill it.
 *
 *  @param uri The URI to open in the web browser.
 *
 *  @since 0.16
 **/
GEANY_API_SYMBOL
void utils_open_browser(const gchar *uri)
{
#ifdef G_OS_WIN32
        g_return_if_fail(uri != NULL);
        win32_open_browser(uri);
#else
        gchar *argv[2] = { (gchar *) uri, NULL };

        g_return_if_fail(uri != NULL);

        while (!spawn_async(NULL, tool_prefs.browser_cmd, argv, NULL, NULL, NULL))
        {
                gchar *new_cmd = dialogs_show_input(_("Select Browser"), GTK_WINDOW(main_widgets.window),
                        _("Failed to spawn the configured browser command. "
                          "Please correct it or enter another one."),
                        tool_prefs.browser_cmd);

                if (new_cmd == NULL) /* user canceled */
                        break;

                SETPTR(tool_prefs.browser_cmd, new_cmd);
        }
#endif
}


/* taken from anjuta, to determine the EOL mode of the file */
gint utils_get_line_endings(const gchar* buffer, gsize size)
{
        gsize i;
        guint cr, lf, crlf, max_mode;
        gint mode;

        cr = lf = crlf = 0;

        for (i = 0; i < size ; i++)
        {
                if (buffer[i] == 0x0a)
                {
                        /* LF */
                        lf++;
                }
                else if (buffer[i] == 0x0d)
                {
                        if (i >= (size - 1))
                        {
                                /* Last char, CR */
                                cr++;
                        }
                        else
                        {
                                if (buffer[i + 1] != 0x0a)
                                {
                                        /* CR */
                                        cr++;
                                }
                                else
                                {
                                        /* CRLF */
                                        crlf++;
                                }
                                i++;
                        }
                }
        }

        /* Vote for the maximum */
        mode = SC_EOL_LF;
        max_mode = lf;
        if (crlf > max_mode)
        {
                mode = SC_EOL_CRLF;
                max_mode = crlf;
        }
        if (cr > max_mode)
        {
                mode = SC_EOL_CR;
                max_mode = cr;
        }

        return mode;
}


gboolean utils_isbrace(gchar c, gboolean include_angles)
{
        switch (c)
        {
                case '<':
                case '>':
                return include_angles;

                case '(':
                case ')':
                case '{':
                case '}':
                case '[':
                case ']': return TRUE;
                default:  return FALSE;
        }
}


gboolean utils_is_opening_brace(gchar c, gboolean include_angles)
{
        switch (c)
        {
                case '<':
                return include_angles;

                case '(':
                case '{':
                case '[':  return TRUE;
                default:  return FALSE;
        }
}


/**
 * Writes @a text into a file named @a filename.
 * If the file doesn't exist, it will be created.
 * If it already exists, it will be overwritten.
 *
 * @warning You should use @c g_file_set_contents() instead if you don't need
 * file permissions and other metadata to be preserved, as that always handles
 * disk exhaustion safely.
 *
 * @param filename The filename of the file to write, in locale encoding.
 * @param text The text to write into the file.
 *
 * @return 0 if the file was successfully written, otherwise the @c errno of the
 *         failed operation is returned.
 **/
GEANY_API_SYMBOL
gint utils_write_file(const gchar *filename, const gchar *text)
{
        g_return_val_if_fail(filename != NULL, ENOENT);
        g_return_val_if_fail(text != NULL, EINVAL);

        if (file_prefs.use_safe_file_saving)
        {
                GError *error = NULL;
                if (! g_file_set_contents(filename, text, -1, &error))
                {
                        geany_debug("%s: could not write to file %s (%s)", G_STRFUNC, filename, error->message);
                        g_error_free(error);
                        return EIO;
                }
        }
        else
        {
                FILE *fp;
                gsize bytes_written, len;
                gboolean fail = FALSE;

                if (filename == NULL)
                        return ENOENT;

                len = strlen(text);
                errno = 0;
                fp = g_fopen(filename, "w");
                if (fp == NULL)
                        fail = TRUE;
                else
                {
                        bytes_written = fwrite(text, sizeof(gchar), len, fp);

                        if (len != bytes_written)
                        {
                                fail = TRUE;
                                geany_debug(
                                        "utils_write_file(): written only %"G_GSIZE_FORMAT" bytes, had to write %"G_GSIZE_FORMAT" bytes to %s",
                                        bytes_written, len, filename);
                        }
                        if (fclose(fp) != 0)
                                fail = TRUE;
                }
                if (fail)
                {
                        geany_debug("utils_write_file(): could not write to file %s (%s)",
                                filename, g_strerror(errno));
                        return FALLBACK(errno, EIO);
                }
        }
        return 0;
}


/** Searches backward through @a size bytes looking for a '<'.
 * @param sel .
 * @param size .
 * @return @nullable The tag name (newly allocated) or @c NULL if no opening tag was found.
 */
GEANY_API_SYMBOL
gchar *utils_find_open_xml_tag(const gchar sel[], gint size)
{
        const gchar *cur, *begin;
        gsize len;

        cur = utils_find_open_xml_tag_pos(sel, size);
        if (cur == NULL)
                return NULL;

        cur++; /* skip the bracket */
        begin = cur;
        while (strchr(":_-.", *cur) || isalnum(*cur))
                cur++;

        len = (gsize)(cur - begin);
        return len ? g_strndup(begin, len) : NULL;
}


/** Searches backward through @a size bytes looking for a '<'.
 * @param sel .
 * @param size .
 * @return @nullable pointer to '<' of the found opening tag within @a sel, or @c NULL if no opening tag was found.
 */
GEANY_API_SYMBOL
const gchar *utils_find_open_xml_tag_pos(const gchar sel[], gint size)
{
        /* stolen from anjuta and modified */
        const gchar *begin, *cur;

        if (G_UNLIKELY(size < 3))
        {       /* Smallest tag is "<p>" which is 3 characters */
                return NULL;
        }
        begin = &sel[0];
        cur = &sel[size - 1];

        /* Skip to the character before the closing brace */
        while (cur > begin)
        {
                if (*cur == '>')
                        break;
                --cur;
        }
        --cur;
        /* skip whitespace */
        while (cur > begin && isspace(*cur))
                cur--;
        if (*cur == '/')
                return NULL; /* we found a short tag which doesn't need to be closed */
        while (cur > begin)
        {
                if (*cur == '<')
                        break;
                /* exit immediately if such non-valid XML/HTML is detected, e.g. "<script>if a >" */
                else if (*cur == '>')
                        break;
                --cur;
        }

        /* if the found tag is an opening, not a closing tag or empty <> */
        if (*cur == '<' && *(cur + 1) != '/' && *(cur + 1) != '>')
                return cur;

        return NULL;
}


/* Returns true if tag_name is a self-closing tag */
gboolean utils_is_short_html_tag(const gchar *tag_name)
{
        const gchar names[][20] = {
                "area",
                "base",
                "basefont",     /* < or not < */
                "br",
                "col",
                "command",
                "embed",
                "frame",
                "hr",
                "img",
                "input",
                "keygen",
                "link",
                "meta",
                "param",
                "source",
                "track",
                "wbr"
        };

        if (tag_name)
        {
                if (bsearch(tag_name, names, G_N_ELEMENTS(names), 20,
                        (GCompareFunc)g_ascii_strcasecmp))
                                return TRUE;
        }
        return FALSE;
}


const gchar *utils_get_eol_name(gint eol_mode)
{
        switch (eol_mode)
        {
                case SC_EOL_CRLF: return _("Windows (CRLF)"); break;
                case SC_EOL_CR: return _("Classic Mac (CR)"); break;
                default: return _("Unix (LF)"); break;
        }
}


const gchar *utils_get_eol_short_name(gint eol_mode)
{
        switch (eol_mode)
        {
                case SC_EOL_CRLF: return _("CRLF"); break;
                case SC_EOL_CR: return _("CR"); break;
                default: return _("LF"); break;
        }
}


const gchar *utils_get_eol_char(gint eol_mode)
{
        switch (eol_mode)
        {
                case SC_EOL_CRLF: return "\r\n"; break;
                case SC_EOL_CR: return "\r"; break;
                default: return "\n"; break;
        }
}


/* Converts line endings to @a target_eol_mode. */
void utils_ensure_same_eol_characters(GString *string, gint target_eol_mode)
{
        const gchar *eol_str = utils_get_eol_char(target_eol_mode);

        /* first convert data to LF only */
        utils_string_replace_all(string, "\r\n", "\n");
        utils_string_replace_all(string, "\r", "\n");

        if (target_eol_mode == SC_EOL_LF)
                return;

        /* now convert to desired line endings */
        utils_string_replace_all(string, "\n", eol_str);
}


gboolean utils_atob(const gchar *str)
{
        if (G_UNLIKELY(str == NULL))
                return FALSE;
        else if (strcmp(str, "TRUE") == 0 || strcmp(str, "true") == 0)
                return TRUE;
        return FALSE;
}


/* NULL-safe version of g_path_is_absolute(). */
gboolean utils_is_absolute_path(const gchar *path)
{
        if (G_UNLIKELY(EMPTY(path)))
                return FALSE;

        return g_path_is_absolute(path);
}


/* Skips root if path is absolute, do nothing otherwise.
 * This is a relative-safe version of g_path_skip_root().
 */
const gchar *utils_path_skip_root(const gchar *path)
{
        const gchar *path_relative;

        path_relative = g_path_skip_root(path);

        return (path_relative != NULL) ? path_relative : path;
}


/* Convert a fractional @a val in the range [0, 1] to a whole value in the range [0, @a factor].
 * In particular, this is used for converting a @c GdkColor to the "#RRGGBB" format in a way that
 * agrees with GTK+, so the "#RRGGBB" in the color picker is the same "#RRGGBB" that is inserted
 * into the document. See https://github.com/geany/geany/issues/1527
 */
gdouble utils_scale_round(gdouble val, gdouble factor)
{
        val = floor(val * factor + 0.5);
        val = MAX(val, 0);
        val = MIN(val, factor);

        return val;
}


/* like g_utf8_strdown() but if @str is not valid UTF8, convert it from locale first.
 * returns NULL on charset conversion failure */
gchar *utils_utf8_strdown(const gchar *str)
{
        gchar *down;

        if (g_utf8_validate(str, -1, NULL))
                down = g_utf8_strdown(str, -1);
        else
        {
                down = g_locale_to_utf8(str, -1, NULL, NULL, NULL);
                if (down)
                        SETPTR(down, g_utf8_strdown(down, -1));
        }

        return down;
}


/**
 *  A replacement function for g_strncasecmp() to compare strings case-insensitive.
 *  It converts both strings into lowercase using g_utf8_strdown() and then compare
 *  both strings using strcmp().
 *  This is not completely accurate regarding locale-specific case sorting rules
 *  but seems to be a good compromise between correctness and performance.
 *
 *  The input strings should be in UTF-8 or locale encoding.
 *
 *  @param s1 @nullable Pointer to first string or @c NULL.
 *  @param s2 @nullable Pointer to second string or @c NULL.
 *
 *  @return an integer less than, equal to, or greater than zero if @a s1 is found, respectively,
 *          to be less than, to match, or to be greater than @a s2.
 *
 *  @since 0.16
 */
GEANY_API_SYMBOL
gint utils_str_casecmp(const gchar *s1, const gchar *s2)
{
        gchar *tmp1, *tmp2;
        gint result;

        g_return_val_if_fail(s1 != NULL, 1);
        g_return_val_if_fail(s2 != NULL, -1);

        /* ensure strings are UTF-8 and lowercase */
        tmp1 = utils_utf8_strdown(s1);
        if (! tmp1)
                return 1;
        tmp2 = utils_utf8_strdown(s2);
        if (! tmp2)
        {
                g_free(tmp1);
                return -1;
        }

        /* compare */
        result = strcmp(tmp1, tmp2);

        g_free(tmp1);
        g_free(tmp2);
        return result;
}


/**
 *  Truncates the input string to a given length.
 *  Characters are removed from the middle of the string, so the start and the end of string
 *  won't change.
 *
 *  @param string Input string.
 *  @param truncate_length The length in characters of the resulting string.
 *
 *  @return A copy of @a string which is truncated to @a truncate_length characters,
 *          should be freed when no longer needed.
 *
 *  @since 0.17
 */
/* This following function is taken from Gedit. */
GEANY_API_SYMBOL
gchar *utils_str_middle_truncate(const gchar *string, guint truncate_length)
{
        GString *truncated;
        guint length;
        guint n_chars;
        guint num_left_chars;
        guint right_offset;
        guint delimiter_length;
        const gchar *delimiter = "\342\200\246";

        g_return_val_if_fail(string != NULL, NULL);

        length = strlen(string);

        g_return_val_if_fail(g_utf8_validate(string, length, NULL), NULL);

        /* It doesn't make sense to truncate strings to less than the size of the delimiter plus 2
         * characters (one on each side) */
        delimiter_length = g_utf8_strlen(delimiter, -1);
        if (truncate_length < (delimiter_length + 2))
                return g_strdup(string);

        n_chars = g_utf8_strlen(string, length);

        /* Make sure the string is not already small enough. */
        if (n_chars <= truncate_length)
                return g_strdup (string);

        /* Find the 'middle' where the truncation will occur. */
        num_left_chars = (truncate_length - delimiter_length) / 2;
        right_offset = n_chars - truncate_length + num_left_chars + delimiter_length;

        truncated = g_string_new_len(string, g_utf8_offset_to_pointer(string, num_left_chars) - string);
        g_string_append(truncated, delimiter);
        g_string_append(truncated, g_utf8_offset_to_pointer(string, right_offset));

        return g_string_free(truncated, FALSE);
}


/**
 *  @c NULL-safe string comparison. Returns @c TRUE if both @a a and @a b are @c NULL
 *  or if @a a and @a b refer to valid strings which are equal.
 *
 *  @param a @nullable Pointer to first string or @c NULL.
 *  @param b @nullable Pointer to second string or @c NULL.
 *
 *  @return @c TRUE if @a a equals @a b, else @c FALSE.
 **/
GEANY_API_SYMBOL
gboolean utils_str_equal(const gchar *a, const gchar *b)
{
        /* (taken from libexo from os-cillation) */
        if (a == NULL && b == NULL) return TRUE;
        else if (a == NULL || b == NULL) return FALSE;

        return strcmp(a, b) == 0;
}


/**
 *  Removes the extension from @a filename and return the result in a newly allocated string.
 *
 *  @param filename The filename to operate on.
 *
 *  @return A newly-allocated string, should be freed when no longer needed.
 **/
GEANY_API_SYMBOL
gchar *utils_remove_ext_from_filename(const gchar *filename)
{
        gchar *last_dot;
        gchar *result;
        gsize len;

        g_return_val_if_fail(filename != NULL, NULL);

        last_dot = strrchr(filename, '.');
        if (! last_dot)
                return g_strdup(filename);

        len = (gsize) (last_dot - filename);
        result = g_malloc(len + 1);
        memcpy(result, filename, len);
        result[len] = 0;

        return result;
}


gchar utils_brace_opposite(gchar ch)
{
        switch (ch)
        {
                case '(': return ')';
                case ')': return '(';
                case '[': return ']';
                case ']': return '[';
                case '{': return '}';
                case '}': return '{';
                case '<': return '>';
                case '>': return '<';
                default: return '\0';
        }
}


/* Checks whether the given file can be written. locale_filename is expected in locale encoding.
 * Returns 0 if it can be written, otherwise it returns errno */
gint utils_is_file_writable(const gchar *locale_filename)
{
        gchar *file;
        gint ret;

        if (! g_file_test(locale_filename, G_FILE_TEST_EXISTS) &&
                ! g_file_test(locale_filename, G_FILE_TEST_IS_DIR))
                /* get the file's directory to check for write permission if it doesn't yet exist */
                file = g_path_get_dirname(locale_filename);
        else
                file = g_strdup(locale_filename);

#ifdef G_OS_WIN32
        /* use _waccess on Windows, access() doesn't accept special characters */
        ret = win32_check_write_permission(file);
#else

        /* access set also errno to "FILE NOT FOUND" even if locale_filename is writeable, so use
         * errno only when access() explicitly returns an error */
        if (access(file, R_OK | W_OK) != 0)
                ret = errno;
        else
                ret = 0;
#endif
        g_free(file);
        return ret;
}


/* Replaces all occurrences of needle in haystack with replacement.
 * Warning: *haystack must be a heap address; it may be freed and reassigned.
 * Note: utils_string_replace_all() will always be faster when @a replacement is longer
 * than @a needle.
 * All strings have to be NULL-terminated.
 * See utils_string_replace_all() for details. */
void utils_str_replace_all(gchar **haystack, const gchar *needle, const gchar *replacement)
{
        GString *str;

        g_return_if_fail(*haystack != NULL);

        str = g_string_new(*haystack);

        g_free(*haystack);
        utils_string_replace_all(str, needle, replacement);

        *haystack = g_string_free(str, FALSE);
}


gint utils_strpos(const gchar *haystack, const gchar *needle)
{
        const gchar *sub;

        if (! *needle)
                return -1;

        sub = strstr(haystack, needle);
        if (! sub)
                return -1;

        return sub - haystack;
}


/**
 *  Retrieves a formatted date/time string from GDateTime.
 *  This function works on UTF-8 encoded strings.
 *
 *  @param format The format string to pass to g_date_time_format, in UTF-8 encoding.
                  See https://docs.gtk.org/glib/method.DateTime.format.html for details.
 *  @param time_to_use @nullable The date/time to use, in time_t format or @c NULL to use the current time.
 *
 *  @return A newly-allocated string, should be freed when no longer needed.
 *
 *  @since 0.16
 */
GEANY_API_SYMBOL
gchar *utils_get_date_time(const gchar *format, time_t *time_to_use)
{
        time_t unixtime;
        gchar *datetime_formatted;
        GDateTime *datetime;

        g_return_val_if_fail(format != NULL, NULL);

        if (time_to_use != NULL)
                unixtime = *time_to_use;
        else
                unixtime = time(NULL);

        datetime = g_date_time_new_from_unix_local(unixtime);
        datetime_formatted = g_date_time_format(datetime, format);

        g_date_time_unref(datetime);
        return datetime_formatted;
}


gchar *utils_get_initials(const gchar *name)
{
        gint i = 1, j = 1;
        gchar *initials = g_malloc0(5);

        initials[0] = name[0];
        while (name[i] != '\0' && j < 4)
        {
                if (name[i] == ' ' && name[i + 1] != ' ')
                {
                        initials[j++] = name[i + 1];
                }
                i++;
        }
        return initials;
}


/**
 *  Wraps g_key_file_get_integer() to add a default value argument.
 *
 *  @param config A GKeyFile object.
 *  @param section The group name to look in for the key.
 *  @param key The key to find.
 *  @param default_value The default value which will be returned when @a section or @a key
 *         don't exist.
 *
 *  @return The value associated with @a key as an integer, or the given default value if the value
 *          could not be retrieved.
 **/
GEANY_API_SYMBOL
gint utils_get_setting_integer(GKeyFile *config, const gchar *section, const gchar *key,
                                                           const gint default_value)
{
        gint tmp;
        GError *error = NULL;

        g_return_val_if_fail(config, default_value);

        tmp = g_key_file_get_integer(config, section, key, &error);
        if (error)
        {
                g_error_free(error);
                return default_value;
        }
        return tmp;
}


/**
 *  Wraps g_key_file_get_boolean() to add a default value argument.
 *
 *  @param config A GKeyFile object.
 *  @param section The group name to look in for the key.
 *  @param key The key to find.
 *  @param default_value The default value which will be returned when @c section or @c key
 *         don't exist.
 *
 *  @return The value associated with @a key as a boolean, or the given default value if the value
 *          could not be retrieved.
 **/
GEANY_API_SYMBOL
gboolean utils_get_setting_boolean(GKeyFile *config, const gchar *section, const gchar *key,
                                                                   const gboolean default_value)
{
        gboolean tmp;
        GError *error = NULL;

        g_return_val_if_fail(config, default_value);

        tmp = g_key_file_get_boolean(config, section, key, &error);
        if (error)
        {
                g_error_free(error);
                return default_value;
        }
        return tmp;
}


/**
 *  Wraps g_key_file_get_double() to add a default value argument.
 *
 *  @param config A GKeyFile object.
 *  @param section The group name to look in for the key.
 *  @param key The key to find.
 *  @param default_value The default value which will be returned when @a section or @a key
 *         don't exist.
 *
 *  @return The value associated with @a key as an integer, or the given default value if the value
 *          could not be retrieved.
 **/
GEANY_API_SYMBOL
gdouble utils_get_setting_double(GKeyFile *config, const gchar *section, const gchar *key,
                                                           const gdouble default_value)
{
        gdouble tmp;
        GError *error = NULL;

        g_return_val_if_fail(config, default_value);

        tmp = g_key_file_get_double(config, section, key, &error);
        if (error)
        {
                g_error_free(error);
                return default_value;
        }
        return tmp;
}


/**
 *  Wraps g_key_file_get_string() to add a default value argument.
 *
 *  @param config A GKeyFile object.
 *  @param section The group name to look in for the key.
 *  @param key The key to find.
 *  @param default_value The default value which will be returned when @a section or @a key
 *         don't exist.
 *
 *  @return A newly allocated string, either the value for @a key or a copy of the given
 *          default value if it could not be retrieved.
 **/
GEANY_API_SYMBOL
gchar *utils_get_setting_string(GKeyFile *config, const gchar *section, const gchar *key,
                                                                const gchar *default_value)
{
        gchar *tmp;

        g_return_val_if_fail(config, g_strdup(default_value));

        tmp = g_key_file_get_string(config, section, key, NULL);
        if (!tmp)
        {
                return g_strdup(default_value);
        }
        return tmp;
}


gchar *utils_get_hex_from_color(GdkColor *color)
{
        g_return_val_if_fail(color != NULL, NULL);

        return g_strdup_printf("#%02X%02X%02X",
                (guint) (utils_scale_round(color->red / 65535.0, 255)),
                (guint) (utils_scale_round(color->green / 65535.0, 255)),
                (guint) (utils_scale_round(color->blue / 65535.0, 255)));
}


/* Get directory from current file in the notebook.
 * Returns dir string that should be freed or NULL, depending on whether current file is valid.
 * Returned string is in UTF-8 encoding */
gchar *utils_get_current_file_dir_utf8(void)
{
        GeanyDocument *doc = document_get_current();

        if (doc != NULL)
        {
                /* get current filename */
                const gchar *cur_fname = doc->file_name;

                if (cur_fname != NULL)
                {
                        /* get folder part from current filename */
                        return g_path_get_dirname(cur_fname); /* returns "." if no path */
                }
        }

        return NULL; /* no file open */
}


/* very simple convenience function */
void utils_beep(void)
{
        if (prefs.beep_on_errors)
                gdk_beep();
}


/* taken from busybox, thanks */
gchar *utils_make_human_readable_str(guint64 size, gulong block_size,
                                                                         gulong display_unit)
{
        /* The code will adjust for additional (appended) units. */
        static const gchar zero_and_units[] = { '0', 0, 'K', 'M', 'G', 'T' };
        static const gchar fmt[] = "%Lu %c%c";
        static const gchar fmt_tenths[] = "%Lu.%d %c%c";

        guint64 val;
        gint frac;
        const gchar *u;
        const gchar *f;

        u = zero_and_units;
        f = fmt;
        frac = 0;

        val = size * block_size;
        if (val == 0)
                return g_strdup(u);

        if (display_unit)
        {
                val += display_unit/2;  /* Deal with rounding. */
                val /= display_unit;    /* Don't combine with the line above!!! */
        }
        else
        {
                ++u;
                while ((val >= 1024) && (u < zero_and_units + sizeof(zero_and_units) - 1))
                {
                        f = fmt_tenths;
                        ++u;
                        frac = ((((gint)(val % 1024)) * 10) + (1024 / 2)) / 1024;
                        val /= 1024;
                }
                if (frac >= 10)
                {               /* We need to round up here. */
                        ++val;
                        frac = 0;
                }
        }

        /* If f==fmt then 'frac' and 'u' are ignored. */
        return g_strdup_printf(f, val, frac, *u, 'b');
}


/* converts a color representation using gdk_color_parse(), with additional
 * support of the "0x" prefix as a synonym for "#" */
gboolean utils_parse_color(const gchar *spec, GdkColor *color)
{
        gchar buf[64] = {0};

        g_return_val_if_fail(spec != NULL, -1);

        if (spec[0] == '0' && (spec[1] == 'x' || spec[1] == 'X'))
        {
                /* convert to # format for GDK to understand it */
                buf[0] = '#';
                strncpy(buf + 1, spec + 2, sizeof(buf) - 2);
                spec = buf;
        }

        return gdk_color_parse(spec, color);
}


/* converts a GdkColor to the packed 24 bits BGR format, as understood by Scintilla
 * returns a 24 bits BGR color, or -1 on failure */
gint utils_color_to_bgr(const GdkColor *c)
{
        g_return_val_if_fail(c != NULL, -1);
        return (c->red / 256) | ((c->green / 256) << 8) | ((c->blue / 256) << 16);
}


/* parses @p spec using utils_parse_color() and convert it to 24 bits BGR using
 * utils_color_to_bgr() */
gint utils_parse_color_to_bgr(const gchar *spec)
{
        GdkColor color;
        if (utils_parse_color(spec, &color))
                return utils_color_to_bgr(&color);
        else
                return -1;
}


/* Returns: newly allocated string with the current time formatted HH:MM:SS.
 * If "include_microseconds" is TRUE, microseconds are appended.
 *
 * The returned string should be freed with g_free(). */
gchar *utils_get_current_time_string(gboolean include_microseconds)
{
        // "%f" specifier for microseconds is only available since GLib 2.66
        if (glib_check_version(2, 66, 0) != NULL)
                include_microseconds = FALSE;

        GDateTime *now = g_date_time_new_now_local();
        const gchar *format = include_microseconds ? "%H:%M:%S.%f" : "%H:%M:%S";
        gchar *time_string = g_date_time_format(now, format);
        g_date_time_unref(now);
        return time_string;
}


GIOChannel *utils_set_up_io_channel(
                                gint fd, GIOCondition cond, gboolean nblock, GIOFunc func, gpointer data)
{
        GIOChannel *ioc;
        /*const gchar *encoding;*/

        #ifdef G_OS_WIN32
        ioc = g_io_channel_win32_new_fd(fd);
        #else
        ioc = g_io_channel_unix_new(fd);
        #endif

        if (nblock)
                g_io_channel_set_flags(ioc, G_IO_FLAG_NONBLOCK, NULL);

        g_io_channel_set_encoding(ioc, NULL, NULL);
/*
        if (! g_get_charset(&encoding))
        {       // hope this works reliably
                GError *error = NULL;
                g_io_channel_set_encoding(ioc, encoding, &error);
                if (error)
                {
                        geany_debug("%s: %s", G_STRFUNC, error->message);
                        g_error_free(error);
                        return ioc;
                }
        }
*/
        /* "auto-close" ;-) */
        g_io_channel_set_close_on_unref(ioc, TRUE);

        g_io_add_watch(ioc, cond, func, data);
        g_io_channel_unref(ioc);

        return ioc;
}


/* Contributed by Stefan Oltmanns, thanks.
 * Replaces \\, \r, \n, \t and \uXXX by their real counterparts.
 * keep_backslash is used for regex strings to leave '\\' and '\?' in place */
gboolean utils_str_replace_escape(gchar *string, gboolean keep_backslash)
{
        gsize i, j, len;
        guint unicodechar;

        g_return_val_if_fail(string != NULL, FALSE);

        j = 0;
        len = strlen(string);
        for (i = 0; i < len; i++)
        {
                if (string[i]=='\\')
                {
                        if (i++ >= strlen(string))
                        {
                                return FALSE;
                        }
                        switch (string[i])
                        {
                                case '\\':
                                        if (keep_backslash)
                                                string[j++] = '\\';
                                        string[j] = '\\';
                                        break;
                                case 'n':
                                        string[j] = '\n';
                                        break;
                                case 'r':
                                        string[j] = '\r';
                                        break;
                                case 't':
                                        string[j] = '\t';
                                        break;
#if 0
                                case 'x': /* Warning: May produce illegal utf-8 string! */
                                        i += 2;
                                        if (i >= strlen(string))
                                        {
                                                return FALSE;
                                        }
                                        if (isdigit(string[i - 1])) string[j] = string[i - 1] - 48;
                                        else if (isxdigit(string[i - 1])) string[j] = tolower(string[i - 1])-87;
                                        else return FALSE;
                                        string[j] <<= 4;
                                        if (isdigit(string[i])) string[j] |= string[i] - 48;
                                        else if (isxdigit(string[i])) string[j] |= tolower(string[i])-87;
                                        else return FALSE;
                                        break;
#endif
                                case 'u':
                                {
                                        i += 2;
                                        if (i >= strlen(string))
                                        {
                                                return FALSE;
                                        }
                                        if (isdigit(string[i - 1])) unicodechar = string[i - 1] - 48;
                                        else if (isxdigit(string[i - 1])) unicodechar = tolower(string[i - 1])-87;
                                        else return FALSE;
                                        unicodechar <<= 4;
                                        if (isdigit(string[i])) unicodechar |= string[i] - 48;
                                        else if (isxdigit(string[i])) unicodechar |= tolower(string[i])-87;
                                        else return FALSE;
                                        if (((i + 2) < strlen(string)) && (isdigit(string[i + 1]) || isxdigit(string[i + 1]))
                                                && (isdigit(string[i + 2]) || isxdigit(string[i + 2])))
                                        {
                                                i += 2;
                                                unicodechar <<= 8;
                                                if (isdigit(string[i - 1])) unicodechar |= ((string[i - 1] - 48) << 4);
                                                else unicodechar |= ((tolower(string[i - 1])-87) << 4);
                                                if (isdigit(string[i])) unicodechar |= string[i] - 48;
                                                else unicodechar |= tolower(string[i])-87;
                                        }
                                        if (((i + 2) < strlen(string)) && (isdigit(string[i + 1]) || isxdigit(string[i + 1]))
                                                && (isdigit(string[i + 2]) || isxdigit(string[i + 2])))
                                        {
                                                i += 2;
                                                unicodechar <<= 8;
                                                if (isdigit(string[i - 1])) unicodechar |= ((string[i - 1] - 48) << 4);
                                                else unicodechar |= ((tolower(string[i - 1])-87) << 4);
                                                if (isdigit(string[i])) unicodechar |= string[i] - 48;
                                                else unicodechar |= tolower(string[i])-87;
                                        }
                                        if (unicodechar < 0x80)
                                        {
                                                string[j] = unicodechar;
                                        }
                                        else if (unicodechar < 0x800)
                                        {
                                                string[j] = (unsigned char) ((unicodechar >> 6) | 0xC0);
                                                j++;
                                                string[j] = (unsigned char) ((unicodechar & 0x3F) | 0x80);
                                        }
                                        else if (unicodechar < 0x10000)
                                        {
                                                string[j] = (unsigned char) ((unicodechar >> 12) | 0xE0);
                                                j++;
                                                string[j] = (unsigned char) (((unicodechar >> 6) & 0x3F) | 0x80);
                                                j++;
                                                string[j] = (unsigned char) ((unicodechar & 0x3F) | 0x80);
                                        }
                                        else if (unicodechar < 0x110000) /* more chars are not allowed in unicode */
                                        {
                                                string[j] = (unsigned char) ((unicodechar >> 18) | 0xF0);
                                                j++;
                                                string[j] = (unsigned char) (((unicodechar >> 12) & 0x3F) | 0x80);
                                                j++;
                                                string[j] = (unsigned char) (((unicodechar >> 6) & 0x3F) | 0x80);
                                                j++;
                                                string[j] = (unsigned char) ((unicodechar & 0x3F) | 0x80);
                                        }
                                        else
                                        {
                                                return FALSE;
                                        }
                                        break;
                                }
                                default:
                                        /* unnecessary escapes are allowed */
                                        if (keep_backslash)
                                                string[j++] = '\\';
                                        string[j] = string[i];
                        }
                }
                else
                {
                        string[j] = string[i];
                }
                j++;
        }
        while (j < i)
        {
                string[j] = 0;
                j++;
        }
        return TRUE;
}


/* Wraps a string in place, replacing a space with a newline character.
 * wrapstart is the minimum position to start wrapping or -1 for default */
gboolean utils_wrap_string(gchar *string, gint wrapstart)
{
        gchar *pos, *linestart;
        gboolean ret = FALSE;

        if (wrapstart < 0)
                wrapstart = 80;

        for (pos = linestart = string; *pos != '\0'; pos++)
        {
                if (pos - linestart >= wrapstart && *pos == ' ')
                {
                        *pos = '\n';
                        linestart = pos;
                        ret = TRUE;
                }
        }
        return ret;
}


/**
 *  Converts the given UTF-8 encoded string into locale encoding.
 *  On Windows platforms, it does nothing and instead it just returns a copy of the input string.
 *
 *  @param utf8_text UTF-8 encoded text.
 *
 *  @return The converted string in locale encoding, or a copy of the input string if conversion
 *    failed. Should be freed with g_free(). If @a utf8_text is @c NULL, @c NULL is returned.
 **/
GEANY_API_SYMBOL
gchar *utils_get_locale_from_utf8(const gchar *utf8_text)
{
#ifdef G_OS_WIN32
        /* just do nothing on Windows platforms, this ifdef is just to prevent unwanted conversions
         * which would result in wrongly converted strings */
        return g_strdup(utf8_text);
#else
        gchar *locale_text;

        if (! utf8_text)
                return NULL;
        locale_text = g_locale_from_utf8(utf8_text, -1, NULL, NULL, NULL);
        if (locale_text == NULL)
                locale_text = g_strdup(utf8_text);
        return locale_text;
#endif
}


/**
 *  Converts the given string (in locale encoding) into UTF-8 encoding.
 *  On Windows platforms, it does nothing and instead it just returns a copy of the input string.
 *
 *  @param locale_text Text in locale encoding.
 *
 *  @return The converted string in UTF-8 encoding, or a copy of the input string if conversion
 *    failed. Should be freed with g_free(). If @a locale_text is @c NULL, @c NULL is returned.
 **/
GEANY_API_SYMBOL
gchar *utils_get_utf8_from_locale(const gchar *locale_text)
{
#ifdef G_OS_WIN32
        /* just do nothing on Windows platforms, this ifdef is just to prevent unwanted conversions
         * which would result in wrongly converted strings */
        return g_strdup(locale_text);
#else
        gchar *utf8_text;

        if (! locale_text)
                return NULL;
        utf8_text = g_locale_to_utf8(locale_text, -1, NULL, NULL, NULL);
        if (utf8_text == NULL)
                utf8_text = g_strdup(locale_text);
        return utf8_text;
#endif
}


/* Pass pointers to free after arg_count.
 * The last argument must be NULL as an extra check that arg_count is correct. */
void utils_free_pointers(gsize arg_count, ...)
{
        va_list a;
        gsize i;
        gpointer ptr;

        va_start(a, arg_count);
        for (i = 0; i < arg_count; i++)
        {
                ptr = va_arg(a, gpointer);
                g_free(ptr);
        }
        ptr = va_arg(a, gpointer);
        if (ptr)
                g_warning("Wrong arg_count!");
        va_end(a);
}


/* Creates a string array deep copy of a series of non-NULL strings.
 * The first argument is nothing special and must not be NULL.
 * The list must be terminated with NULL. */
GEANY_EXPORT_SYMBOL
gchar **utils_strv_new(const gchar *first, ...)
{
        gsize strvlen, i;
        va_list args;
        gchar *str;
        gchar **strv;

        g_return_val_if_fail(first != NULL, NULL);

        strvlen = 1;    /* for first argument */

        /* count other arguments */
        va_start(args, first);
        for (; va_arg(args, gchar*) != NULL; strvlen++);
        va_end(args);

        strv = g_new(gchar*, strvlen + 1);      /* +1 for NULL terminator */
        strv[0] = g_strdup(first);

        va_start(args, first);
        for (i = 1; str = va_arg(args, gchar*), str != NULL; i++)
        {
                strv[i] = g_strdup(str);
        }
        va_end(args);

        strv[i] = NULL;
        return strv;
}


/**
 *  Creates a directory if it doesn't already exist.
 *  Creates intermediate parent directories as needed, too.
 *  The permissions of the created directory are set 0700.
 *
 *  @param path The path of the directory to create, in locale encoding.
 *  @param create_parent_dirs Whether to create intermediate parent directories if necessary.
 *
 *  @return 0 if the directory was successfully created, otherwise the @c errno of the
 *          failed operation is returned.
 **/
GEANY_API_SYMBOL
gint utils_mkdir(const gchar *path, gboolean create_parent_dirs)
{
        gint mode = 0700;
        gint result;

        if (path == NULL || strlen(path) == 0)
                return EFAULT;

        result = (create_parent_dirs) ? g_mkdir_with_parents(path, mode) : g_mkdir(path, mode);
        if (result != 0)
                return errno;
        return 0;
}


/**
 * Gets a list of files from the specified directory.
 * Locale encoding is expected for @a path and used for the file list. The list and the data
 * in the list should be freed after use, e.g.:
 * @code
 * g_slist_foreach(list, (GFunc) g_free, NULL);
 * g_slist_free(list); @endcode
 *
 * @note If you don't need a list you should use the foreach_dir() macro instead -
 * it's more efficient.
 *
 * @param path The path of the directory to scan, in locale encoding.
 * @param full_path Whether to include the full path for each filename in the list. Obviously this
 * will use more memory.
 * @param sort Whether to sort alphabetically (UTF-8 safe).
 * @param error The location for storing a possible error, or @c NULL.
 *
 * @return @elementtype{filename} @transfer{full} @nullable A newly allocated list or @c NULL if
 * no files were found. The list and its data should be freed when no longer needed.
 * @see utils_get_file_list().
 **/
GEANY_API_SYMBOL
GSList *utils_get_file_list_full(const gchar *path, gboolean full_path, gboolean sort, GError **error)
{
        GSList *list = NULL;
        GDir *dir;
        const gchar *filename;

        if (error)
                *error = NULL;
        g_return_val_if_fail(path != NULL, NULL);

        dir = g_dir_open(path, 0, error);
        if (dir == NULL)
                return NULL;

        foreach_dir(filename, dir)
        {
                list = g_slist_prepend(list, full_path ?
                        g_build_path(G_DIR_SEPARATOR_S, path, filename, NULL) : g_strdup(filename));
        }
        g_dir_close(dir);
        /* sorting last is quicker than on insertion */
        if (sort)
                list = g_slist_sort(list, (GCompareFunc) utils_str_casecmp);
        return list;
}


/**
 * Gets a sorted list of files from the specified directory.
 * Locale encoding is expected for @a path and used for the file list. The list and the data
 * in the list should be freed after use, e.g.:
 * @code
 * g_slist_foreach(list, (GFunc) g_free, NULL);
 * g_slist_free(list); @endcode
 *
 * @param path The path of the directory to scan, in locale encoding.
 * @param length The location to store the number of non-@c NULL data items in the list,
 *               unless @c NULL.
 * @param error The location for storing a possible error, or @c NULL.
 *
 * @return @elementtype{filename} @transfer{full} @nullable A newly allocated list or @c NULL
 * if no files were found. The list and its data should be freed when no longer needed.
 * @see utils_get_file_list_full().
 **/
GEANY_API_SYMBOL
GSList *utils_get_file_list(const gchar *path, guint *length, GError **error)
{
        GSList *list = utils_get_file_list_full(path, FALSE, TRUE, error);

        if (length)
                *length = g_slist_length(list);
        return list;
}


/* returns TRUE if any letter in str is a capital, FALSE otherwise. Should be Unicode safe. */
gboolean utils_str_has_upper(const gchar *str)
{
        gunichar c;

        if (EMPTY(str) || ! g_utf8_validate(str, -1, NULL))
                return FALSE;

        while (*str != '\0')
        {
                c = g_utf8_get_char(str);
                /* check only letters and stop once the first non-capital was found */
                if (g_unichar_isalpha(c) && g_unichar_isupper(c))
                        return TRUE;
                /* FIXME don't write a const string */
                str = g_utf8_next_char(str);
        }
        return FALSE;
}


/* end can be -1 for haystack->len.
 * returns: position of found text or -1. */
gint utils_string_find(GString *haystack, gint start, gint end, const gchar *needle)
{
        gint pos;

        g_return_val_if_fail(haystack != NULL, -1);
        if (haystack->len == 0)
                return -1;

        g_return_val_if_fail(start >= 0, -1);
        if (start >= (gint)haystack->len)
                return -1;

        g_return_val_if_fail(!EMPTY(needle), -1);

        if (end < 0)
                end = haystack->len;

        pos = utils_strpos(haystack->str + start, needle);
        if (pos == -1)
                return -1;

        pos += start;
        if (pos >= end)
                return -1;
        return pos;
}


/* Replaces @len characters from offset @a pos.
 * len can be -1 to replace the remainder of @a str.
 * returns: pos + strlen(replace). */
gint utils_string_replace(GString *str, gint pos, gint len, const gchar *replace)
{
        g_string_erase(str, pos, len);
        if (replace)
        {
                g_string_insert(str, pos, replace);
                pos += strlen(replace);
        }
        return pos;
}


/**
 * Replaces all occurrences of @a needle in @a haystack with @a replace.
 * As of Geany 0.16, @a replace can match @a needle, so the following will work:
 * @code utils_string_replace_all(text, "\n", "\r\n"); @endcode
 *
 * @param haystack The input string to operate on. This string is modified in place.
 * @param needle The string which should be replaced.
 * @param replace The replacement for @a needle.
 *
 * @return Number of replacements made.
 **/
GEANY_API_SYMBOL
guint utils_string_replace_all(GString *haystack, const gchar *needle, const gchar *replace)
{
        guint count = 0;
        gint pos = 0;
        gsize needle_length = strlen(needle);

        while (1)
        {
                pos = utils_string_find(haystack, pos, -1, needle);

                if (pos == -1)
                        break;

                pos = utils_string_replace(haystack, pos, needle_length, replace);
                count++;
        }
        return count;
}


/**
 * Replaces only the first occurrence of @a needle in @a haystack
 * with @a replace.
 * For details, see utils_string_replace_all().
 *
 * @param haystack The input string to operate on. This string is modified in place.
 * @param needle The string which should be replaced.
 * @param replace The replacement for @a needle.
 *
 * @return Number of replacements made.
 *
 *  @since 0.16
 */
GEANY_API_SYMBOL
guint utils_string_replace_first(GString *haystack, const gchar *needle, const gchar *replace)
{
        gint pos = utils_string_find(haystack, 0, -1, needle);

        if (pos == -1)
                return 0;

        utils_string_replace(haystack, pos, strlen(needle), replace);
        return 1;
}


/* Similar to g_regex_replace but allows matching a subgroup.
 * match_num: which match to replace, 0 for whole match.
 * literal: FALSE to interpret escape sequences in @a replace.
 * returns: number of replacements.
 * bug: replaced text can affect matching of ^ or \b */
guint utils_string_regex_replace_all(GString *haystack, GRegex *regex,
                guint match_num, const gchar *replace, gboolean literal)
{
        GMatchInfo *minfo;
        guint ret = 0;
        gint start = 0;

        g_assert(literal); /* escapes not implemented yet */
        g_return_val_if_fail(replace, 0);

        /* ensure haystack->str is not null */
        if (haystack->len == 0)
                return 0;

        /* passing a start position makes G_REGEX_MATCH_NOTBOL automatic */
        while (g_regex_match_full(regex, haystack->str, -1, start, 0, &minfo, NULL))
        {
                gint end, len;

                g_match_info_fetch_pos(minfo, match_num, &start, &end);
                len = end - start;
                utils_string_replace(haystack, start, len, replace);
                ret++;

                /* skip past whole match */
                g_match_info_fetch_pos(minfo, 0, NULL, &end);
                start = end - len + strlen(replace);
                g_match_info_free(minfo);
        }
        g_match_info_free(minfo);
        return ret;
}


/* Get project or default startup directory (if set), or NULL. */
const gchar *utils_get_default_dir_utf8(void)
{
        if (app->project && !EMPTY(app->project->base_path))
        {
                return app->project->base_path;
        }

        if (!EMPTY(prefs.default_open_path))
        {
                return prefs.default_open_path;
        }
        return NULL;
}


/**
 *  Wraps @c spawn_sync(), which see.
 *
 *  @param dir @nullable The child's current working directory, or @c NULL to inherit parent's.
 *  @param argv The child's argument vector.
 *  @param env @nullable The child's environment, or @c NULL to inherit parent's.
 *  @param flags Ignored.
 *  @param child_setup @girskip Ignored.
 *  @param user_data @girskip Ignored.
 *  @param std_out @out @optional The return location for child output, or @c NULL.
 *  @param std_err @out @optional The return location for child error messages, or @c NULL.
 *  @param exit_status @out @optional The child exit status, as returned by waitpid(), or @c NULL.
 *  @param error The return location for error or @c NULL.
 *
 *  @return @c TRUE on success, @c FALSE if an error was set.
 **/
GEANY_API_SYMBOL
gboolean utils_spawn_sync(const gchar *dir, gchar **argv, gchar **env, GSpawnFlags flags,
                                                  GSpawnChildSetupFunc child_setup, gpointer user_data, gchar **std_out,
                                                  gchar **std_err, gint *exit_status, GError **error)
{
        GString *output = std_out ? g_string_new(NULL) : NULL;
        GString *errors = std_err ? g_string_new(NULL) : NULL;
        gboolean result = spawn_sync(dir, NULL, argv, env, NULL, output, errors, exit_status, error);

        if (std_out)
                *std_out = g_string_free(output, !result);

        if (std_err)
                *std_err = g_string_free(errors, !result);

        return result;
}


/**
 *  Wraps @c spawn_async(), which see.
 *
 *  @param dir @nullable The child's current working directory, or @c NULL to inherit parent's.
 *  @param argv The child's argument vector.
 *  @param env @nullable The child's environment, or @c NULL to inherit parent's.
 *  @param flags Ignored.
 *  @param child_setup @girskip Ignored.
 *  @param user_data Ignored.
 *  @param child_pid @out @nullable The return location for child process ID, or @c NULL.
 *  @param error The return location for error or @c NULL.
 *
 *  @return @c TRUE on success, @c FALSE if an error was set.
 **/
GEANY_API_SYMBOL
gboolean utils_spawn_async(const gchar *dir, gchar **argv, gchar **env, GSpawnFlags flags,
                                                   GSpawnChildSetupFunc child_setup, gpointer user_data, GPid *child_pid,
                                                   GError **error)
{
        return spawn_async(dir, NULL, argv, env, child_pid, error);
}


/* Returns "file:///" on Windows, "file://" everywhere else */
const gchar *utils_get_uri_file_prefix(void)
{
#ifdef G_OS_WIN32
        return "file:///";
#else
        return "file://";
#endif
}


/* Retrieves the path for the given URI.
 * It returns:
 * - the path which was determined by g_filename_from_uri() or GIO
 * - NULL if the URI is non-local and gvfs-fuse is not installed
 * - a new copy of 'uri' if it is not an URI. */
gchar *utils_get_path_from_uri(const gchar *uri)
{
        gchar *locale_filename;

        g_return_val_if_fail(uri != NULL, NULL);

        if (! utils_is_uri(uri))
                return g_strdup(uri);

        /* this will work only for 'file://' URIs */
        locale_filename = g_filename_from_uri(uri, NULL, NULL);
        /* g_filename_from_uri() failed, so we probably have a non-local URI */
        if (locale_filename == NULL)
        {
                GFile *file = g_file_new_for_uri(uri);
                locale_filename = g_file_get_path(file);
                g_object_unref(file);
                if (locale_filename == NULL)
                {
                        geany_debug("The URI '%s' could not be resolved to a local path. This means "
                                "that the URI is invalid or that you don't have gvfs-fuse installed.", uri);
                }
        }

        return locale_filename;
}


gboolean utils_is_uri(const gchar *uri)
{
        g_return_val_if_fail(uri != NULL, FALSE);

        return (strstr(uri, "://") != NULL);
}


/* path should be in locale encoding */
gboolean utils_is_remote_path(const gchar *path)
{
        g_return_val_if_fail(path != NULL, FALSE);

        /* if path is an URI and it doesn't start "file://", we take it as remote */
        if (utils_is_uri(path) && strncmp(path, "file:", 5) != 0)
                return TRUE;

#ifndef G_OS_WIN32
        {
                static gchar *fuse_path = NULL;
                static gsize len = 0;

                if (G_UNLIKELY(fuse_path == NULL))
                {
                        fuse_path = g_build_filename(g_get_home_dir(), ".gvfs", NULL);
                        len = strlen(fuse_path);
                }
                /* Comparing the file path against a hardcoded path is not the most elegant solution
                 * but for now it is better than nothing. Ideally, g_file_new_for_path() should create
                 * proper GFile objects for Fuse paths, but it only does in future GVFS
                 * versions (gvfs 1.1.1). */
                return (strncmp(path, fuse_path, len) == 0);
        }
#endif

        return FALSE;
}


/* Remove all relative and untidy elements from the path of @a filename.
 * @param filename must be a valid absolute path.
 * @see utils_get_real_path() - also resolves links. */
void utils_tidy_path(gchar *filename)
{
        GString *str;
        const gchar *needle;
        gboolean preserve_double_backslash = FALSE;

        g_return_if_fail(g_path_is_absolute(filename));

        str = g_string_new(filename);

        if (str->len >= 2 && strncmp(str->str, "\\\\", 2) == 0)
                preserve_double_backslash = TRUE;

#ifdef G_OS_WIN32
        /* using MSYS we can get Unix-style separators */
        utils_string_replace_all(str, "/", G_DIR_SEPARATOR_S);
#endif
        /* replace "/./" and "//" */
        utils_string_replace_all(str, G_DIR_SEPARATOR_S "." G_DIR_SEPARATOR_S, G_DIR_SEPARATOR_S);
        utils_string_replace_all(str, G_DIR_SEPARATOR_S G_DIR_SEPARATOR_S, G_DIR_SEPARATOR_S);

        if (preserve_double_backslash)
                g_string_prepend(str, "\\");

        /* replace "/../" */
        needle = G_DIR_SEPARATOR_S ".." G_DIR_SEPARATOR_S;
        while (1)
        {
                const gchar *c = strstr(str->str, needle);
                if (c == NULL)
                        break;
                else
                {
                        gssize pos, sub_len;

                        pos = c - str->str;
                        if (pos <= 3)
                                break;  /* bad path */

                        /* replace "/../" */
                        g_string_erase(str, pos, strlen(needle));
                        g_string_insert_c(str, pos, G_DIR_SEPARATOR);

                        /* search for last "/" before found "/../" */
                        c = g_strrstr_len(str->str, pos, G_DIR_SEPARATOR_S);
                        sub_len = pos - (c - str->str);
                        if (! c)
                                break;  /* bad path */

                        pos = c - str->str;     /* position of previous "/" */
                        g_string_erase(str, pos, sub_len);
                }
        }
        if (str->len <= strlen(filename))
                memcpy(filename, str->str, str->len + 1);
        else
                g_warn_if_reached();
        g_string_free(str, TRUE);
}


/**
 *  Removes characters from a string, in place.
 *
 *  @param string String to search.
 *  @param chars Characters to remove.
 *
 *  @return @a string - return value is only useful when nesting function calls, e.g.:
 *  @code str = utils_str_remove_chars(g_strdup("f_o_o"), "_"); @endcode
 *
 *  @see @c g_strdelimit.
 **/
GEANY_API_SYMBOL
gchar *utils_str_remove_chars(gchar *string, const gchar *chars)
{
        const gchar *r;
        gchar *w = string;

        g_return_val_if_fail(string, NULL);
        if (G_UNLIKELY(EMPTY(chars)))
                return string;

        foreach_str(r, string)
        {
                if (!strchr(chars, *r))
                        *w++ = *r;
        }
        *w = 0x0;
        return string;
}


/* Gets list of sorted filenames with no path and no duplicates from user and system config */
GSList *utils_get_config_files(const gchar *subdir)
{
        gchar *path = g_build_path(G_DIR_SEPARATOR_S, app->configdir, subdir, NULL);
        GSList *list = utils_get_file_list_full(path, FALSE, FALSE, NULL);
        GSList *syslist, *node;

        if (!list)
        {
                utils_mkdir(path, FALSE);
        }
        SETPTR(path, g_build_path(G_DIR_SEPARATOR_S, app->datadir, subdir, NULL));
        syslist = utils_get_file_list_full(path, FALSE, FALSE, NULL);
        /* merge lists */
        list = g_slist_concat(list, syslist);

        list = g_slist_sort(list, (GCompareFunc) utils_str_casecmp);
        /* remove duplicates (next to each other after sorting) */
        foreach_slist(node, list)
        {
                if (node->next && utils_str_equal(node->next->data, node->data))
                {
                        GSList *old = node->next;

                        g_free(old->data);
                        node->next = old->next;
                        g_slist_free1(old);
                }
        }
        g_free(path);
        return list;
}


/* Suffix can be NULL or a string which should be appended to the Help URL like
 * an anchor link, e.g. "#some_anchor". */
gchar *utils_get_help_url(const gchar *suffix)
{
        gchar *uri;
        const gchar *uri_file_prefix = utils_get_uri_file_prefix();
        gint skip = strlen(uri_file_prefix);

        uri = g_strconcat(uri_file_prefix, app->docdir, "/index.html", NULL);
#ifdef G_OS_WIN32
        g_strdelimit(uri, "\\", '/'); /* replace '\\' by '/' */
#endif

        if (! g_file_test(uri + skip, G_FILE_TEST_IS_REGULAR))
        {       /* fall back to online documentation if it is not found on the hard disk */
                g_free(uri);
                uri = g_strconcat(GEANY_HOMEPAGE, "manual/", PACKAGE_VERSION, "/index.html", NULL);
        }

        if (suffix != NULL)
        {
                SETPTR(uri, g_strconcat(uri, suffix, NULL));
        }

        return uri;
}


static gboolean str_in_array(const gchar **haystack, const gchar *needle)
{
        const gchar **p;

        for (p = haystack; *p != NULL; ++p)
        {
                if (utils_str_equal(*p, needle))
                        return TRUE;
        }
        return FALSE;
}


/**
 * Copies the current environment into a new array.
 * @a exclude_vars is a @c NULL-terminated array of variable names which should be not copied.
 * All further arguments are key, value pairs of variables which should be added to
 * the environment.
 *
 * The argument list must be @c NULL-terminated.
 *
 * @param exclude_vars @c NULL-terminated array of variable names to exclude.
 * @param first_varname Name of the first variable to copy into the new array.
 * @param ... Key-value pairs of variable names and values, @c NULL-terminated.
 *
 * @return @transfer{full} The new environment array. Use @c g_strfreev() to free it.
 **/
GEANY_API_SYMBOL
gchar **utils_copy_environment(const gchar **exclude_vars, const gchar *first_varname, ...)
{
        gchar **result;
        gchar **p;
        gchar **env;
        va_list args;
        const gchar *key, *value;
        guint n, o;

        /* count the additional variables */
        va_start(args, first_varname);
        for (o = 1; va_arg(args, gchar*) != NULL; o++);
        va_end(args);
        /* the passed arguments should be even (key, value pairs) */
        g_return_val_if_fail(o % 2 == 0, NULL);

        o /= 2;

        /* get all the environ variables */
        env = g_listenv();

        /* create an array large enough to hold the new environment */
        n = g_strv_length(env);
        /* 'n + o + 1' could leak a little bit when exclude_vars is set */
        result = g_new(gchar *, n + o + 1);

        /* copy the environment */
        for (n = 0, p = env; *p != NULL; ++p)
        {
                /* copy the variable */
                value = g_getenv(*p);
                if (G_LIKELY(value != NULL))
                {
                        /* skip excluded variables */
                        if (exclude_vars != NULL && str_in_array(exclude_vars, *p))
                                continue;

                        result[n++] = g_strconcat(*p, "=", value, NULL);
                }
        }
        g_strfreev(env);

        /* now add additional variables */
        va_start(args, first_varname);
        key = first_varname;
        value = va_arg(args, gchar*);
        while (key != NULL)
        {
                result[n++] = g_strconcat(key, "=", value, NULL);

                key = va_arg(args, gchar*);
                if (key == NULL)
                        break;
                value = va_arg(args, gchar*);
        }
        va_end(args);

        result[n] = NULL;

        return result;
}


/* Joins @a first and @a second into a new string vector, freeing the originals.
 * The original contents are reused. */
gchar **utils_strv_join(gchar **first, gchar **second)
{
        gchar **strv;
        gchar **rptr, **wptr;

        if (!first)
                return second;
        if (!second)
                return first;

        strv = g_new0(gchar*, g_strv_length(first) + g_strv_length(second) + 1);
        wptr = strv;

        foreach_strv(rptr, first)
                *wptr++ = *rptr;
        foreach_strv(rptr, second)
                *wptr++ = *rptr;

        g_free(first);
        g_free(second);
        return strv;
}

/* * Returns the common prefix in a list of strings.
 *
 * The size of the list may be given explicitely, but defaults to @c g_strv_length(strv).
 *
 * @param strv The list of strings to process.
 * @param strv_len The number of strings contained in @a strv. Can be -1 if it's terminated by @c NULL.
 *
 * @return The common prefix that is part of all strings (maybe empty), or NULL if an empty list
 *         was passed in.
 */
GEANY_EXPORT_SYMBOL
gchar *utils_strv_find_common_prefix(gchar **strv, gssize strv_len)
{
        gsize num;

        if (strv_len == 0)
                return NULL;

        num = (strv_len == -1) ? g_strv_length(strv) : (gsize) strv_len;

        for (gsize i = 0; strv[0][i]; i++)
        {
                for (gsize j = 1; j < num; j++)
                {
                        if (strv[j][i] != strv[0][i])
                        {
                                /* return prefix on first mismatch */
                                return g_strndup(strv[0], i);
                        }
                }
        }

        return g_strdup(strv[0]);
}


/* * Returns the longest common substring in a list of strings.
 *
 * The size of the list may be given explicitely, but defaults to @c g_strv_length(strv).
 *
 * @param strv The list of strings to process.
 * @param strv_len The number of strings contained in @a strv. Can be -1 if it's terminated by @c NULL.
 *
 * @return The common prefix that is part of all strings.
 */
GEANY_EXPORT_SYMBOL
gchar *utils_strv_find_lcs(gchar **strv, gssize strv_len, const gchar *delim)
{
        gchar *first, *_sub, *sub;
        gsize num;
        gsize n_chars;
        gsize len;
        gsize max = 0;
        char *lcs;
        gsize found;

        if (strv_len == 0)
                return NULL;

        num = (strv_len == -1) ? g_strv_length(strv) : (gsize) strv_len;

        first = strv[0];
        len = strlen(first);

        /* sub is the working area where substrings from first are copied to */
        sub = g_malloc(len+1);
        lcs = g_strdup("");
        foreach_str(_sub, first)
        {
                gsize chars_left = len - (_sub - first);
                /* No point in continuing if the remainder is too short */
                if (max > chars_left)
                        break;
                /* If delimiters are given, we only need to compare substrings which start and
                 * end with one of them, so skip any non-delim chars at front ... */
                if (NZV(delim) && (strchr(delim, _sub[0]) == NULL))
                        continue;
                for (n_chars = 1; n_chars <= chars_left; n_chars++)
                {
                        if (NZV(delim))
                        {       /* ... and advance to the next delim char at the end, if any */
                                if (!_sub[n_chars] || strchr(delim, _sub[n_chars]) == NULL)
                                        continue;
                                n_chars += 1;
                        }
                        g_strlcpy(sub, _sub, n_chars+1);
                        found = 1;
                        for (gsize i = 1; i < num; i++)
                        {
                                if (strstr(strv[i], sub) == NULL)
                                        break;
                                found++;
                        }
                        if (found == num && n_chars > max)
                        {
                                max = n_chars;
                                SETPTR(lcs, g_strdup(sub));
                        }
                }
        }
        g_free(sub);

        return lcs;
}


/** Transform file names in a list to be shorter.
 *
 * This function takes a list of file names (probably with absolute paths), and
 * transforms the paths such that they are short but still unique. This is intended
 * for dialogs which present the file list to the user, where the base name may result
 * in duplicates (showing the full path might be inappropriate).
 *
 * The algorthm strips the common prefix (e-g. the user's home directory) and
 * replaces the longest common substring with an ellipsis ("...").
 *
 * @param file_names @array{length=file_names_len} The list of strings to process.
 * @param file_names_len The number of strings contained in @a file_names. Can be -1 if it's
 *        terminated by @c NULL.
 * @return @transfer{full} A newly-allocated array of transformed paths strings, terminated by
            @c NULL. Use @c g_strfreev() to free it.
 *
 * @since 1.34 (API 239)
 */
GEANY_API_SYMBOL
gchar **utils_strv_shorten_file_list(gchar **file_names, gssize file_names_len)
{
        gsize num;
        gsize i;
        gchar *prefix, *lcs, *end;
        gchar **names;
        gsize prefix_len = 0, lcs_len = 0;

        if (file_names_len == 0)
                return g_new0(gchar *, 1);

        g_return_val_if_fail(file_names != NULL, NULL);

        num = (file_names_len == -1) ? g_strv_length(file_names) : (gsize) file_names_len;
        /* Always include a terminating NULL, enables easy freeing with g_strfreev()
         * We just copy the pointers so we can advance them here. But don't
         * forget to duplicate the strings before returning.
         */
        names = g_new(gchar *, num + 1);
        memcpy(names, file_names, num * sizeof(gchar *));
        /* Always include a terminating NULL, enables easy freeing with g_strfreev() */
        names[num] = NULL;

        /* First: determine the common prefix, that will be stripped.
         * We only want to strip full path components, including the trailing slash.
         * Except if the component is just "/".
         */
        prefix = utils_strv_find_common_prefix(names, num);
        end = strrchr(prefix, G_DIR_SEPARATOR);
        if (end && end > prefix)
        {
                prefix_len = end - prefix + 1; /* prefix_len includes the trailing slash */
                for (i = 0; i < num; i++)
                        names[i] += prefix_len;
        }

        /* Second: determine the longest common substring (lcs), that will be ellipsized. Again,
         * we look only for full path compnents so that we ellipsize between separators. This implies
         * that the file name cannot be ellipsized which is desirable anyway.
         */
        lcs = utils_strv_find_lcs(names, num, G_DIR_SEPARATOR_S"/");
        if (lcs)
        {
                lcs_len = strlen(lcs);
                /* Don't bother for tiny common parts (which are often just "." or "/"). Beware
                 * that lcs includes the enclosing dir separators so the part must be at least 5 chars
                 * to be eligible for ellipsizing.
                 */
                if (lcs_len < 7)
                        lcs_len = 0;
        }

        /* Last: build the shortened list of unique file names */
        for (i = 0; i < num; i++)
        {
                if (lcs_len == 0)
                {       /* no lcs, copy without prefix */
                        names[i] = g_strdup(names[i]);
                }
                else
                {
                        const gchar *lcs_start = strstr(names[i], lcs);
                        const gchar *lcs_end = lcs_start + lcs_len;
                        /* Dir seperators are included in lcs but shouldn't be elipsized. */
                        names[i] = g_strdup_printf("%.*s...%s", (int)(lcs_start - names[i] + 1), names[i], lcs_end - 1);
                }
        }

        g_free(lcs);
        g_free(prefix);

        return names;
}


/* Try to parse a date using g_date_set_parse(). It doesn't take any format hint,
 * obviously g_date_set_parse() uses some magic.
 * The returned GDate object must be freed. */
GDate *utils_parse_date(const gchar *input)
{
        GDate *date = g_date_new();

        g_date_set_parse(date, input);

        if (g_date_valid(date))
                return date;

        g_date_free(date);
        return NULL;
}


gchar *utils_parse_and_format_build_date(const gchar *input)
{
        gchar date_buf[255];
        GDate *date = utils_parse_date(input);

        if (date != NULL)
        {
                g_date_strftime(date_buf, sizeof(date_buf), GEANY_TEMPLATES_FORMAT_DATE, date);
                g_date_free(date);
                return g_strdup(date_buf);
        }

        return g_strdup(input);
}


gchar *utils_get_user_config_dir(void)
{
#ifdef G_OS_WIN32
        return win32_get_user_config_dir();
#else
        return g_build_filename(g_get_user_config_dir(), "geany", NULL);
#endif
}


static gboolean is_osx_bundle(void)
{
#ifdef MAC_INTEGRATION
        gchar *bundle_id = gtkosx_application_get_bundle_id();
        if (bundle_id)
        {
                g_free(bundle_id);
                return TRUE;
        }
#endif
        return FALSE;
}


const gchar *utils_resource_dir(GeanyResourceDirType type)
{
        static const gchar *resdirs[RESOURCE_DIR_COUNT] = {NULL};

        if (!resdirs[RESOURCE_DIR_DATA])
        {
#ifdef G_OS_WIN32
                gchar *prefix = win32_get_installation_dir();

                resdirs[RESOURCE_DIR_DATA] = g_build_filename(prefix, "data", NULL);
                resdirs[RESOURCE_DIR_ICON] = g_build_filename(prefix, "share", "icons", NULL);
                resdirs[RESOURCE_DIR_DOC] = g_build_filename(prefix, "share", "doc", "geany", "html", NULL);
                resdirs[RESOURCE_DIR_LOCALE] = g_build_filename(prefix, "share", "locale", NULL);
                resdirs[RESOURCE_DIR_PLUGIN] = g_build_filename(prefix, "lib", "geany", NULL);
                resdirs[RESOURCE_DIR_LIBEXEC] = g_build_filename(prefix, "libexec", "geany", NULL);
                g_free(prefix);
#else
                if (is_osx_bundle())
                {
# ifdef MAC_INTEGRATION
                        gchar *prefix = gtkosx_application_get_resource_path();

                        resdirs[RESOURCE_DIR_DATA] = g_build_filename(prefix, "share", "geany", NULL);
                        resdirs[RESOURCE_DIR_ICON] = g_build_filename(prefix, "share", "icons", NULL);
                        resdirs[RESOURCE_DIR_DOC] = g_build_filename(prefix, "share", "doc", "geany", "html", NULL);
                        resdirs[RESOURCE_DIR_LOCALE] = g_build_filename(prefix, "share", "locale", NULL);
                        resdirs[RESOURCE_DIR_PLUGIN] = g_build_filename(prefix, "lib", "geany", NULL);
                        resdirs[RESOURCE_DIR_LIBEXEC] = g_build_filename(prefix, "libexec", "geany", NULL);
                        g_free(prefix);
# endif
                }
                else
                {
                        resdirs[RESOURCE_DIR_DATA] = g_build_filename(GEANY_DATADIR, "geany", NULL);
                        resdirs[RESOURCE_DIR_ICON] = g_build_filename(GEANY_DATADIR, "icons", NULL);
                        resdirs[RESOURCE_DIR_DOC] = g_build_filename(GEANY_DOCDIR, "html", NULL);
                        resdirs[RESOURCE_DIR_LOCALE] = g_build_filename(GEANY_LOCALEDIR, NULL);
                        resdirs[RESOURCE_DIR_PLUGIN] = g_build_filename(GEANY_LIBDIR, "geany", NULL);
                        resdirs[RESOURCE_DIR_LIBEXEC] = g_build_filename(GEANY_LIBEXECDIR, "geany", NULL);
                }
#endif
        }

        return resdirs[type];
}


void utils_start_new_geany_instance(const gchar *doc_path)
{
        const gchar *command = is_osx_bundle() ? "open" : "geany";
        gchar *exec_path = g_find_program_in_path(command);

        if (exec_path)
        {
                GError *err = NULL;
                const gchar *argv[6]; // max args + 1
                gint argc = 0;

                argv[argc++] = exec_path;
                if (is_osx_bundle())
                {
                        argv[argc++] = "-n";
                        argv[argc++] = "-a";
                        argv[argc++] = "Geany";
                        argv[argc++] = doc_path;
                }
                else
                {
                        argv[argc++] = "-i";
                        argv[argc++] = doc_path;
                }
                argv[argc] = NULL;

                if (!utils_spawn_async(NULL, (gchar**) argv, NULL, 0, NULL, NULL, NULL, &err))
                {
                        g_printerr("Unable to open new window: %s\n", err->message);
                        g_error_free(err);
                }
                g_free(exec_path);
        }
        else
                g_printerr("Unable to find 'geany'\n");
}


/**
 * Get a link-dereferenced, absolute version of a file name.
 *
 * This is similar to the POSIX `realpath` function when passed a
 * @c NULL argument.
 *
 * @warning This function suffers the same problems as the POSIX
 * function `realpath()`, namely that it's impossible to determine
 * a suitable size for the returned buffer, and so it's limited to a
 * maximum of `PATH_MAX`.
 *
 * @param file_name The file name to get the real path of.
 *
 * @return A newly-allocated string containing the real path which
 * should be freed with `g_free()` when no longer needed, or @c NULL
 * if the real path cannot be obtained.
 *
 * @since 1.32 (API 235)
 */
GEANY_API_SYMBOL
gchar *utils_get_real_path(const gchar *file_name)
{
        return tm_get_real_path(file_name);
}


/*
 * Get a string describing the OS.
 *
 * If the OS can be determined, a string which describes the OS will
 * be returned. If no OS can be determined then `NULL` will be returned.
 *
 * @note The format of the returned string is unspecified and is only
 * meant to provide diagnostic information to the user.
 *
 * @return A newly-allocated string containing a description of the
 * OS if it can be determined or `NULL` if it cannot.
 *
 * @since 1.37
 */
gchar *utils_get_os_info_string(void)
{
        gchar *os_info = NULL;

#if GLIB_CHECK_VERSION(2, 64, 0)
# if ! defined(__APPLE__)
        /* on non-macOS operating systems */
        {
                GString *os_str;
                gchar *pretty_name;
                gchar *code_name;

                pretty_name = g_get_os_info(G_OS_INFO_KEY_PRETTY_NAME);
                if (pretty_name == NULL)
                        return NULL;

                os_str = g_string_new(pretty_name);
                g_free(pretty_name);

                code_name = g_get_os_info(G_OS_INFO_KEY_VERSION_CODENAME);
                if (code_name != NULL)
                {
                        g_string_append_printf(os_str, " (%s)", code_name);
                        g_free(code_name);
                }

                os_info = g_string_free(os_str, FALSE);
        }
# else
        /* on macOS, only `G_OS_INFO_KEY_NAME` is supported and returns the
         * fixed string `macOS` */
        os_info = g_get_os_info(G_OS_INFO_KEY_NAME);
# endif
#else
        /* if g_get_os_info() is not available, do it the old-fashioned way */
# if defined(_WIN64)
        os_info = g_strdup("Microsoft Windows (64-bit)");
# elif defined(_WIN32)
        os_info = g_strdup("Microsoft Windows");
# elif defined(__APPLE__)
        os_info = g_strdup("Apple macOS");
# elif defined(__linux__)
        os_info = g_strdup("Linux");
# elif defined(__FreeBSD__)
        os_info = g_strdup("FreeBSD");
# elif defined(__ANDROID__)
        os_info = g_strdup("Android");
# endif
#endif

        return os_info;
}