probleme d'expression reguliére

bonjour,
je voulais savoir si quelqu'un pouvait éventuellement m'apporter son soutien.
Voila deux jour que j'essai de faire une fonction(en c) qui va m'analyser le contenu d'une chaine de caractére pour y récupérer les url.


voici l'idée de base programmé n'importe comment.
do {
    const char *str_regex = "href=\"([^\"]*)\"";

    err = regcomp (&preg, str_regex, REG_EXTENDED);
    if (err != 0)
    {
        printf("Erreur err = %d\n", err);
    }else{

        size_t nmatch=5;
        regmatch_t *pmatch = NULL;

        nmatch = preg.re_nsub;
       

            end = 0;
            oldEnd = end;
            lengthOfPage = strlen(str_request);
            do
            {
free(pmatch);
pmatch = malloc (sizeof (*pmatch) * nmatch);


                match = regexec (&preg, &str_request[end], nmatch, pmatch, 0);

                if (match != 0)
                {
                    printf("Expression non trouvee\n");
                }else{
                   
                    start = pmatch[0].rm_so;
                    oldEnd = end;
                    end = pmatch[0].rm_eo;
                    size = (end-1) - (start+6);

                    site = malloc (sizeof (*site) * (size + 1));
                    end+=oldEnd;
                    if (!site){
                        printf("Manque de ram?\n");
                    }else{

                        strncpy (site, &str_request[oldEnd+start+6], size);

                        site[size] = '\0';

                        classUrl(site, urlUsed, domainUrl, domain, urlInDomain);

                        free (site);
                    }
                   
                }
} while (end<=lengthOfPage);
regfree (&preg);

    }
quelqu'un aurait il une idée pour récupérer tout les liens necessaires proprement?

merci d'avance

Salut,

Je pense que si tu veux utiliser les RegEX,
le mieux serait d'utiliser une librairie, http://regexlib.com/
Mais pour faire un serveur http de petite taille,
ce n'est pas forcement utilie (enfin je pense).

J'ai d'ailleur une source d'un serveur http,
je peusx la mettre en ligne (c'est du linux).

Cordialement,
Sébastien.

Salut,

J'ai le sentiment que le C n'est pas le langage idéal pour l'utilisation des regex, et de manière générale pour la manipulation des chaînes de caractères.
Bien que ta regex soit correcte, tu t'enlisses dans des problèmes d'allocation et de copie de chaînes de caractères, et ce, pour résoudre un problème qui devrait se résoudre en 2 lignes de code !!!
Voici, pour exemple, une solution en c++ utilisant la bibliothèque regex de boost.

#include <iostream>
#include <fstream>
#include <string>
#include <boost/regex.hpp>

using namespace std;
using namespace boost;

int main()
{
    ifstream ifs( "./test.html" );
    string line;
    getline( ifs , line , '\0' );

    regex reg( "href=\\\"([^\\\"]*)\\\"" );
    sregex_iterator it( line.begin() , line.end() , reg );
    sregex_iterator end;

    for ( ; it != end ; it++ ) cout << (*it)[1].str() << endl;
}

Quel est le contexte de développement de ton projet ? En fonction du cadre, il sera plus facile de te guider dans le choix technologique.

tout d'abord, merci beaucoup pour vos reponses.

SebLinck
ensuite j'utilise deja une librairie, enfin je crois, mes fonctions regexec et regcomp viennent de l'include de regex.h
et je veux bien ta source du serveur http a titre informatif.



Lucky92
je prend note de ta source en c++, et je songe a y passé mais vu que j'ai beaucoup avancé dans le reste du projet en c, ca sera pas pour tout de suite.
concernant mon projet, la fonction doit prendre une variable contenant un contenu html et pour chaque lien trouvé l'envoyé en parametre dans une fonction qui stocke ce dernier lien a un endroit donné.

Salut,

Est-ce que tu peux donner le début du programme, notamment la définition de preg, s'il te plaît ?

bien entendu , en plus j'ai trouvé une autre méthode vraiment artisanale.
donc voici ma méthode sans expressions reguliéres:

list* getUrl(char *site)
{

    int length,i,j,ok,k,lengthOfPS, lengthOfPE;
    list *urlHref;
    char* patStart = "href=\"";
    char* patEnd = "\"";
    char *tmpUrl;
    size_t size;
    urlHref = initList();
    length = strlen(site);
    lengthOfPS = strlen(patStart);
    lengthOfPE = strlen(patEnd);

    for (i=0;i<length;i++)
    {

        if (site[i] == patStart[0])
        {
            ok=1;
            for (j=0;j<lengthOfPS;j++)
            {
                if (site[i+j] != patStart[j])
                {
                    ok=0;
                    break;
                }
            }

            if (ok == 1)
            {

                for (k=(i+lengthOfPS);k<length;k++)
                {
                    if (site[k] == patEnd[0])
                    {
                        ok=1;
                        for (j=0;j<lengthOfPE;j++)
                        {
                            if (site[k+j] != patEnd[j])
                            {
                                ok=0;
                                break;
                            }
                        }
                        if (ok==1)
                        {
                            size = (k)-(i+lengthOfPS);
                            tmpUrl = (char*)malloc(sizeof(char)*(size+1));
                            strncpy (tmpUrl, &site[i+lengthOfPS], size);
                            tmpUrl[size]='\0';
                            addToList(urlHref, tmpUrl);
                            free(tmpUrl);
                            break;
                        }
                        i=i+lengthOfPS+size+lengthOfPE;
                    }
                }
            }
        }
   
    }
    return urlHref;
}

et pou le preg, j'utilisais:

regex_t preg;
    const char *str_regex = "href=\"([^\"]*)\"";

    err = regcomp (&preg, str_regex, REG_EXTENDED);
    if (err == 0)
    {

        size_t nmatch=5;
        regmatch_t *pmatch = NULL;

        nmatch = preg.re_nsub;
       

            end = 0;
            oldEnd = end;
            lengthOfPage = strlen(str_request);
pmatch = malloc (sizeof (*pmatch) * nmatch);
                match = regexec (&preg, &str_request, nmatch, pmatch, 0);
                if (match == 0)
//alors la chaine est incluse dans str_request

Salut,

J'ai simplifié en supprimant le tableau de "pmatch", je pense que tu peux t'en passer.

/*________________________________________________
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <regex.h>
/*________________________________________________
*/
size_t size_of_file( const char * file_name )
{
    FILE * fp = fopen( file_name , "r" );
    if ( !fp ) return 0 ;
    fseek( fp , 0 , SEEK_END );
    size_t sz = ftell( fp );
    fclose( fp );
    return sz ;
}
/*________________________________________________
*/
char * read_file( const char * file_name )
{
    FILE * fp = fopen( file_name , "r" ) ;
    if ( !fp ) return 0 ;
    size_t sz = size_of_file( file_name );
    char * dst = (char*)malloc(  sz + 1 ) ;
    fread( dst , sz , 0 , fp ) ;
    *( dst + sz ) = '\0' ;
    fclose( fp ) ;
    return dst ;
}
/*________________________________________________
*/
int main( int argc , char ** argv )
{
    if ( argc != 2 )
    {
        printf( "syntax : prog.exe file_name\n" );
    }
    else
    {
        //file name
        const char * file_name = argv[1] ;
        printf( "parse file %s \n" , file_name );

        //text to parse
        char * str_text = read_file( file_name );

        //compilation regex
        const char * str_regex = "href=\"([^\"]*)\"";
        regex_t preg ;
        regcomp( &preg , str_regex , REG_EXTENDED );

        //execution
        regmatch_t match;
        char * ptr = str_text;
        while( regexec( &preg , ptr , 1 , &match , 0 ) == 0 )
        {
            size_t sz = match.rm_eo - match.rm_so;
            char * str_result = (char*)malloc( sz + 1 );
            strncpy( str_result , ptr + match.rm_so , sz );
            *(str_result + sz ) = '\0' ;
            printf( "match result : %s\n" , str_result );
            ptr += match.rm_eo ;
            free( str_result );
        }
        regfree( &preg );
        free( str_text );
    }
}
/*________________________________________________
*/

je m'applique à tester dés que possible. j'ai commencé a lire , ca a lair plutot pas mal en effet.
merci bien.