Puis-je utiliser regex_t pour plusieurs compilations

Question

Question de base, pas clair pour moi pour le regcomp man.

Si j'ai une instance statique de regex_t, puis-je réutiliser pour plusieurs compilation sans libérer chaque fois, quelque chose comme:

int match(char* pattern, char* name) { 
     static regex_t re; 
     regcomp(&re,pattern,REG_EXTENDED|REG_NOSUB); 
     ... 
    } 

Le code lui-même est un peu plus compliqué, et l'idée est d'utiliser variable statique pour enregistrer la compilation si le motif n'a pas été modifié entre les appels. La question est de savoir si je dois appeler regfree avant chaque nouvelle regcomp.

Merci.

Answer 1

Si vous voulez utiliser le résultat précédent de regcomp() qui a été compilé dans re qui est parfaitement bien - aussi longtemps que vous ne pas appel regfree() dans l'intervalle.

Mais quand vous voulez compiler une nouvelle regex en appelant regcomp() à nouveau, vous devrez appeler regfree() pour libérer correctement les ressources utilisées par l'appel regcomp() précédent. Donc, vous aurez probablement besoin d'une autre variable statique qui garde la trace si la variable re a été utilisée par un appel à regcomp() et doit être regfree() avant d'être réutilisée.

Quelque chose le long des lignes de:

int match(char* pattern, char* name) { 
    static regex_t re; 
    static int re_in_use = 0; 

    if (isNewRegex(pattern)) { // however you want to determine this... 
     if (re_in_use) { 
      regfree(&re); 
      re_in_use = 0; 
     } 
    } 

    re_in_use = regcomp(&re,pattern,REG_EXTENDED|REG_NOSUB); 

    ... 
} 

Answer 2

Désolé, je ne peux pas écrire une bonne explication, mais voici un exemple de code pour un cache un élément regcomp():

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <sys/types.h> 
#include <regex.h> 

static struct { 
    char *pattern; 
    regex_t re; 
} last_match = { .pattern = (char*)NULL }; 


int match(const char *pattern, const char *name){ 
    int ret; 

    if(last_match.pattern != (char*)NULL && strcmp(last_match.pattern, pattern) != 0){ 
    free(last_match.pattern); last_match.pattern = (char*)NULL; 
    regfree(&last_match.re); 
    } 

    if(last_match.pattern == (char*)NULL){ 
    last_match.pattern = (char*)malloc(strlen(pattern)+1); 
    strcpy(last_match.pattern, pattern); 
    ret = regcomp(&last_match.re, last_match.pattern, REG_EXTENDED|REG_NOSUB); 
    printf("regcomp: %i '%s'\n", ret, last_match.pattern); 
    } 

    ret = regexec(&last_match.re, name, 0, (regmatch_t*)NULL, 0); 
    printf("regexec: %i\n", ret); 

    return ret; 
} 

int main(void){ 
    match("[0-9]+", "qwer1234"); 
    match("[0-9]+", "asdf5678"); 

    match("[a-z]+", "qwer1234"); 
    match("[a-z]+", "asdf5678"); 
} 

Si vous Exécuter le code Vous verrez deux messages 'regcomp' et quatre 'regexec' en raison de la réutilisation de regex_t.