Scol » Lib2D GTK » Utils_g

/*! \file scol_glib_keyfile.c

*	\brief all functions of this API

*   \author Stephane Bisaro

*/

/*

This source file is part of Scol

For the latest info, see http://www.scolring.org

Copyright (c) 2010 Stephane Bisaro, aka Iri <iri@irizone.net>

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) 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with

this program; if not, write to the Free Software Foundation, Inc., 59 Temple

Place - Suite 330, Boston, MA 02111-1307, USA, or go to

http://www.gnu.org/copyleft/lesser.txt

For others informations, please contact us from http://www.scolring.org/

*/

#include "../include/scol_glib_keyfile.h"

#if ((defined _WIN32) || (defined __WIN32__))

cbmachine ww;

#endif

mmachine  mm;

/**

 * \brief GKF_VALUE_RAW : I : flag used to load a key file. The raw value associated with key under group.

 * The value can be escaped string

 */

int GKF_VALUE_RAW (mmachine m) { return MMpush (m, ITOM (1)); }

/**

 * \brief GKF_VALUE_STRING : I : flag used to load a key file. The string value associated with key under group.

 * Unlike GKF_VALUE_RAW, any escaped sequence are unescaped

 */

int GKF_VALUE_STRING (mmachine m) { return MMpush (m, ITOM (2)); }

/**

 * \brief GKF_VALUE_INTEGER : Not implemented yet

 */

int GKF_VALUE_INTEGER (mmachine m) { return MMpush (m, ITOM (3)); }

/**

 * \brief GKF_VALUE_INTEGER64 : Not implemented yet

 */

int GKF_VALUE_INTEGER64 (mmachine m) { return MMpush (m, ITOM (4)); }

/**

 * \brief GKF_VALUE_UINTEGER64 : Not implemented yet

 */

int GKF_VALUE_UINTEGER64 (mmachine m) { return MMpush (m, ITOM (5)); }

/**

 * \brief GKF_VALUE_DOUBLE : Not implemented yet

 */

int GKF_VALUE_DOUBLE (mmachine m) { return MMpush (m, ITOM (6)); }

/**

 * \brief GKF_VALUE_BOOLEAN : Not implemented yet

 */

int GKF_VALUE_BOOLEAN (mmachine m) { return MMpush (m, ITOM (7)); }

/**

 * \brief _gkeyFileReadP : read a key file

 * fun [P S] [[S [[S S] r1]] r1]

 *

 * \param P : any file (read reference only)

 * \param S : the list seperator, or nil (default ";")

 * \return [[S [[S S] r1]] r1] : the list of datas : group names and for each group name, a list of tuple [key value]

 */

int SCOL_gkeyFileReadP (mmachine m)

{

    int mfile, msep;

    gboolean b;

    GKeyFile *ini;

    GError *err = NULL;

    msep = MTOP (MMpull (m));

    mfile = MMpull (m);

    if (mfile == NIL)

    {

        MMpush (m, NIL);

        return 0;

    }

    ini = g_key_file_new ();

    if (msep != NIL)

        g_key_file_set_list_separator (ini, (MMstart (m, msep))[0]);

    b = g_key_file_load_from_file (ini, MMstartstr (m, MTOP (mfile)), G_KEY_FILE_NONE, &err);

    if (!b)

    {

        MMechostr (0, "SCOL_gkeyFileReadP load error : %d .:. %s\n", err->code, err->message);

        g_error_free (err);

        MMpush (m, NIL);

        return 0;

    }

    g_key_file_free (ini);

    return scol_g_key_file_read (ini, m);

}

/* ========================================================================= */

/** \private

 * internal function : get groups names

 */

int scol_g_key_file_get_groups (mmachine m, int flag)

{

    int mini;

    int i = 0;

    gsize len = 0;

    GKeyFile *ini;

    gchar **groups;

    mini = MMpull (m);

    if (mini == NIL)

    {

        MMechostr (0, "scol_g_key_file_get_groups error : object is nil\n");

        MMpush (m, NIL);

        return 0;

    }

    ini = (GKeyFile*) MMfetch (m, MTOP (mini), OBJGKEYFILE_HANDLE);

    groups = g_key_file_get_groups (ini, &len);

    if (flag)

        MMpush (m, ITOM ((int) len));   /* I */

    else

    {

        for (i = 0; i < (int) len; i++)

            Mpushstrbloc (m, groups[i]);

        MMpush (m, NIL);

        for (i = 0; i < (int) len; i++)

        {

            MMpush (m, ITOM (2));

            MBdeftab (m);

        }                               /* [S r1] */

    }

    g_strfreev (groups);

    return 0;

}

/** \private

 * internal function : return a list of the entire content ( [[S [[S S] r1]] r1] )

 */

int scol_g_key_file_read (GKeyFile *ini, mmachine m)

{

    int i, j;

    gsize ngroups, nkeys;

    gchar **groups;

    groups = g_key_file_get_groups (ini, &ngroups);

    for (i = 0; i < (int) ngroups; i++)

    {

        gchar **keys;

        Mpushstrbloc (m, groups[i]);    /* S */

        keys = g_key_file_get_keys (ini, groups[i], &nkeys, NULL);

        for (j = 0; j < (int) nkeys; j++)

        {

            gchar *value;

            value = g_key_file_get_value (ini, groups[i], keys[j], NULL);

            Mpushstrbloc (m, keys[j]);

            Mpushstrbloc (m, value);

            MMpush (m, ITOM (2));

            MBdeftab (m);               /* [S S] */

            g_free (value);

        }

        g_strfreev (keys);

        MMpush (m, NIL);

        for (j = 0; j < (int) nkeys; j++)

        {

            MMpush (m, ITOM (2));

            MBdeftab (m);

        }                               /* [[S S] r1] */

        MMpush (m, ITOM (2));

        MBdeftab (m);                   /* [S [[S S] r1]] */

    }

    g_strfreev (groups);

    MMpush (m, NIL);

    for (i = 0; i < (int) ngroups; i++)

    {

        MMpush (m, ITOM (2));

        MBdeftab (m);

    }                                   /* [[S [[S S] r1]] r1] */

    return 0;

}

/** \private

 * internal function : load a file or data

 */

int scol_g_key_file_load (mmachine m, int typ)

{

    int mchannel, mfile, msep, mflag;

    int initab;

    gboolean b;

    GKeyFileFlags flag = G_KEY_FILE_NONE;

    GKeyFile *ini;

    GError *err = NULL;

    mflag = MTOI (MMpull (m));

    msep = MTOP (MMpull (m));

    mfile = MMpull (m);

    mchannel = MMget (m, 0);

    if (mchannel == NIL)

    {

        MMechostr (0, "scol_g_key_file_load error : channel is nil\n");

        MMpush (m, NIL);

        return 0;

    }

    if (mfile == NIL)

    {

        MMechostr (0, "scol_g_key_file_load error : file is nil\n");

        MMpush (m, NIL);

        return 0;

    }

    ini = g_key_file_new ();

    if (msep != NIL)

        g_key_file_set_list_separator (ini, (MMstart (m, msep))[0]);

    if (mflag == 1)

        flag = G_KEY_FILE_KEEP_COMMENTS;

    else if (mflag == 2)

        flag = G_KEY_FILE_KEEP_TRANSLATIONS;

    else if (mflag == 3)

        flag = G_KEY_FILE_KEEP_TRANSLATIONS|G_KEY_FILE_KEEP_COMMENTS;

    if (typ)

        b = g_key_file_load_from_data (ini, MMstartstr (m, MTOP (mfile)), MMsizestr (m, MTOP (mfile)), flag, &err);

    else

        b = g_key_file_load_from_file (ini, MMstartstr (m, MTOP (mfile)), flag, &err);

    if ((!b) || (err != NULL))

    {

        MMechostr (0, "scol_g_key_file_load error : loading is failed -> %s\n", err->message);

        g_error_free (err);

        MMpush (m, NIL);

        return 0;

    }

    initab = MMmalloc (m, sizeof (ini) + 1, TYPETAB);

    if (initab == NIL)

    {

        MMechostr (0, "scol_g_key_file_load error : not enough memory\n");

        MMpull (m);

        MMpush (m, NIL);

        g_key_file_free (ini);

        return 0;

    }

    MMstore (m, initab, OBJGKEYFILE_HANDLE, (int) ini);

    MMpush (m, PTOM (initab));

    OBJcreate (m, ObjKeyFile, (int) ini, -1, -1);

    return 0;

}

/**

 * \brief _gkeyFileLoadP : Loads a key file from any valid file

 *

 * fun [Chn P S I] ObjKeyFile

 *

 * \param Chn : the channel

 * \param P : any read referenced file

 * \param S : the list separator or nil (default ";"). One character only (if more, they are ignored)

 * \param I : flag :

 *      0 -> No flags, default behaviour

 *      1 -> Use this flag if you plan to write the (possibly modified) contents of the key file back to a file;

 *      otherwise all comments will be lost when the key file is written back.

 *      2 -> Use this flag if you plan to write the (possibly modified) contents of the key file back to a file;

 *      otherwise only the translations for the current language will be written back.

 *      3 -> 1 and 2

 * \return ObjKeyFile : the new object, or nil if error

 *

 * Importante note : if you want get/set any localized key, be sure set the flag to 2 (or 3) !

 */

int SCOL_gkeyFileLoadP (mmachine m)

{

    return scol_g_key_file_load (m, 0);

}

/**

 * \brief _gkeyFileLoadS : Loads a key file from any valid data

 *

 * fun [Chn P S I] ObjKeyFile

 *

 * \param Chn : the channel

 * \param S : any valid content

 * \param S : the list separator or nil (default ";"). One character only (if more, they are ignored)

 * \param I : flag :

 *      0 -> No flags, default behaviour

 *      1 -> Use this flag if you plan to write the (possibly modified) contents of the key file back to a file;

 *      otherwise all comments will be lost when the key file is written back.

 *      2 -> Use this flag if you plan to write the (possibly modified) contents of the key file back to a file;

 *      otherwise only the translations for the current language will be written back.

 *      3 -> 1 and 2

 * \return ObjKeyFile : the new object, or nil if error

 */

int SCOL_gkeyFileLoadS (mmachine m)

{

    return scol_g_key_file_load (m, 1);

}

/**

 * \brief _gkeyFileSave : save a keyfile to a filename

 *

 * fun [ObjKeyFile W] I

 *

 * \param ObjKeyFile : a valid object

 * \param W : a Scol write referenced filename

 * \return I : 0 if success or nil if error (see log message)

 */

int SCOL_gkeyFileSave (mmachine m)

{

    int mini, mwfile;

    gboolean b;

    GKeyFile *ini;

    gchar *content, *wfile;

    gsize len = 0;

    GError *err = NULL;

    mwfile = MMpull (m);

    mini = MMpull (m);

    if ((mini == NIL) || (mwfile == NIL))

    {

        MMechostr (0, "SCOL_gkeyFileSave error : bad(s) argument(s) !\n");

        MMpush (m, NIL);

        return 0;

    }

    ini = (GKeyFile*) MMfetch (m, MTOP (mini), OBJGKEYFILE_HANDLE);

    wfile = MMstartstr (m, MTOP (mwfile));

    content = g_key_file_to_data (ini, &len, &err);

    if ((content == NULL) || (err != NULL))

    {

        MMechostr (0, "SCOL_gkeyFileSave error : %d ->  %s !\n", err->code, err->message);

        g_error_free (err);

        MMpush (m, NIL);

        return 0;

    }

    b = g_file_set_contents (wfile, content, len, &err);

    if ((!b) || (err != NULL))

    {

        MMechostr (0, "SCOL_gkeyFileSave error : %d ->  %s !\n", err->code, err->message);

        g_error_free (err);

        MMpush (m, NIL);

        return 0;

    }

    g_free (content);

    MMpush (m, ITOM (0));

    return 0;

}

/**

 *\brief _gkeyFileDestroy : Destroys an object

 *

 * \param ObjKeyFile

 * \return I : O or nil if error

 */

int SCOL_gkeyFileDestroy (mmachine m)

{

    int mini;

    GKeyFile *ini;

    mini = MMpull (m);

    if (mini == NIL)

    {

        MMechostr (0, "SCOL_gkeyFileDestroy error : object is nil\n");

        MMpush (m, NIL);

        return 0;

    }

    ini = (GKeyFile*) MMfetch (m, MTOP (mini), OBJGKEYFILE_HANDLE);

    g_key_file_free (ini);

    OBJdelTM (m, ObjKeyFile, mini);

    MMpush (m, 0);

    return 0;

}

/**

 * \brief _gkeyFileGetContent : Returns the content of key file

 *

 * fun [ObjKeyFile] [S I]

 *

 * \param ObjKeyFile : any valid object

 * \return [S I] : a tuple : the content and its length or nil if error

 */

int SCOL_gkeyFileGetContent (mmachine m)

{

    int mini;

    gchar *content;

    gsize len = 0;

    GKeyFile *ini;

    mini = MMpull (m);

    if (mini == NIL)

    {

        MMechostr (0, "SCOL_gkeyFileGetContent error : object is nil\n");

        MMpush (m, NIL);

        return 0;

    }

    ini = (GKeyFile*) MMfetch (m, MTOP (mini), OBJGKEYFILE_HANDLE);

    content = g_key_file_to_data (ini, &len, NULL);

    Mpushstrbloc (m, content);

    MMpush (m, ITOM ((int) len));

    MMpush (m, ITOM (2));

    MBdeftab (m);

    g_free (content);

    return 0;

}

/**

 * \brief _gkeyFileGetDatas : Return a list of the content

 *

 * fun [ObjKeyFile] [[S [[S S] r1]] r1]

 *

 * \param ObjKeyFile : an object already created

 * \return [[S [[S S] r1]] r1] : a list of group names and for each group name, a list of tuple [key value] or nil if error

 */

int SCOL_gkeyFileGetDatas (mmachine m)

{

    int mini;

    GKeyFile *ini;

    mini = MMpull (m);

    if (mini == NIL)

    {

        MMechostr (0, "SCOL_gkeyFileGetDatas error : object is nil\n");

        MMpush (m, NIL);

        return 0;

    }

    ini = (GKeyFile*) MMfetch (m, MTOP (mini), OBJGKEYFILE_HANDLE);

    return scol_g_key_file_read (ini, m);

}

/**

 * \brief _gkeyFileGetGroups : Returns a list of all groups

 *

 * fun [ObjKeyFile] [S r1]

 *

 * \param ObjKeyFile : any object already created

 * \return [S r1] : this list or nil if error

 */

int SCOL_gkeyFileGetGroups (mmachine m)

{

    return scol_g_key_file_get_groups (m, 0);

}

/**

 * \brief _gkeyFileGetNbGroups : Returns the number of group

 *

 * fun [ObjKeyFile] I

 *

 * \param ObjKeyFile : any object already created

 * \return I : this number or nil if error

 */

int SCOL_gkeyFileGetNbGroups (mmachine m)

{

    return scol_g_key_file_get_groups (m, 1);

}

/**

 * \brief _gkeyFileDataExist : Looks whether the key file has the datas

 *

 * fun [ObjKeyFile S S] I

 *

 * \param ObjKeyFile : any object already created

 * \param S : a group name or nil

 * \param S : a key name or nil

 * \return I : the result (see below) or nil if error

 *

 * If the group name and the key name are not nil, this function searches the key into the group.

 * If found, 1 is returned, else 0

 * If the group name is nil, this function searches the key into all groups.

 * The returned value is the number of this key, 0 if not found.

 * If the key name is nil, this function searches the group into the keyfile.

 * If found, 1 is returned, else 0.

 * If the keyfile is nil or if the group and key names are nil, nil is returned.

 */

int SCOL_gkeyFileDataExist (mmachine m)

{

    int mini, mgroup, mkey;

    GKeyFile *ini;

    gboolean b;

    mkey = MMpull (m);

    mgroup = MMpull (m);

    mini = MMpull (m);

    if (mini == NIL)

    {

        MMechostr (0, "SCOL_gkeyFileDataExist error : object is nil\n");

        MMpush (m, NIL);

        return 0;

    }

    if ((mkey == NIL) && (mgroup == NIL))

    {

        MMechostr (0, "SCOL_gkeyFileDataExist error : group and key are nil\n");

        MMpush (m, NIL);

        return 0;

    }

    ini = (GKeyFile*) MMfetch (m, MTOP (mini), OBJGKEYFILE_HANDLE);

    if (mkey == NIL)    /* search a group only */

    {

        b = g_key_file_has_group (ini, MMstartstr (m, MTOP (mgroup)));

        MMpush (m, ITOM (b));

        return 0;

    }

    if (mgroup == NIL)  /* search a key in all groups */

    {

        gchar ** groups;

        gsize len = 0;

        int i, r = 0;

        groups = g_key_file_get_groups (ini, &len);

        for (i = 0; i < len; i++)

        {

            if (g_key_file_has_key (ini, groups[i], MMstartstr (m, MTOP (mkey)), NULL))

                r++;

        }

        MMpush (m, ITOM (r));

        g_strfreev (groups);

        return 0;

    }

    /* search a key in a group */

    b = g_key_file_has_key (ini, MMstartstr (m, MTOP (mgroup)), MMstartstr (m, MTOP (mkey)), NULL);

    MMpush (m, ITOM (b));

    return 0;

}

/**

 * \brief _keyFileGetValue : Returns the value for any key in any group

 *

 * fun [ObjKeyFile S S I] S

 *

 * \param ObjKeyFile : any valid object

 * \param S : any group name

 * \param S : any key name

 * \param I : flag : GKF_VALUE_RAW, GKF_VALUE_STRING, GKF_VALUE_INTEGER, GKF_VALUE_INTEGER64, GKF_VALUE_UINTEGER64, GKF_VALUE_DOUBLE, GKF_VALUE_BOOLEAN

 * GKF_VALUE_RAW and GKF_VALUE_STRING have a difference, others always return a string

 * \return S : the value or nil if error or not found

 */

int SCOL_keyFileGetValue (mmachine m)

{

    int mini, mgroup, mkey, mflag;

    GKeyFile *ini;

    gchar *value, *group, *key;

    GError *err = NULL;

    mflag = MTOI (MMpull (m));

    mkey = MMpull (m);

    mgroup = MMpull (m);

    mini = MMpull (m);

    if ((mini == NIL) || (mkey == NIL) || (mgroup == NIL))

    {

        MMechostr (0, "SCOL_keyFileGetValue error : bad(s) argument(s) !\n");

        MMpush (m, NIL);

        return 0;

    }

    ini = (GKeyFile*) MMfetch (m, MTOP (mini), OBJGKEYFILE_HANDLE);

    group = MMstartstr (m, MTOP (mgroup));

    key = MMstartstr (m, MTOP (mkey));

    switch (mflag)

    {

        case (2) :

            value = g_key_file_get_string (ini, group, key, &err);

            break;

        case (3) :

        {

            int v;

            v = g_key_file_get_integer (ini, group, key, &err);

            value = g_malloc (sizeof (gchar) * 64);

            snprintf (value, 64, "%d", v);

            break;

        }

#ifndef GLIB_224

        case (4) :

        {

            gint64 v;

            v = g_key_file_get_int64 (ini, group, key, &err);

            value = g_malloc (sizeof (gchar) * 64);

            snprintf (value, 64, "%" G_GINT64_MODIFIER "x", v);

            break;

        }

        case (5) :

        {

            guint64 v;

            v = g_key_file_get_uint64 (ini, group, key, &err);

            value = g_malloc (sizeof (gchar) * 64);

            snprintf (value, 64, "%" G_GUINT64_FORMAT "x", v);

            break;

        }

#endif

        case (6) :

        {

            double v;

            v = g_key_file_get_double (ini, group, key, &err);

            value = g_malloc (sizeof (gchar) * 64);

            snprintf (value, 64, "%f", v);

            break;

        }

        case (7) :

        {

            gboolean v;

            v = g_key_file_get_boolean (ini, group, key, &err);

            value = g_malloc (sizeof (gchar) * 64);

            snprintf (value, 64, "%d", v);

            break;

        }

        default :

            value = g_key_file_get_value (ini, group, key, &err);

    }

    if ((value == NULL) || (err != NULL))

    {

        MMechostr (0, "SCOL_keyFileGetValue error : %d -> %s !\n", err->code, err->message);

        g_error_free (err);

        MMpush (m, NIL);

    }

    else

    {

        Mpushstrbloc (m, value);

        g_free (value);

    }

    return 0;

}

/**

 * \brief _keyFileGetLocaleValue : Returns the locale value for any key in any group

 *

 * fun [ObjKeyFile S S S] S

 *

 * \param ObjKeyFile : any valid object

 * \param S : any group name

 * \param S : any key name

 * \param S : any locale identifier or nil

 * \return S : the value or nil if error or not found

 *

 * If locale is nil or not found, the value of the default key (without localization) will be returned

 * When the ObjKeyFile has been created, if the flag is at 0 or 1, the current locale can be used only.

 * In this last case, to get a value of an other locale, the flag should have set to 2 or 3.

 */

int SCOL_keyFileGetLocaleValue (mmachine m)

{

    int mini, mgroup, mkey, mlang;

    GKeyFile *ini;

    gchar *value, *group, *key, *lang = NULL;

    GError *err = NULL;

    mlang = MMpull (m);

    mkey = MMpull (m);

    mgroup = MMpull (m);

    mini = MMpull (m);

    if ((mini == NIL) || (mkey == NIL) || (mgroup == NIL))

    {

        MMechostr (0, "SCOL_keyFileGetLocaleValue error : bad(s) argument(s) !\n");

        MMpush (m, NIL);

        return 0;

    }

    ini = (GKeyFile*) MMfetch (m, MTOP (mini), OBJGKEYFILE_HANDLE);

    group = MMstartstr (m, MTOP (mgroup));

    key = MMstartstr (m, MTOP (mkey));

    if (mlang != NIL)

        lang = MMstartstr (m, MTOP (mlang));

    value = g_key_file_get_locale_string (ini, group, key, lang, &err);

    if ((value == NULL) || (err != NULL))

    {

        MMechostr (0, "SCOL_keyFileGetLocaleValue error : %d -> %s !\n", err->code, err->message);

        g_error_free (err);

        MMpush (m, NIL);

    }

    Mpushstrbloc (m, value);

    g_free (value);

    return 0;

}

/**

 * \brief _gkeyFileGetValueList : Returns the values associated with key under group

 *

 * fun [ObjKeyFile S S] [S r1]

 *

 * \param ObjKeyFile : any valid object

 * \param S : any group name

 * \param S : any key name

 * \return [S r1] : the value or nil if error or not found

 */

int SCOL_gkeyFileGetValueList (mmachine m)

{

    int mini, mgroup, mkey;

    int i;

    GKeyFile *ini;