Java - expression régulière trouvant des commentaires dans le code

Un peu plaisir avec Java cette fois. Je veux écrire un programme qui lit un code de l'entrée standard (ligne par ligne, par exemple), comme:

//some comment
class Main {
    /* blah */
    ///* foo
    foo();
    //foo */
    foo2();
    /* //foo2 */
}

trouve tous les commentaires et les supprime. Je suis en train d'utiliser des expressions régulières, et pour l'instant j'ai fait quelque chose comme ceci:

private static String ParseCode(String pCode)
{
    String MyCommentsRegex = "(?://.*)|(/\\*(?:.|[\\n\\r])*?\\*/)";
    return pCode.replaceAll(MyCommentsRegex, " ");
}

mais il semble ne pas fonctionner pour tous les cas, par exemple:

System.out.print("We can use /* comments */inside a string of course, but it shouldn't start a comment");

Des conseils ou des idées différentes de regex?
Merci à l'avance.

source d'informationauteur brovar

23

Vous avez déjà renoncé à cela maintenant, mais j'ai été intrigué par le problème.

Je crois que c'est une solution partielle...

Natif de la regex:
```
//.*|("(?:\\[^"]|\\"|.)*?")|(?s)/\*.*?\*/
```
En Java:
```
String clean = original.replaceAll( "//.*|(\"(?:\\\\[^\"]|\\\\\"|.)*?\")|(?s)/\\*.*?\\*/", "$1 " );
```
Cela semble gérer correctement les commentaires intégrés dans des chaînes ainsi que des échappées guillemets à l'intérieur des chaînes de caractères. J'ai jeté quelques choses à pour vérifier mais pas de manière exhaustive.

Il y a un compromis que "toutes les" blocs dans le code va se retrouver avec un espace après. Garder ce simple et la résolution de ce problème sera très difficile compte tenu de la nécessité de proprement de la poignée:
```
int/* some comment */foo = 5;
```
Une simple Correspondance.trouver/appendReplacement boucle peut conditionnellement vérifier pour le groupe(1) avant de les remplacer par un espace et ne serait plus qu'une poignée de lignes de code. Encore plus simple qu'un seul analyseur, peut-être. (Je pourrais ajouter au comparateur de boucle trop si quelqu'un est intéressé.)
3

Le dernier exemple n'est pas un problème je pense:
```
/* we comment out some code
System.out.print("We can use */ inside a string of course");
we end the comment */
```
... parce que le commentaire se termine effectivement avec "We can use */. Ce code ne compile pas.

Mais j'ai un autre cas problématique:
```
int/*comment*/foo=3;
```
Votre modèle se transformer en l':
```
intfoo=3;
```
...qu'est-ce que le code non valide. Afin de mieux de remplacer vos commentaires avec " " au lieu de "".
3

Je pense qu'un 100% solution correcte à l'aide des expressions régulières est soit inhumains ou impossible (en tenant compte des évasions, etc.).

Je crois que la meilleure option serait d'utiliser ANTLR - je crois qu'ils fournissent même un Java de grammaire que vous pouvez utiliser.

J'ai fini avec cette solution.

public class CommentsFun {
static List<Match> commentMatches = new ArrayList<Match>();
public static void main(String[] args) {
Pattern commentsPattern = Pattern.compile("(//.*?$)|(/\\*.*?\\*/)", Pattern.MULTILINE | Pattern.DOTALL);
Pattern stringsPattern = Pattern.compile("(\".*?(?<!\\\\)\")");
String text = getTextFromFile("src/my/test/CommentsFun.java");
Matcher commentsMatcher = commentsPattern.matcher(text);
while (commentsMatcher.find()) {
Match match = new Match();
match.start = commentsMatcher.start();
match.text = commentsMatcher.group();
commentMatches.add(match);
}
List<Match> commentsToRemove = new ArrayList<Match>();
Matcher stringsMatcher = stringsPattern.matcher(text);
while (stringsMatcher.find()) {
for (Match comment : commentMatches) {
if (comment.start > stringsMatcher.start() && comment.start < stringsMatcher.end())
commentsToRemove.add(comment);
}
}
for (Match comment : commentsToRemove)
commentMatches.remove(comment);
for (Match comment : commentMatches)
text = text.replace(comment.text, " ");
System.out.println(text);
}
//Single-line
//"String? Nope"
/*
* "This  is not String either"
*/
//Complex */
///*More complex*/
/*Single line, but */
String moreFun = " /* comment? doubt that */";
String evenMoreFun = " //comment? doubt that ";
static class Match {
int start;
String text;
}
}

0

Une autre alternative est d'utiliser une bibliothèque de soutenir AST analyse, par exemple, pour org.eclipse.jdt.de base a toutes les Api que vous devez faire cela et plus encore. Mais alors que c'est juste une solution de rechange:)

Vous devez vous connecter pour publier un commentaire.