Scol » Lib2D GTK » Utils_g » GKeyFile

*/

#ifdef __cplusplus

#error This source file is not C++ but rather C. Please use a C-compiler

#endif

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

cbmachine ww;

#endif

mmachine  mm;

/**

 * \brief _gbaseUserName : Returns the user (or real) name

 *

 * fun [] S

 *

 * \param : nothing

 * \return S : this name

 */

int SCOL_gbaseUserName (mmachine m)

{

    const gchar * name;

    name = g_get_user_name ();

    if (name == NULL)

        name = g_get_real_name ();

    if (name == NULL)

    {

        Mpushstrbloc (m, "unknown");

        return 0;

    }

    Mpushstrbloc (m, (char *) name);

    return 0;

}

/**

 * \brief _gBaseHostName : Returns the host name

 *

 * fun [] S

 *

 * \param : nothing

 * \return S : this name

 */

int SCOL_gBaseHostName (mmachine m)

{

    const gchar * name;

    name = g_get_host_name ();

    if (name == NULL)

    {

        Mpushstrbloc (m, "unknown");

        return 0;

    }

    Mpushstrbloc (m, (char *) name);

    return 0;

}

/**

 * \brief _gBaseDirCur : Returns the current directory (by default on MS Windows "C:\Program Files\Scol Voyager")

 *

 * fun [] S

 *

 * \param : nothing

 * \return S : this directory or "unknown" if undefined

 */

int SCOL_gBaseDirCur (mmachine m)

{

    const gchar * name;

    name = g_get_current_dir ();

    if (name == NULL)

    {

        Mpushstrbloc (m, "unknown");

        return 0;

    }

    Mpushstrbloc (m, (char *) name);

    return 0;

}

/**

 * \brief _gBasePathAbsolute : Returns 1 if the given file_name is an absolute file name.

 *

 * fun [S] I

 *

 * \param S : any path

 * \return I : 1 if TRUE,otherwise 0

 */

 int SCOL_gBasePathAbsolute (mmachine m)

 {

    int mpath;

    gboolean value;

    mpath = MMpull (m);

    if (mpath == NIL)

    {

        MMpush (m, NIL);

        return 0;

    }

    value = g_path_is_absolute (MMstartstr (m, MTOP (mpath)));

    MMpush (m, ITOM (value));

    return 0;

 }

/**

 * \brief _gBasePathBase : Returns the last component of the filename

 *

 * fun [S] S

 *

 * \param S : any path

 * \return S : this last component

 */

int SCOL_gBasePathBase (mmachine m)

{

    int mpath;

    gchar *base;

    mpath = MMpull (m);

    if (mpath == NIL)

    {

        MMpush (m, NIL);

        return 0;

    }

    base = g_path_get_basename (MMstartstr (m, MTOP (mpath)));

    Mpushstrbloc (m, base);

    g_free (base);

    return 0;

}

/**

 * \brief _gBasePathDir : Returns the directory components of a file name.

 *

 * fun [S] S

 *

 * \param S : any path

 * \return S : this directory

 */

int SCOL_gBasePathDir (mmachine m)

{

    int mpath;

    gchar *dir;

    mpath = MMpull (m);

    if (mpath == NIL)

    {

        MMpush (m, NIL);

        return 0;

    }

    dir = g_path_get_dirname (MMstartstr (m, MTOP (mpath)));

    Mpushstrbloc (m, dir);

    g_free (dir);

    return 0;

}

/**

 * \brief _gBasePathBuild : Creates a filename from a list of elements using the correct separator for filenames.

 *

 * fun [[S r1] I] S

 *

 * \param [S r1] : a list of elements (typically, a list of directory : a :: b :: c :: file.ext)

 * \param I : 1 : OS separator (e.g. "\" on MS Windows, "/" on Linux), otherwise Scol separator ("/")

 * \return S : the filename

 */

int SCOL_gBasePathBuild (mmachine m)

{

    int mlist, mflag;

    int size = 0, i = 0;

    gchar **list;

    gchar *fn;

    mflag = MTOI (MMpull (m));

    mlist = MMget (m, 0);

    if (mlist == NIL)

    {

        MMpush (m, NIL);

        return 0;

    }

    mlist = MTOP (mlist);

    while (mlist != NIL)

    {

        size++;

        mlist = MMfetch (m, mlist, 1)>>1;

    }

    list = g_new0 (gchar*, size + 2);

    mlist = MTOP (MMpull (m));

    for (; i < size; i++)

    {

        list[i] = MMstartstr (m, MTOP (MMfetch (m, mlist, 0)));

        mlist = MTOP (MMfetch (m, mlist, 1));

    }

    if (mflag == 1)

        fn = g_build_filenamev (list);

    else

        fn = g_build_pathv ("/", list);

    Mpushstrbloc (m, fn);

    g_free (list);

    g_free (fn);

    return 0;

}

/**

 * \brief _gBaseStringUTF8 : Converts a string in the current locale into a UTF-8 string or reverse.

 *

 * fun [S I] S

 *

 * \param S : any string

 * \param I : 1 from locale to UTF8, 0 from UTF-8 to current locale

 * \return : the new string

 */

int SCOL_gBaseStringUTF8 (mmachine m)

{

    int mstring, mflag;

    gchar *string;

    mflag = MMpull (m);

    mstring = MMpull (m);

    if (mstring == NIL)

    {

        MMpush (m, NIL);

        return 0;

    }

    if (mflag)

        string = SCOLUTF8 (MMstartstr (m, MTOP (mstring)), -1);

    else

        string = UTF8SCOL (MMstartstr (m, MTOP (mstring)), -1);

    Mpushstrbloc (m, string);

    g_free (string);

    return 0;

}

/**

 * \brief _gbaseChecksumS : Computes the checksum of a string.

 *

 * fun [S I] S

 *

 * \param S : any string

 * \param I : the hashing algorithm to use : 0 -> MD5 (default), 1 -> SHA-1, 2 -> SHA-256

 * \return S : the checksum as an hexadecimal string.

 */

int SCOL_gbaseChecksumS (mmachine m)

{

    int mstring, mtype;

    GChecksumType type = G_CHECKSUM_MD5;

    gchar *string;

    mtype = MTOI (MMpull (m));

    mstring = MMpull (m);

    if (mstring == NIL)

    {

        MMpush (m, NIL);

        return 0;

    }

    mstring = MTOP (mstring);

    if (mtype == 1)

        type = G_CHECKSUM_SHA1;

    else if (mtype == 2)

        type = G_CHECKSUM_SHA256;

    string = g_compute_checksum_for_string (type, MMstartstr (m, mstring), -1);

    Mpushstrbloc (m, string);

    g_free (string);

    return 0;

}

/**

 * \brief _gbaseChecksumP : Computes the checksum of a file.

 *

 * fun [P I] S

 *

 * \param S : any file (read referenced only)

 * \param I : the hashing algorithm to use : 0 -> MD5 (default), 1 -> SHA-1, 2 -> SHA-256

 * \return S : the checksum as an hexadecimal string.

 */

int SCOL_gbaseChecksumP (mmachine m)

{

    /* #define SCSP_MAX_SIZE G_MAXUINT-1 */ /* i'm stupid ! */

    #define SCSP_MAX_SIZE 1024*32   /* 32 ko / each loop */

    int mfile, mtype;

    guchar data[SCSP_MAX_SIZE];

    gsize size = 0;

    GChecksumType type = G_CHECKSUM_MD5;

    GChecksum *cs;

    const gchar *string;

    FILE *file;

    mtype = MTOI (MMpull (m));

    mfile = MMpull (m);

    if (mfile == NIL)

    {

        MMpush (m, NIL);

        return 0;

    }

    mfile = MTOP (mfile);

    file = fopen (MMstartstr (m, mfile), "rb");

    if (file == NULL)

    {

        MMpush (m, NIL);

        return 0;

    }

    if (mtype == 1)

        type = G_CHECKSUM_SHA1;

    else if (mtype == 2)

        type = G_CHECKSUM_SHA256;

    cs = g_checksum_new (type);

    do

    {

        size = fread((void *) data, sizeof (guchar), SCSP_MAX_SIZE, file);

        g_checksum_update (cs, data, size);

    }

    while (size == SCSP_MAX_SIZE);

    fclose (file);

    string = g_checksum_get_string (cs);

    Mpushstrbloc (m, (char *) string);

    g_checksum_free (cs);

    return 0;

}

/**

 * \brief _gbaseSleep : Pauses the current thread for the given number of milliseconds.

 *

 * fun [I] I

 *

 * \param I : the number of milliseconds

 * \return I : 0 if success, nil if error

 */

int SCOL_gbaseSleep (mmachine m)

{

    int msleep;

    msleep = MTOI (MMpull (m));

    if (msleep <= 0)

    {

        MMpush (m, NIL);

        return 0;

    }

    g_usleep (1000*msleep);

    MMpush (m, ITOM (0));

    return 0;

}

/**

 * \brief _gbaseFileStat : it should not be used, at this time

 *

 * fun [P] [I I I I]

 *

 * \param P : a filename (read reference only)

 * \return [I I I I] : size, last access, last modification, last state changed

 */

int SCOL_gbaseFileStat (mmachine m)

{

    int mfile;

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

    #endif

    mfile = MMpull(m);

    if (mfile == NIL)

    {

        MMpush (m, NIL);

        return 0;

    }

    mfile = MTOP (mfile);

    result = g_stat (MMstartstr (m, mfile), s);

    if (result != 0)

    {

        MMpush (m, NIL);

        return 0;

    }

    MMpush (m, ITOM (s->st_size));

    MMpush (m, ITOM (s->st_atime));

    MMpush (m, ITOM (s->st_mtime));

    MMpush (m, ITOM (s->st_ctime));

    MMpush (m, ITOM (4));

    MBdeftab (m);

    return 0;

}

/**

 * \brief _gbaseIsIp : Tests if a string is a form of an IPv4 or IPv6 address (like "123.210.012.231").

 * fun [S] I

 * \param S : any string

 * \return I : 1 if TRUE (the string is an IP address), 0 if FALSE

 */

int SCOL_gbaseIsIp (mmachine m)

{

    int ms;

    ms = MMpull (m);

    if (ms == NIL)

    {

        MMpush (m, NIL);

        return 0;

    }

    MMpush (m, ITOM (g_hostname_is_ip_address (MMstartstr (m, MTOP (ms)))));

    return 0;

}

    "_gbaseUserName",

    "_gBaseHostName",

    "_gBaseDirCur",

    "_gBasePathAbsolute",

    "_gBasePathBase",

    "_gBasePathDir",

    "_gBasePathBuild",

    "_gBaseStringUTF8",

    "_gbaseChecksumS",

    "_gbaseChecksumP",

    "_gbaseSleep",

    "_gbaseFileStat",

    SCOL_gbaseUserName,

    SCOL_gBaseHostName,

    SCOL_gBaseDirCur,

    SCOL_gBasePathAbsolute,

    SCOL_gBasePathBase,

    SCOL_gBasePathDir,

    SCOL_gBasePathBuild,

    SCOL_gBaseStringUTF8,

    SCOL_gbaseChecksumS,

    SCOL_gbaseChecksumP,

    SCOL_gbaseSleep,

    SCOL_gbaseFileStat,

    0,      /* SCOL_gbaseUserName */

    0,      /* SCOL_gBaseHostName */

    0,      /* SCOL_gBaseDirCur */

    1,      /* SCOL_gBasePathAbsolute */

    1,      /* SCOL_gBasePathBase */

    1,      /* SCOL_gBasePathDir */

    2,      /* SCOL_gBasePathBuild */

    2,       /* SCOL_gBaseStringUTF8 */

    2,       /* SCOL_gbaseChecksumS */

    2,       /* SCOL_gbaseChecksumP */

    1,       /* SCOL_gbaseSleep */

    1,       /* SCOL_gbaseFileStat */

    "fun [] S",                     /* SCOL_gbaseUserName */

    "fun [] S",                     /* SCOL_gBaseHostName */

    "fun [] S",                     /* SCOL_gBaseDirCur */

    "fun [S] I",                    /* SCOL_gBasePathAbsolute */

    "fun [S] S",                    /* SCOL_gBasePathBase */

    "fun [S] S",                    /* SCOL_gBasePathDir */

    "fun [[S r1] I] S",             /* SCOL_gBasePathBuild */

    "fun [S I] S",                  /* SCOL_gBaseStringUTF8 */

    "fun [S I] S",                  /* SCOL_gbaseChecksumS */

    "fun [P I] S",                  /* SCOL_gbaseChecksumS */

    "fun [I] I",                    /* SCOL_gbaseSleep */

    "fun [P] [I I I I]",            /* SCOL_gbaseFileStat */

}

/*

 * Load and free the regular expression library

 * Plateforms supported : MS Windows and GNU / Linux

 */

int GBaseRelease ()

{

    MMechostr (0, "\nGBASE library released !\n");

    return 0;

}

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

__declspec (dllexport) int SCOLloadGBASE (mmachine m, cbmachine w)

{

    int k = 0;

    ww = w;

    mm = m;

    MMechostr (MSKDEBUG, "\nGBASE library loading .... !\n");

    SCOLinitplugin (w);

    if ((k = SCOLinitGbaseClass (m))) return k;

    MMechostr(MSKDEBUG, "\nGBASE library loaded !\n");

    return k;

}

__declspec (dllexport) int SCOLfreeGBASE ()

{

    GBaseRelease ();

    return 0;

}

/* Version GNU / Linux */

#elif ((defined linux) || (defined __linux))

int SCOLloadGBASE (mmachine m)

{

    int k = 0;

    mm = m;

    MMechostr (MSKDEBUG, "\nGBASE library loading !\n");

    if ((k = SCOLinitGbaseClass (m))) return k;

    MMechostr (MSKDEBUG, "\nGBASE library loaded !\n");

    return k;

}

int SCOLfreeGBASE ()

{

    GBaseRelease ();

    return 0;

}

#else

#error no platform supported

#endif

*/

#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);

}

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

 */

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)

    {

        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;

}

 */

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++)

        {