Scol » Lib2D GTK » Utils_g

/*

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/

*/

#ifdef __cplusplus

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

#endif

#include "../include/scol_glib_pregex.h"

/* http://library.gnome.org/devel/glib/unstable/glib-Perl-compatible-regular-expressions.html */

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

cbmachine ww;

#endif

mmachine  mm;

/*

    Easy interface

    - SCOL_pcreEasyMatch

    - SCOL_pcreEasySplit

    - SCOL_pcreEasyReplace

*/

/**

 * \brief Scans for a match in string for pattern

 * \param : S : pattern : the regular expression

 * \param : S : string : the string to scan for matches

 * \return : I : 1 if matched, else 0 (or nil if string or pattern is nil)

 *

 * The compile options for the regular expression are at 0

 * The match options ara at 0 too

 */

int SCOL_pcreEasyMatch (mmachine m)

{

    int mpattern, mstring;

    gchar *pattern, *string;

    MMechostr (MSKDEBUG, "SCOL_pcreEasyMatch : entering\n");

    mstring = MTOP (MMpull (m));

    mpattern = MTOP (MMpull (m));

    if((mstring == NIL) || (mpattern == NIL))

    {

        MMechostr (0, "SCOL_pcreEasyMatch error : an argument is nil");

        MMpush (m, NIL);

        return 0;

    }

    pattern = SCOLUTF8 (MMstartstr (m, mpattern), MMsizestr (m, mpattern));

    string = SCOLUTF8 (MMstartstr (m, mstring), MMsizestr (m, mstring));

    MMpush (m, ITOM (g_regex_match_simple (pattern, string, 0, 0)));

    g_free (pattern);

    g_free (string);

    return 0;

}

/**

 * \brief Breaks the string on the pattern, and returns an list of the tokens.

 * \param : S : pattern : the regular expression

 * \param : S : string : the string to scan for matches

 * \return : [S r1] : a list of substrings or nil

 *

 * The compile options for the regular expression are at 0

 * The match options ara at 0 too

 */

int SCOL_pcreEasySplit (mmachine m)

{

    int mpattern, mstring;

    int i = 0;

    gchar *pattern, *string;

    gchar **result;

    MMechostr (MSKDEBUG, "SCOL_pcreEsaySplit : entering\n");

    mstring = MTOP (MMpull (m));

    mpattern = MTOP (MMpull (m));

    if (mstring == NIL)

    {

        MMechostr (0, "SCOL_pcreEsaySplit error : an argument is nil");

        MMpush (m, NIL);

        return 0;

    }

    if (mpattern == NIL)

    {

        Mpushstrbloc (m, MMstartstr (m, mstring));

        MMpush (m, NIL);

        MMpush (m, ITOM (2));

        MBdeftab (m);

        return 0;

    }

    pattern = SCOLUTF8 (MMstartstr (m, mpattern), MMsizestr (m, mpattern));

    string = SCOLUTF8 (MMstartstr (m, mstring), MMsizestr (m, mstring));

    result = g_regex_split_simple (pattern, string, 0, 0);

    while (result[i] != NULL)

    {

        Mpushstrbloc (m, UTF8SCOL (result[i], strlen (result[i])));

        i++;

    }

    g_strfreev (result);

    g_free (pattern);

    g_free (string);

    MMpush (m, NIL);

    for (; i > 0; i--)

    {

        MMpush (m, ITOM (2));

        MBdeftab (m);

    }

    return 0;

}

/**

 * \brief Replaces all occurrences of the pattern in string with a replacement text

 * \param S : pattern

 * \param S : string

 * \param S : replacement text

 * \return S : new string containing the replacements

 */

int SCOL_pcreEasyReplace (mmachine m)

{

    int mpattern, mstring, mreplace;

    GRegex *regex;

    gchar *result;

    gchar *pattern, *string, *replace;

    MMechostr (MSKDEBUG, "SCOL_pcreEasyReplace : entering\n");

    mreplace = MTOP (MMpull (m));

    mstring = MTOP (MMpull (m));

    mpattern = MTOP (MMpull (m));

    if(mstring == NIL)

    {

        MMechostr (0, "SCOL_pcreEasyReplace error : an argument is nil");

        MMpush (m, NIL);

        return 0;

    }

    if ((mreplace == NIL) || (mpattern == NIL))

    {

        Mpushstrbloc (m, MMstartstr (m, mstring));

        return 0;

    }

    pattern = SCOLUTF8 (MMstartstr (m, mpattern), MMsizestr (m, mpattern));

    string = SCOLUTF8 (MMstartstr (m, mstring), MMsizestr (m, mstring));

    replace = SCOLUTF8 (MMstartstr (m, mreplace), MMsizestr (m, mreplace));

    regex = scol_pcre_regex_new (pattern, 0, 0);

    result = g_regex_replace (regex, string, strlen (string), 0, replace, 0, NULL);

    result = UTF8SCOL (result, strlen (result));

    Mpushstrbloc (m, result);

    g_free (result);

    g_regex_unref (regex);

    g_free (pattern);

    g_free (string);

    g_free (replace);

    return 0;

}

/*

    Normal interface

    - SCOL_pcreNormalMatch

    - SCOL_pcreNormalSplit

*/

int SCOL_pcreNormalMatch (mmachine m)

{

    int mpattern, mstring, mcompile, mstart, mmatch, malgo;

    gchar * pattern, *string;

    MMechostr (MSKDEBUG, "SCOL_pcreNormalMatch : entering\n");

    malgo = MTOI (MMpull (m));

    mmatch = MMpull (m);

    mstart = MTOI (MMpull (m));

    mcompile = MMpull (m);

    mstring = MTOP (MMpull (m));

    mpattern = MTOP (MMpull (m));

    if ((mstring == NIL) || (mpattern == NIL))

    {

        MMechostr (0, "SCOL_pcreNormalMatch error : string or pattern is nil\n");

        MMpush (m, NIL);

        return 0;

    }

    if (mstart< 0)

        mstart = 0;

    if (malgo != PCRE_MATCH_DFA)

        malgo = PCRE_MATCH_STANDARD;

    if (mcompile == NIL)

        mcompile = 0;

    if (mmatch == NIL)

        mmatch = 0;

    pattern = SCOLUTF8 (MMstartstr (m, mpattern), MMsizestr (m, mpattern));

    string = SCOLUTF8 (MMstartstr (m, mstring), MMsizestr (m, mstring));

    if (malgo == PCRE_MATCH_STANDARD)

        scol_pcre_match_standard (m, pattern, string, mcompile, mmatch, mstart);

    else

        scol_pcre_match_DFA (m, pattern, string, mcompile, mmatch, mstart);

    g_free (pattern);

    g_free (string);

    return 0;

}

int SCOL_pcreNormalSplit (mmachine m)

{

    int mpattern, mstring, mcompile, mstart, mmax, mmatch;

    int i = 0;

    gchar *pattern, *string;

    GRegex *regex;

    GError *error = NULL;

    gchar **result;

    MMechostr (MSKDEBUG, "SCOL_pcreNormalSplit : entering\n");

    mmax = MTOI (MMpull (m));

    mmatch = MMpull (m);

    mstart = MTOI (MMpull (m));

    mcompile = MMpull (m);

    mstring = MTOP (MMpull (m));

    mpattern = MTOP (MMpull (m));

    if ((mstring == NIL) || (mpattern == NIL))

    {

        MMechostr (0, "SCOL_pcreNormalSplit error : string or pattern is nil\n");

        MMpush (m, NIL);

        return 0;

    }

    if (mstart < 0)

        mstart = 0;

    if (mcompile == NIL)

        mcompile = 0;

    if (mmatch == NIL)

        mmatch = 0;

    pattern = SCOLUTF8 (MMstartstr (m, mpattern), MMsizestr (m, mpattern));

    string = SCOLUTF8 (MMstartstr (m, mstring), MMsizestr (m, mstring));

    regex = scol_pcre_regex_new (pattern, mcompile, mmatch);

    result = g_regex_split_full (regex, string, strlen (string), mstart, mmatch, mmax, &error);

    g_regex_unref (regex);

    if (error != NULL)

    {

        MMechostr (0, "SCOL_pcreNormalSplit error : %s\n", error->message);

        MMpush (m, NIL);

        g_error_free (error);

    }

    while (result[i] != NULL)

    {

        Mpushstrbloc (m, UTF8SCOL (result[i], strlen (result[i])));

        i++;

    }

    g_strfreev (result);

    g_free (pattern);

    g_free (string);

    MMpush (m, NIL);

    for (; i > 0; i--)

    {

        MMpush (m, ITOM (2));

        MBdeftab (m);

    }

    return 0;

}

int SCOL_pcreNormalReplace (mmachine m)

{

    int mpattern, mstring, mreplace, mcompile, mstart, mmatch;

    gchar *pattern, *string, *replace, *result;

    GRegex *regex;

    GError *error = NULL;

    MMechostr (MSKDEBUG, "SCOL_pcreNormalReplace : entering\n");

    mmatch = MMpull (m);

    mstart = MTOI (MMpull (m));

    mcompile = MMpull (m);

    mreplace = MTOP (MMpull (m));

    mstring = MTOP (MMpull (m));

    mpattern = MTOP (MMpull (m));

    if(mstring == NIL)

    {

        MMechostr (0, "SCOL_pcreNormalReplace error : string is nil");

        MMpush (m, NIL);

        return 0;

    }

    if ((mreplace == NIL) || (mpattern == NIL))

    {

        Mpushstrbloc (m, MMstartstr (m, mstring));

        return 0;

    }

    if (mstart < 0)

        mstart = 0;

    if (mcompile == NIL)

        mcompile = 0;

    if (mmatch == NIL)

        mmatch = 0;

    pattern = SCOLUTF8 (MMstartstr (m, mpattern), MMsizestr (m, mpattern));

    string = SCOLUTF8 (MMstartstr (m, mstring), MMsizestr (m, mstring));

    replace = SCOLUTF8 (MMstartstr (m, mreplace), MMsizestr (m, mreplace));

    regex = scol_pcre_regex_new (pattern, mcompile, mmatch);

    result = g_regex_replace (regex, string, strlen (string), mstart, replace, mmatch, &error);

    g_regex_unref (regex);

    if (error != NULL)

    {

        MMechostr (0, "SCOL_pcreNormalReplace error : %s\n", error->message);

        MMpush (m, NIL);

        g_error_free (error);

    }

    Mpushstrbloc (m, UTF8SCOL (result, strlen (result)));

    g_free (result);

    g_free (string);

    g_free (pattern);

    return 0;

}

/*

    Internals functions

    - scol_pcre_regex_new

        GRegex * scol_pcre_regex_new (const gchar *, GRegexCompileFlags, GRegexMatchFlags);

        Create a new regular expression

    - scol_pcre_match_standard

        void scol_pcre_match_full (mmachine, const gchar *, const gchar *, GRegexCompileFlags  GRegexMatchFlags, gint)

    - scol_pcre_match_DFA

        void scol_pcre_match_DFA (mmachine m, const gchar *pattern, const gchar *string, GRegexCompileFlags compile, GRegexMatchFlags match, gint start)

*/

GRegex * scol_pcre_regex_new (const gchar * pattern, GRegexCompileFlags compile, GRegexMatchFlags match)

{

    return g_regex_new (pattern, compile, match, NULL);

}

void scol_pcre_match_standard (mmachine m, const gchar *pattern, const gchar *string, GRegexCompileFlags compile, GRegexMatchFlags match, gint start)

{

    GRegex *regex;

    GMatchInfo *match_info;

    GError *error = NULL;

    gchar *word;

    gboolean r;

    int i, n = 0;

    gint pos1 = -1, pos2 = -1;

    regex = scol_pcre_regex_new (pattern, compile, match);

    r = g_regex_match_full (regex, string, strlen (string), start, match, &match_info, &error);

    while (g_match_info_matches (match_info))

    {

        word = g_match_info_fetch (match_info, 0);

        g_match_info_fetch_pos (match_info, 0, &pos1, &pos2);

        Mpushstrbloc (m, word);

        MMpush (m, ITOM (pos1));

        MMpush (m, ITOM (pos2));

        MMpush (m, ITOM (3));

        MBdeftab (m);

        g_free (word);

        pos1 = -1; pos2 = -1;

        g_match_info_next (match_info, &error);

        n++;

    }

    g_match_info_free (match_info);

    g_regex_unref (regex);

    if (error != NULL)

    {

        MMechostr (0, "scol_pcre_match_standard error : %s\n", error->message);

        g_error_free (error);

    }

    MMpush (m, NIL);

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

    {

        MMpush (m, ITOM (2));

        MBdeftab (m);

    }

    return;

}

void scol_pcre_match_DFA (mmachine m, const gchar *pattern, const gchar *string, GRegexCompileFlags compile, GRegexMatchFlags match, gint start)

{

    GRegex *regex;

    GMatchInfo *match_info;

    GError *error = NULL;

    gchar *word;

    gboolean r;

    int i, n = 0;

    gint pos1 = -1, pos2 = -1;

    regex = scol_pcre_regex_new (pattern, compile, match);

    r = g_regex_match_all_full (regex, string, strlen (string), start, match, &match_info, &error);

    while (g_match_info_matches (match_info))

    {

        word = g_match_info_fetch (match_info, 0);

        g_match_info_fetch_pos (match_info, 0, &pos1, &pos2);

        Mpushstrbloc (m, word);

        MMpush (m, ITOM (pos1));

        MMpush (m, ITOM (pos2));

        MMpush (m, ITOM (3));

        MBdeftab (m);

        g_free (word);

        pos1 = -1; pos2 = -1;

        g_match_info_next (match_info, &error);

        n++;

    }

    g_match_info_free (match_info);

    g_regex_unref (regex);

    if (error != NULL)

    {

        MMechostr (0, "scol_pcre_match_DFA error : %s\n", error->message);

        g_error_free (error);

    }

    MMpush (m, NIL);

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

    {

        MMpush (m, ITOM (2));

        MBdeftab (m);

    }

    return;

}

/* API definitions : */

char* glib_pcre_name[GLIB_PCRE_PKG_NB]=

{

    "PCRE_MATCH_STANDARD", "PCRE_MATCH_DFA",

    "PCRE_MATCH_ANCHORED", "PCRE_MATCH_NOTBOL", "PCRE_MATCH_NOTEOL",

    "PCRE_MATCH_NOTEMPTY", "PCRE_MATCH_PARTIAL", "PCRE_MATCH_NEWLINE_CR",

    "PCRE_MATCH_NEWLINE_LF", "PCRE_MATCH_NEWLINE_CRLF", "PCRE_MATCH_NEWLINE_ANY",

    "PCRE_REGEX_CASELESS", "PCRE_REGEX_MULTILINE", "PCRE_REGEX_DOTALL",

    "PCRE_REGEX_EXTENDED", "PCRE_REGEX_ANCHORED", "PCRE_REGEX_DOLLAR_ENDONLY",

    "PCRE_REGEX_UNGREEDY", "PCRE_REGEX_RAW", "PCRE_REGEX_NO_AUTO_CAPTURE",

    "PCRE_REGEX_OPTIMIZE", "PCRE_REGEX_DUPNAMES", "PCRE_REGEX_NEWLINE_CR",

    "PCRE_REGEX_NEWLINE_LF", "PCRE_REGEX_NEWLINE_CRLF",

    "_pcreEasyMatch",

    "_pcreEasySplit",

    "_pcreEasyReplace",

    "_pcreNormalMatch",

    "_pcreNormalSplit",

    "_pcreNormalReplace"

};

int (*glib_pcre_fun[GLIB_PCRE_PKG_NB])(mmachine m)=

{

    (bullshit) (1*2), (bullshit) (2*2),

    (bullshit) (1<<4), (bullshit) (1<<7), (bullshit) (1<<8),

    (bullshit) (1<<10), (bullshit) (1<<15), (bullshit) (1<<20),

    (bullshit) (1<<21), (bullshit) (1<<20|1<<21), (bullshit) (1<<22),

    (bullshit) (1<<0), (bullshit) (1<<1), (bullshit) (1<<2),

    (bullshit) (1<<3), (bullshit) (1<<4), (bullshit) (1<<5),

    (bullshit) (1<<9), (bullshit) (1<<11), (bullshit) (1<<12),

    (bullshit) (1<<13), (bullshit) (1<<19), (bullshit) (1<<20),

    (bullshit) (1<<21), (bullshit) (1<<20|1<<21),

    SCOL_pcreEasyMatch,

    SCOL_pcreEasySplit,

    SCOL_pcreEasyReplace,

    SCOL_pcreNormalMatch,

    SCOL_pcreNormalSplit,

    SCOL_pcreNormalReplace

};

int glib_pcre_narg[GLIB_PCRE_PKG_NB]=

{

    TYPVAR, TYPVAR,

    TYPVAR, TYPVAR, TYPVAR,

    TYPVAR, TYPVAR, TYPVAR,

    TYPVAR, TYPVAR, TYPVAR,

    TYPVAR, TYPVAR, TYPVAR,

    TYPVAR, TYPVAR, TYPVAR,

    TYPVAR, TYPVAR, TYPVAR,

    TYPVAR, TYPVAR, TYPVAR,

    TYPVAR, TYPVAR,

    2,

    2,

    3,

    6,

    6,

    6

};

char* glib_pcre_type[GLIB_PCRE_PKG_NB]=

{

    "I", "I",

    "I", "I", "I",

    "I", "I", "I",

    "I", "I", "I",

    "I", "I", "I",

    "I", "I", "I",

    "I", "I", "I",

    "I", "I", "I",

    "I", "I",

    "fun [S S] I",

    "fun [S S] [S r1]",

    "fun [S S S] S",

    "fun [S S I I I I] [[S I I] r1]",

    "fun [S S I I I I] [S r1]",

    "fun [S S S I I I] S"

};

/**

 * \brief Load the Scol api

 */

int SCOLinitPcreClass (mmachine m)

{

    int k;

    MMechostr (0, "SCOLinitPcreClass : entering\n");

    k = PKhardpak (m, "PCREengine", GLIB_PCRE_PKG_NB, glib_pcre_name, glib_pcre_fun, glib_pcre_narg, glib_pcre_type);

    return k;

}

/**

 * \brief Load and free the regular expression library

 * Plateforms supported : MS Windows and GNU / Linux

 */

int PcreRelease ()

{

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

    return 0;

}

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

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

{

    int k = 0;

    ww = w;

    mm = m;

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

    SCOLinitplugin (w);

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

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

    return k;

}

__declspec (dllexport) int SCOLfreePCRE ()

{

    PcreRelease ();

    return 0;

}

/* Version GNU / Linux */

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

int SCOLloadPCRE (mmachine m)

{

    int k = 0;

    mm = m;

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

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

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

    return k;

}

int SCOLfreePCRE ()

{

    MMechostr(MSKDEBUG, "\nPCRE library release !\n");

    PcreRelease ();

    return 0;

}

#else

#error no platform supported

#endif