[REGEXP] Reconnaitre un catch réalisant un throw

Bonjour,

Je souhaite identifier via une REGEXP java le bout de code suivant :

Code:

---

1 2 3 4 5

catch (Exception e) { // ... throw e; }

---

Je crois que cela revient à avoir un catch suivi d'un throw avant qu'une accolade fermante ne soit trouvée.

D'ou la regexp : "catch[.&&[^}]]*throw" qui signifie le mot "catch", puis n'importe quel caractère sauf "}" 0 ou n fois puis throw.

Mais ça ne marche pas.

Avez-vous une idée ?

tu peux essayer ca :

Code:

---

catch[^\}]*throw

---

qui signifie "catch" suivis de n'importe quel caractère different de "}" suivis de "throw".
Ca marche pas mieux ?

Citation:

---

Envoyé par crv

tu peux essayer ca :

Code:

---

catch[^\}]*throw

---

qui signifie "catch" suivis de n'importe quel caractère different de "}" suivis de "throw".
Ca marche pas mieux ?

---

Impeccable effectivement, mais il faut rajouter un .* à la fin si la chaine contient des caractères après le throw :

Code:

---

1 2 3 4

System.out.println(Pattern.matches("catch[^}]*throw.*", "catch (Exception e) { e.printStackTrace(); throw e; }"));   System.out.println(Pattern.matches("catch[^}]*throw.*", "catch (Exception e) { e.printStackTrace(); } throw e; "));

---

Il ne me reste plus qu'à reconnaitre l'inverse, à savoir un catch qui ne contient pas de throw.

Une petite remarque, n'oublie pas d'échaper le caractère '}' :

Code:

---

String regex = "catch[^\\}]*throw.*"

---

Citation:

---

Envoyé par otsgd

Il ne me reste plus qu'à reconnaitre l'inverse, à savoir un catch qui ne contient pas de throw.

---

Il te suffit de modifier ta première expression régulière afin de rendre le "throw" optionnel (avec le quantifieur ?), ainsi tu as une seule expression régulière ;) :

Code:

---

String regex = "catch[^\\}]*(throw)?.*"

---

Citation:

---

Envoyé par le y@m's

Une petite remarque, n'oublie pas d'échaper le caractère '}' :

Code:

---

String regex = "catch[^\\}]*throw.*"

---

---

Le caractère '}' n'a pas besoin d'être échappé il me semble. En plus "\\" représente l'échappement du '\' => Autant pour moi, ca à l'air de marcher dans les deux cas, avec ou sans ton échappement.

Citation:

---

Il te suffit de modifier ta première expression régulière afin de rendre le "throw" optionnel (avec le quantifieur ?), ainsi tu as une seule expression régulière ;) :

Code:

---

String regex = "catch[^\\}]*(throw)?.*"

---

---

Effectivement, mais je veux reconnaitre les expressions ou le throw ne se trouve pas et uniquement celles-ci. Ce n'est donc pas facultatif.

D'après ce que je lis ici et là, ce n'est pas possible via une regexp, il faut faire du code, ce qui n'est pas possible dans mon cas. La négation '^' ne peut s'utiliser que sur les caractères : "[^abc]" signifie ni a ni b ni c. Mais ca ne marche pas pour un groupe de lettres.

Citation:

---

Envoyé par otsgd

Le caractère '}' n'a pas besoin d'être échappé il me semble.

---

Si tu regarde la javadoc de la classe Pattern tu remarqueras que plusieurs expressions utilisent les accolades ('{' et '}') comme caractères spéciaux, il vaut donc mieux prendre la précaution de les échapper.

Citation:

---

Envoyé par otsgd

En plus "\\" représente l'échappement du '\

---

cf Pourquoi dois-je doubler/quadrupler le caractère anti-slash ('\') ?

Citation:

---

D'après ce que je lis ici et là, ce n'est pas possible via une regexp, il faut faire du code, ce qui n'est pas possible dans mon cas. La négation '^' ne peut s'utiliser que sur les caractères : "[^abc]" signifie ni a ni b ni c. Mais ca ne marche pas pour un groupe de lettres.

---

C'est vrai dans le sens ou il n'y a pas de norme pour la négation, mais si tu utilises la classe Pattern, il semble que la négation soit gérée : "?!X" signifierait "pas X"

http://java.sun.com/j2se/1.4.2/docs/...x/Pattern.html :

Code:

---

1 2 3 4 5 6 7 8 9

Special constructs (non-capturing) (?:X) X, as a non-capturing group (?idmsux-idmsux) Nothing, but turns match flags on - off (?idmsux-idmsux:X) X, as a non-capturing group with the given flags on - off (?=X) X, via zero-width positive lookahead (?!X) X, via zero-width negative lookahead (?<=X) X, via zero-width positive lookbehind (?<!X) X, via zero-width negative lookbehind (?>X) X, as an independent, non-capturing group

---

à tester ... ;)

Effectivement, ça à l'air intéressant, mais je ne parviens pas à l'utiliser :

Code:

---

1 2	System.out.println(Pattern.matches("a(?:(th))*c", "atcc"));

---

Devrait renvoyer true, mais renvoit false. Pourtant, on a bien "a", puis autant de fois que l'on veut quelque chose qui ne match pas "th", puis "c".

Citation:

---

Envoyé par otsgd

Effectivement, ça à l'air intéressant, mais je ne parviens pas à l'utiliser :

Code:

---

1 2	System.out.println(Pattern.matches("a(?:(th))*c", "atcc"));

---

Devrait renvoyer true, mais renvoit false. Pourtant, on a bien "a", puis autant de fois que l'on veut quelque chose qui ne match pas "th", puis "c".

---

tu n'es pas loin :-) essaye cela :

Code:

---

1 2	System.out.println(Pattern.matches("a((?!th).)*c", "atcc"));

---

Sinon pour faire des tests, cette adresse est bien pratique : http://www.cis.upenn.edu/~matuszek/G...ex-tester.html