Newsgroup: it.comp.java
Titolo: espressione regolare per commenti

salve a tutti...
devo elaborare dei sorgenti java e vorrei poter "eliminare" i commenti
so che posso semplicemente scandire il file byte byte ed eliminare cio
che viene dopo /* e lasciare cio che viene dopo */, ma non ci sarebbe
qualcosa di piu comodo passando per esempio dalla replaceAll() di
String???
Ovvero che espressione regolare dovrei usare per beccare i commenti ???
grazie

 writes:
b> salve a tutti...  devo elaborare dei sorgenti java e vorrei poter
b> "eliminare" i commenti
b> so che posso semplicemente scandire il file byte byte ed eliminare
b> cio che viene dopo /* e lasciare cio che viene dopo */, ma non ci
b> sarebbe qualcosa di piu comodo passando per esempio dalla
b> replaceAll() di String???
b> Ovvero che espressione regolare dovrei usare per beccare i commenti
b> ???
La regexp dovrebbe essere (Java ha *2* tipi di commento:
/\*[^*]*\*/\|^//[^\n]*[\n\r\f\z]
compilata con il flag multiline. Non la ho provata quindi il debugging
è  tutto  tuo.
Consiglio: NON LO FARE.
Le regexp sono pesanti, e quelle multiline ancora di più. Scandisci il
file carattere per carattere e scarta tutto quello che c'è tra /* e */
oppure tra // e \n
-- 
 /\           ___
/___/\_|_|\_|__|___Gian Uberto Lauri_____
  //--\| | \|  |   Integralista GNUslamico
\/                 e coltivatore diretto di Software

 oppure tra // e \n
e che per una volta preferivo la pappa scodellata ;-) per essere sicuro
di
non tralasciare niente...
Mi confermi (come ha brevemente riassunto) che mi bastano solo questi
"poche" regole
per scartare SICURAMENTE tutti i commenti??
grazie

 oppure tra // e \n
e che per una volta preferivo la pappa scodellata ;-) per essere sicuro di


"poche" regole per scartare SICURAMENTE tutti i commenti??
No, purtroppo, difatti devi stare attento a ciň che contengono le
stringhe.  Diciamo che una macchina a stati finiti per
l'interpretazione potrebbe essere (non testata, eh?):
stato -- se incontri -- azioni ------ nuovo stato
  0            /          print /         1
-------------------------------------------------
  0            "          print "         5     <<--- inizio stringa
-------------------------------------------------
  0          altro        print altro     0
-------------------------------------------------
  1            /          ignore /        3      <<--- inizio commento
-------------------------------------------------
  1            *          ignore *        2      <<--- inizio commento
-------------------------------------------------
  1          altro        print /         0
                          ptint altro      
-------------------------------------------------
  2            *          ignore *        4     
-------------------------------------------------
  2          altro        ignore altro    2     <<--- caratteri comm.
-------------------------------------------------
  3         newline       ignore newline  0     <<--- fine //
-------------------------------------------------
  3          altro        ignore altro    3     <<--- caratteri comm.
-------------------------------------------------
  4            /          ignore /        0     <<--- fine /*
-------------------------------------------------
  4          altro        print *         2  
                          print altro
-------------------------------------------------
  5            \          print \         6    
-------------------------------------------------
  5            "          print "         0    <<--- fine stringa 
-------------------------------------------------
  5          altro        print altro     5
-------------------------------------------------
  6         qualsiasi     print qualsiasi 5 
-------------------------------------------------

  0            /          print /         1
ecco, già me so impippato, ovviamente è ignore /
;-)


boh, mi segnala errori ad usarla come espr reg per replaceAll... 



Il seguente è codice C, ma penso tu possa adattarlo facilmente:
#include <stdio.h>
int main()
{ 
    int c, state=0;
    while ((c=getchar())!=EOF) {
          switch (state) {
             case 0: if (c=='/') state=1;
                     else {
                     if (c=='\"') state=5;
                     putchar(c);
                     }
                     break;
             case 1: if (c=='/') state=3; 
                     else
                     if (c=='*') state=2;         
                     else {
                       putchar('/');
                       putchar(c);
                       state=0;
                     }
                     break;
             case 2: if (c=='*') state=4; 
                     break;
             case 3: if (c=='\n') state=0;
                     break;
             case 4: if (c=='/') state=0;
                     else state=2;
                     break;
             case 5: { 
                     if (c=='\\') state=6; 
                     else
                     if (c=='\"') state=0;          
                     putchar(c);
                     }
                     break;
             case 6: { 
                     putchar(c);
                     state=5;
                     }
                     break;
          }
    }  
    return 0;
}

> 
b> boh, mi segnala errori ad usarla come espr reg per replaceAll...
Probabilmente ha  errori nella sintassi.  Uso poco le regexp  di Java,
usualmente le uso nel mio editor e la brutta cosa delle regexp che non
tutti hanno la stessa sintassi.


 
Ciao, potresti approfondirla?
Tutti chi/cosa?

> 
p> Ciao, potresti approfondirla?
p> Tutti chi/cosa?
Oddio, non  c'č molto da  dire. Quello che  non cambia non č  tanto il
cosa  fare  e  come  farlo,  le differenze  sono  solo  sintattiche  e
usualmente si  traducono nel come e cosa  "escapare" (scusate l'orrore
linguistico).
Quindi  un  motore accetta  tranquillamente  una  regexp che  un'altro
motore manda a quel paese.
E  ripeto, č  probabile che  quella regexp  avesse errori  di sintassi
(indipendentemente dal motore, la ho  buttata lě, anche se il debug di
una regexp č un "dolore al sederino").
