Java - expresión regular que encuentra comentarios en el código

Question

Un poco diversión con Java esta vez. Quiero escribir un programa que lee un código de la entrada estándar (línea por línea, por ejemplo), como:

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

encuentra todos los comentarios en él y los elimina. Estoy tratando de utilizar expresiones regulares, y por ahora he hecho algo como esto:

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

pero parece no funcionar para todos los casos, por ejemplo:

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

Cualquier consejo o ideas diferentes de regex? Gracias de antemano.

Answer 1

Otra alternativa es utilizar alguna biblioteca que soporte el análisis de AST, por ejemplo. org.eclipse.jdt.core tiene todas las API que necesita para hacer esto y más. Pero eso es sólo una alternativa :)

Answer 2

El último ejemplo es ningún problema que pienso:

/* we comment out some code 
System.out.print("We can use */ inside a string of course"); 
we end the comment */ 

... porque el comentario de hecho termina con "We can use */. Este código no se compila.

Pero tengo otro caso problemático:

int/*comment*/foo=3; 

Su patrón va a transformar esto en:

intfoo=3; 

... lo que es código no válido. Así que es mejor que reemplace sus comentarios con " " en lugar de "".

Answer 3

Creo que una solución 100% correcta usando expresiones regulares es inhumana o imposible (teniendo en cuenta escapes, etc.).

Creo que la mejor opción sería usar ANTLR, creo que incluso proporcionan una gramática de Java que puede usar.

Answer 4

Es posible que ya haya renunciado a esto, pero estaba intrigado por el problema.

Creo que esta es una solución parcial ...

expresiones regulares Nativo:

//.*|("(?:\\[^"]|\\"|.)*?")|(?s)/\*.*?\*/ 

En Java:

String clean = original.replaceAll("//.*|(\"(?:\\\\[^\"]|\\\\\"|.)*?\")|(?s)/\\*.*?\\*/", "$1 "); 

Esto parece manejar adecuadamente los comentarios incrustados en las cadenas, así como escapó correctamente las comillas dentro de las cadenas. Tiré algunas cosas para verificar pero no exhaustivamente.

Hay un compromiso en que todos los "" bloques en el código terminarán con espacio después de ellos. Teniendo esto simple y la solución de ese problema sería muy difícil dada la necesidad de manejar limpiamente:

int/* some comment */foo = 5; 

Un simple Matcher.El bucle find/appendReplacement podría verificar condicionalmente el grupo (1) antes de reemplazarlo con un espacio y solo sería un puñado de líneas de código. Aún más simple que un analizador completo tal vez. (Podría agregar el bucle matcher también si alguien está interesado.)

Answer 5

Terminé con esta solución.

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; 
    } 
}