Voila je veut utiliser regcomp et regexec pour faire des comparaisons. J'ai
donc voulu faire un petit test pour commencer mais cella ne fonctionne pas.
Lors de l'execution, il me dit que les deux chaines ne sont pas les mêmes,
quelqu'un à une idée ?
Voila je veut utiliser regcomp et regexec pour faire des comparaisons.
C'est un peu hors-sujet, ici. On parle généralement des fonctions POSIX sur fr.comp.os.unix .
J'ai donc voulu faire un petit test pour commencer mais cella ne fonctionne pas. Lors de l'execution, il me dit que les deux chaines ne sont pas les mêmes, quelqu'un à une idée ?
Euh, en fait faut lire la doc d'une fonction avant de l'utiliser :). regexec() renvoit zero quand la correspondance est etablie et REG_NOMATCH si elle échoue (cf man regex).
Voila je veut utiliser regcomp et regexec pour faire des comparaisons.
C'est un peu hors-sujet, ici. On parle généralement des fonctions POSIX
sur fr.comp.os.unix .
J'ai
donc voulu faire un petit test pour commencer mais cella ne fonctionne pas.
Lors de l'execution, il me dit que les deux chaines ne sont pas les mêmes,
quelqu'un à une idée ?
Euh, en fait faut lire la doc d'une fonction avant de l'utiliser :).
regexec() renvoit zero quand la correspondance est etablie et
REG_NOMATCH si elle échoue (cf man regex).
Voila je veut utiliser regcomp et regexec pour faire des comparaisons.
C'est un peu hors-sujet, ici. On parle généralement des fonctions POSIX sur fr.comp.os.unix .
J'ai donc voulu faire un petit test pour commencer mais cella ne fonctionne pas. Lors de l'execution, il me dit que les deux chaines ne sont pas les mêmes, quelqu'un à une idée ?
Euh, en fait faut lire la doc d'une fonction avant de l'utiliser :). regexec() renvoit zero quand la correspondance est etablie et REG_NOMATCH si elle échoue (cf man regex).
if (regexec(®exp, "192.168.0.22", 0, NULL, 0)) printf("Match...n"); else printf("NO Match...n");
Le test est inversé.
Anthony
Arno wrote:
Bonjour,
Salut,
Voila je veut utiliser regcomp et regexec pour faire des comparaisons. J'ai donc voulu faire un petit test pour commencer mais cella ne fonctionne pas. Lors de l'execution, il me dit que les deux chaines ne sont pas les mêmes, quelqu'un à une idée ?
Attention, cette question n'a pas sa place ici logiquement. Ces fonctions sont conformes à POSIX et non à C89 ou C99.
int main (int argc, char **argv) { regex_t regexp;
if (!regcomp(®exp, "192.168.0.22", REG_ICASE)) { if (regexec(®exp, "192.168.0.22", 0, NULL, 0))
REGCOMP(3) Linux Programmer's Manual REGCOMP(3)
NAME regcomp, regexec, regerror, regfree - POSIX regex func- tions
RETURN VALUE regcomp returns zero for a successful compilation or an error code for failure.
regexec returns zero for a successful match or REG_NOMATCH for failure.
Si la fonction retourne 0 tu dois tester if(!regexec(...)) un peut comme strcmp.
Anthony -- It's a bird.. It's a plane.. No, it's KernelMan, faster than a speeding bullet, to your rescue. Doing new kernel versions in under 5 seconds flat.. -- Linus, in the announcement for 1.3.27
Arno wrote:
Bonjour,
Salut,
Voila je veut utiliser regcomp et regexec pour faire des comparaisons.
J'ai donc voulu faire un petit test pour commencer mais cella ne
fonctionne pas. Lors de l'execution, il me dit que les deux chaines ne
sont pas les mêmes, quelqu'un à une idée ?
Attention, cette question n'a pas sa place ici logiquement. Ces fonctions
sont conformes à POSIX et non à C89 ou C99.
int main (int argc, char **argv)
{
regex_t regexp;
if (!regcomp(®exp, "192.168.0.22", REG_ICASE))
{
if (regexec(®exp, "192.168.0.22", 0, NULL, 0))
REGCOMP(3) Linux Programmer's Manual REGCOMP(3)
NAME
regcomp, regexec, regerror, regfree - POSIX regex func-
tions
RETURN VALUE
regcomp returns zero for a successful compilation or an
error code for failure.
regexec returns zero for a successful match or REG_NOMATCH
for failure.
Si la fonction retourne 0 tu dois tester if(!regexec(...)) un peut comme
strcmp.
Anthony
--
It's a bird.. It's a plane..
No, it's KernelMan, faster than a speeding bullet, to your rescue.
Doing new kernel versions in under 5 seconds flat..
-- Linus, in the announcement for 1.3.27
Voila je veut utiliser regcomp et regexec pour faire des comparaisons. J'ai donc voulu faire un petit test pour commencer mais cella ne fonctionne pas. Lors de l'execution, il me dit que les deux chaines ne sont pas les mêmes, quelqu'un à une idée ?
Attention, cette question n'a pas sa place ici logiquement. Ces fonctions sont conformes à POSIX et non à C89 ou C99.
int main (int argc, char **argv) { regex_t regexp;
if (!regcomp(®exp, "192.168.0.22", REG_ICASE)) { if (regexec(®exp, "192.168.0.22", 0, NULL, 0))
REGCOMP(3) Linux Programmer's Manual REGCOMP(3)
NAME regcomp, regexec, regerror, regfree - POSIX regex func- tions
RETURN VALUE regcomp returns zero for a successful compilation or an error code for failure.
regexec returns zero for a successful match or REG_NOMATCH for failure.
Si la fonction retourne 0 tu dois tester if(!regexec(...)) un peut comme strcmp.
Anthony -- It's a bird.. It's a plane.. No, it's KernelMan, faster than a speeding bullet, to your rescue. Doing new kernel versions in under 5 seconds flat.. -- Linus, in the announcement for 1.3.27
Arno
Excusez moi, je vient de perdre 30 minutes pour une connerie du genre et je remet çà. Vraiment désolé.
-- Arno - Pour le mail : http://cerbermail.com/?P5oJnDlxNt
Excusez moi, je vient de perdre 30 minutes pour une connerie du genre et je
remet çà. Vraiment désolé.
--
Arno - Pour le mail : http://cerbermail.com/?P5oJnDlxNt
Excusez moi, je vient de perdre 30 minutes pour une connerie du genre et je remet çà. Vraiment désolé.
-- Arno - Pour le mail : http://cerbermail.com/?P5oJnDlxNt
cedric
Anthony wrote:
Si la fonction retourne 0 tu dois tester if(!regexec(...)) un peut comme strcmp.
Sans vouloir débutter une guerre de religion, quoique le mois d'août semble peut propice, personnellement je préfère écrire if (0!=regexec(...)) dans les cas comme ca, et n'utiliser l'opérateur "not" que pour attraper les erreurs ou lorsque la signification s'y prette (if (!eof()) par exemple).
Pas vous ?
Anthony wrote:
Si la fonction retourne 0 tu dois tester if(!regexec(...)) un peut comme
strcmp.
Sans vouloir débutter une guerre de religion, quoique le mois d'août
semble peut propice, personnellement je préfère écrire if
(0!=regexec(...)) dans les cas comme ca, et n'utiliser l'opérateur "not"
que pour attraper les erreurs ou lorsque la signification s'y prette (if
(!eof()) par exemple).
Si la fonction retourne 0 tu dois tester if(!regexec(...)) un peut comme strcmp.
Sans vouloir débutter une guerre de religion, quoique le mois d'août semble peut propice, personnellement je préfère écrire if (0!=regexec(...)) dans les cas comme ca, et n'utiliser l'opérateur "not" que pour attraper les erreurs ou lorsque la signification s'y prette (if (!eof()) par exemple).
Pas vous ?
Anthony
cedric wrote:
Anthony wrote:
Si la fonction retourne 0 tu dois tester if(!regexec(...)) un peut comme strcmp.
Sans vouloir débutter une guerre de religion, quoique le mois d'août semble peut propice, personnellement je préfère écrire if (0!=regexec(...)) dans les cas comme ca, et n'utiliser l'opérateur "not" que pour attraper les erreurs ou lorsque la signification s'y prette (if (!eof()) par exemple).
Pas vous ?
A la lecture if (0 != regexec(...)) est beaucoup plus clair et plus intuitif et évite en effet les erreurs du PO. Après je dois dire que personnelement comme je suis habitué à cette notation, à la lire et à la comprendre, j'utilise souvent le "not" dans les projets dans lesquels j'ai écrit du code.
D'ailleurs personnelement je me dis toujours qu'il faut que j'utilise le 0 != regexec(...) ainsi que le 0 == regexec(...) à la place du regexec(...) == 0, comme le 0 == ... créé une erreur dans le cas où l'on oublie un '=' mais je me suis jamais habitué à l'écrire, tout simplement parce que ca ne coule pas de source par rapport à notre raisonnement lorsqu'on écrit, si on pense que la fonction ne doit pas renvoyer 0 on pense si regexec() != 0.
Enfin voil), le mois d'aout étant calme on pourrait lancer un troll sur le sujet mais bon... les habitudes sont très dures à corriger une fois qu'on les a prises.
Anthony -- It's a bird.. It's a plane.. No, it's KernelMan, faster than a speeding bullet, to your rescue. Doing new kernel versions in under 5 seconds flat.. -- Linus, in the announcement for 1.3.27
cedric wrote:
Anthony wrote:
Si la fonction retourne 0 tu dois tester if(!regexec(...)) un peut comme
strcmp.
Sans vouloir débutter une guerre de religion, quoique le mois d'août
semble peut propice, personnellement je préfère écrire if
(0!=regexec(...)) dans les cas comme ca, et n'utiliser l'opérateur "not"
que pour attraper les erreurs ou lorsque la signification s'y prette (if
(!eof()) par exemple).
Pas vous ?
A la lecture if (0 != regexec(...)) est beaucoup plus clair et plus intuitif
et évite en effet les erreurs du PO. Après je dois dire que personnelement
comme je suis habitué à cette notation, à la lire et à la comprendre,
j'utilise souvent le "not" dans les projets dans lesquels j'ai écrit du
code.
D'ailleurs personnelement je me dis toujours qu'il faut que j'utilise le
0 != regexec(...) ainsi que le 0 == regexec(...) à la place du regexec(...)
== 0, comme le 0 == ... créé une erreur dans le cas où l'on oublie un '='
mais je me suis jamais habitué à l'écrire, tout simplement parce que ca ne
coule pas de source par rapport à notre raisonnement lorsqu'on écrit, si on
pense que la fonction ne doit pas renvoyer 0 on pense si regexec() != 0.
Enfin voil), le mois d'aout étant calme on pourrait lancer un troll sur le
sujet mais bon... les habitudes sont très dures à corriger une fois qu'on
les a prises.
Anthony
--
It's a bird.. It's a plane..
No, it's KernelMan, faster than a speeding bullet, to your rescue.
Doing new kernel versions in under 5 seconds flat..
-- Linus, in the announcement for 1.3.27
Si la fonction retourne 0 tu dois tester if(!regexec(...)) un peut comme strcmp.
Sans vouloir débutter une guerre de religion, quoique le mois d'août semble peut propice, personnellement je préfère écrire if (0!=regexec(...)) dans les cas comme ca, et n'utiliser l'opérateur "not" que pour attraper les erreurs ou lorsque la signification s'y prette (if (!eof()) par exemple).
Pas vous ?
A la lecture if (0 != regexec(...)) est beaucoup plus clair et plus intuitif et évite en effet les erreurs du PO. Après je dois dire que personnelement comme je suis habitué à cette notation, à la lire et à la comprendre, j'utilise souvent le "not" dans les projets dans lesquels j'ai écrit du code.
D'ailleurs personnelement je me dis toujours qu'il faut que j'utilise le 0 != regexec(...) ainsi que le 0 == regexec(...) à la place du regexec(...) == 0, comme le 0 == ... créé une erreur dans le cas où l'on oublie un '=' mais je me suis jamais habitué à l'écrire, tout simplement parce que ca ne coule pas de source par rapport à notre raisonnement lorsqu'on écrit, si on pense que la fonction ne doit pas renvoyer 0 on pense si regexec() != 0.
Enfin voil), le mois d'aout étant calme on pourrait lancer un troll sur le sujet mais bon... les habitudes sont très dures à corriger une fois qu'on les a prises.
Anthony -- It's a bird.. It's a plane.. No, it's KernelMan, faster than a speeding bullet, to your rescue. Doing new kernel versions in under 5 seconds flat.. -- Linus, in the announcement for 1.3.27
Pierre Maurette
Anthony a écrit:
cedric wrote:
Anthony wrote:
Si la fonction retourne 0 tu dois tester if(!regexec(...)) un peut comme strcmp.
Sans vouloir débutter une guerre de religion, quoique le mois d'août semble peut propice, personnellement je préfère écrire if (0!=regexec(...)) dans les cas comme ca, et n'utiliser l'opérateur "not" que pour attraper les erreurs ou lorsque la signification s'y prette (if (!eof()) par exemple).
Pas vous ?
A la lecture if (0 != regexec(...)) est beaucoup plus clair et plus intuitif et évite en effet les erreurs du PO. Après je dois dire que personnelement comme je suis habitué à cette notation, à la lire et à la comprendre, j'utilise souvent le "not" dans les projets dans lesquels j'ai écrit du code.
D'ailleurs personnelement je me dis toujours qu'il faut que j'utilise le 0 != regexec(...) ainsi que le 0 == regexec(...) à la place du regexec(...) == 0, comme le 0 == ... créé une erreur dans le cas où l'on oublie un '=' mais je me suis jamais habitué à l'écrire, tout simplement parce que ca ne coule pas de source par rapport à notre raisonnement lorsqu'on écrit, si on pense que la fonction ne doit pas renvoyer 0 on pense si regexec() != 0. Simplement pour info, mes choix (encore faudrait-il que je les
respecte!):
* N'utiliser la forme réduite if(Expression) que dans le cas où Expression s'évalue en quelque chose de booléen au sens le plus strict du terme. En corrolaire, si le type bool existe, natif ou #included, jamais de if(Expression == false) et surtout pas de if(Expression = true). Pour les pointeurs, j'utilise NULL (que je réserve à cet usage).
* J'ai compris très tard l'utilité supposée de l'inversion if(constante == Expression) Je ne l'utilise pas. Elle gêne MA lecture et les erreurs entre = et = sont rares quand on programme régulièrement. Quoique je fasse régulièrement des erreurs de ce type en Pascal en revenant à Delphi. Enfin, tous mes compilateurs warnent if(a = Expression), mais pas if((a = Expression) != 0).
Je ne connais pas POSIX, mais nous sommes ici dans le cas classique d'un retour "quasi booléen", c'est à dire que !0 (je n'ose pas écrire true ou !false) a une valeur entière significative. C'est une forme que l'on retrouve par exemple dans des fonctions de l'API Windows. Il me semble que le plus propre serait de #define un REG_SUCCESS à 0 et de faire if(regexec(...) != REG_SUCCESS) ou if(regexec(...) == REG_SUCCESS).
Enfin voil), le mois d'aout étant calme on pourrait lancer un troll sur le sujet mais bon... les habitudes sont très dures à corriger une fois qu'on les a prises. Mais certains qui lisent ce forum sont en période de choix de ces
habitudes ;-) -- Pierre
Anthony <fleury_anthony@_hotmail_.com> a écrit:
cedric wrote:
Anthony wrote:
Si la fonction retourne 0 tu dois tester if(!regexec(...)) un peut comme
strcmp.
Sans vouloir débutter une guerre de religion, quoique le mois d'août
semble peut propice, personnellement je préfère écrire if
(0!=regexec(...)) dans les cas comme ca, et n'utiliser l'opérateur "not"
que pour attraper les erreurs ou lorsque la signification s'y prette (if
(!eof()) par exemple).
Pas vous ?
A la lecture if (0 != regexec(...)) est beaucoup plus clair et plus intuitif
et évite en effet les erreurs du PO. Après je dois dire que personnelement
comme je suis habitué à cette notation, à la lire et à la comprendre,
j'utilise souvent le "not" dans les projets dans lesquels j'ai écrit du
code.
D'ailleurs personnelement je me dis toujours qu'il faut que j'utilise le
0 != regexec(...) ainsi que le 0 == regexec(...) à la place du regexec(...)
== 0, comme le 0 == ... créé une erreur dans le cas où l'on oublie un '='
mais je me suis jamais habitué à l'écrire, tout simplement parce que ca ne
coule pas de source par rapport à notre raisonnement lorsqu'on écrit, si on
pense que la fonction ne doit pas renvoyer 0 on pense si regexec() != 0.
Simplement pour info, mes choix (encore faudrait-il que je les
respecte!):
* N'utiliser la forme réduite if(Expression) que dans le cas où
Expression s'évalue en quelque chose de booléen au sens le plus strict
du terme. En corrolaire, si le type bool existe, natif ou #included,
jamais de if(Expression == false) et surtout pas de if(Expression = true). Pour les pointeurs, j'utilise NULL (que je réserve à cet
usage).
* J'ai compris très tard l'utilité supposée de l'inversion
if(constante == Expression)
Je ne l'utilise pas. Elle gêne MA lecture et les erreurs entre = et = sont rares quand on programme régulièrement. Quoique je fasse
régulièrement des erreurs de ce type en Pascal en revenant à Delphi.
Enfin, tous mes compilateurs warnent if(a = Expression), mais pas
if((a = Expression) != 0).
Je ne connais pas POSIX, mais nous sommes ici dans le cas classique
d'un retour "quasi booléen", c'est à dire que !0 (je n'ose pas écrire
true ou !false) a une valeur entière significative. C'est une forme
que l'on retrouve par exemple dans des fonctions de l'API Windows. Il
me semble que le plus propre serait de #define un REG_SUCCESS à 0 et
de faire
if(regexec(...) != REG_SUCCESS)
ou
if(regexec(...) == REG_SUCCESS).
Enfin voil), le mois d'aout étant calme on pourrait lancer un troll sur le
sujet mais bon... les habitudes sont très dures à corriger une fois qu'on
les a prises.
Mais certains qui lisent ce forum sont en période de choix de ces
Si la fonction retourne 0 tu dois tester if(!regexec(...)) un peut comme strcmp.
Sans vouloir débutter une guerre de religion, quoique le mois d'août semble peut propice, personnellement je préfère écrire if (0!=regexec(...)) dans les cas comme ca, et n'utiliser l'opérateur "not" que pour attraper les erreurs ou lorsque la signification s'y prette (if (!eof()) par exemple).
Pas vous ?
A la lecture if (0 != regexec(...)) est beaucoup plus clair et plus intuitif et évite en effet les erreurs du PO. Après je dois dire que personnelement comme je suis habitué à cette notation, à la lire et à la comprendre, j'utilise souvent le "not" dans les projets dans lesquels j'ai écrit du code.
D'ailleurs personnelement je me dis toujours qu'il faut que j'utilise le 0 != regexec(...) ainsi que le 0 == regexec(...) à la place du regexec(...) == 0, comme le 0 == ... créé une erreur dans le cas où l'on oublie un '=' mais je me suis jamais habitué à l'écrire, tout simplement parce que ca ne coule pas de source par rapport à notre raisonnement lorsqu'on écrit, si on pense que la fonction ne doit pas renvoyer 0 on pense si regexec() != 0. Simplement pour info, mes choix (encore faudrait-il que je les
respecte!):
* N'utiliser la forme réduite if(Expression) que dans le cas où Expression s'évalue en quelque chose de booléen au sens le plus strict du terme. En corrolaire, si le type bool existe, natif ou #included, jamais de if(Expression == false) et surtout pas de if(Expression = true). Pour les pointeurs, j'utilise NULL (que je réserve à cet usage).
* J'ai compris très tard l'utilité supposée de l'inversion if(constante == Expression) Je ne l'utilise pas. Elle gêne MA lecture et les erreurs entre = et = sont rares quand on programme régulièrement. Quoique je fasse régulièrement des erreurs de ce type en Pascal en revenant à Delphi. Enfin, tous mes compilateurs warnent if(a = Expression), mais pas if((a = Expression) != 0).
Je ne connais pas POSIX, mais nous sommes ici dans le cas classique d'un retour "quasi booléen", c'est à dire que !0 (je n'ose pas écrire true ou !false) a une valeur entière significative. C'est une forme que l'on retrouve par exemple dans des fonctions de l'API Windows. Il me semble que le plus propre serait de #define un REG_SUCCESS à 0 et de faire if(regexec(...) != REG_SUCCESS) ou if(regexec(...) == REG_SUCCESS).
Enfin voil), le mois d'aout étant calme on pourrait lancer un troll sur le sujet mais bon... les habitudes sont très dures à corriger une fois qu'on les a prises. Mais certains qui lisent ce forum sont en période de choix de ces
habitudes ;-) -- Pierre
K. Ahausse
"Anthony" a écrit dans le message de news:412b4c28$0$22041$
Arno wrote:
Bonjour,
Salut,
Voila je veut utiliser regcomp et regexec pour faire des comparaisons. J'ai donc voulu faire un petit test pour commencer mais cella ne fonctionne pas. Lors de l'execution, il me dit que les deux chaines ne sont pas les mêmes, quelqu'un à une idée ?
Attention, cette question n'a pas sa place ici logiquement. Ces fonctions sont conformes à POSIX et non à C89 ou C99.
(-: Je me pose une question sommes-nous sur fr.comp.lang.c.norme.cx9 :-)
Je n'ai pas relue la charte récemment, mais je n'ai pas souvenir d'une restriction si contraignante.
"Anthony" <fleury_anthony@_hotmail_.com> a écrit dans le message de
news:412b4c28$0$22041$626a14ce@news.free.fr...
Arno wrote:
Bonjour,
Salut,
Voila je veut utiliser regcomp et regexec pour faire des comparaisons.
J'ai donc voulu faire un petit test pour commencer mais cella ne
fonctionne pas. Lors de l'execution, il me dit que les deux chaines ne
sont pas les mêmes, quelqu'un à une idée ?
Attention, cette question n'a pas sa place ici logiquement. Ces fonctions
sont conformes à POSIX et non à C89 ou C99.
(-: Je me pose une question sommes-nous sur fr.comp.lang.c.norme.cx9 :-)
Je n'ai pas relue la charte récemment, mais je n'ai pas souvenir d'une
restriction si contraignante.
"Anthony" a écrit dans le message de news:412b4c28$0$22041$
Arno wrote:
Bonjour,
Salut,
Voila je veut utiliser regcomp et regexec pour faire des comparaisons. J'ai donc voulu faire un petit test pour commencer mais cella ne fonctionne pas. Lors de l'execution, il me dit que les deux chaines ne sont pas les mêmes, quelqu'un à une idée ?
Attention, cette question n'a pas sa place ici logiquement. Ces fonctions sont conformes à POSIX et non à C89 ou C99.
(-: Je me pose une question sommes-nous sur fr.comp.lang.c.norme.cx9 :-)
Je n'ai pas relue la charte récemment, mais je n'ai pas souvenir d'une restriction si contraignante.
Québec
Bonjour, bonjour ... Ça existe-t-il les regex en C norme?
Jean Pierre
Bonjour, bonjour ...
Ça existe-t-il les regex en C norme?
Bonjour, bonjour ... Ça existe-t-il les regex en C norme?
Jean Pierre
Marc Lasson
Québec wrote with his little fingers:
Ça existe-t-il les regex en C norme?
La bibliothèque standard ne contient pas de fonctions permettant de gérer les expressions régulières. Mais l'implémentation des fonctions POSIX doit probablement pouvoir être codé en C tout ce qu'il y a de plus standard.
-- Marc.
Québec wrote with his little fingers:
Ça existe-t-il les regex en C norme?
La bibliothèque standard ne contient pas de fonctions permettant de
gérer les expressions régulières. Mais l'implémentation des fonctions
POSIX doit probablement pouvoir être codé en C tout ce qu'il y a de plus
standard.
La bibliothèque standard ne contient pas de fonctions permettant de gérer les expressions régulières. Mais l'implémentation des fonctions POSIX doit probablement pouvoir être codé en C tout ce qu'il y a de plus standard.
