जावा - नियमित रूप से अभिव्यक्ति कोड

Question

में टिप्पणियां ढूंढने के लिए इस समय जावा के साथ मजेदार।

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

उस में सभी टिप्पणियों पाता है और उन्हें निकालता है: मैं एक प्रोग्राम है जो मानक इनपुट से एक कोड पढ़ता है (लाइन द्वारा लाइन, उदाहरण के लिए) लिखने के लिए, की तरह चाहते हैं।

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

किसी भी सलाह या: मैं रेगुलर एक्सप्रेशन का उपयोग करने के लिए कोशिश कर रहा हूँ, और अब के लिए मैं कुछ इस तरह किया है: उदाहरण के लिए

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

लेकिन यह सभी मामलों के लिए काम करने के लिए नहीं लगता है, विचार regex से अलग? अग्रिम धन्यवाद।

Answer 1

एक और विकल्प कुछ पुस्तकालयों का उपयोग एएसटी पार्सिंग का समर्थन करना है, उदाहरण के लिए org.eclipse.jdt.core में सभी एपीआई हैं जिन्हें आपको और अधिक करने की आवश्यकता है। लेकिन तब है कि सिर्फ एक विकल्प :)

Answer 2

पिछले उदाहरण कोई समस्या नहीं मुझे लगता है कि है:

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

... क्योंकि टिप्पणी वास्तव में "We can use */ साथ समाप्त होता है। यह कोड संकलित नहीं करता है।

int/*comment*/foo=3; 

आपका पैटर्न में इस बदलना होगा:

intfoo=3; 

... अमान्य कोड क्या है

लेकिन मैं एक और समस्या पैदा करने वाले मामला है। "" के बजाय " " के साथ अपनी टिप्पणियों को बेहतर ढंग से बदलें।

Answer 3

मुझे लगता है कि नियमित अभिव्यक्तियों का उपयोग करके 100% सही समाधान या तो अमानवीय या असंभव है (खाते में भाग लेना आदि)।

मेरा मानना ​​है कि सबसे अच्छा विकल्प एएनटीएलआर का उपयोग करेगा- मेरा मानना ​​है कि वे जावा व्याकरण भी प्रदान कर सकते हैं जिसका आप उपयोग कर सकते हैं।

Answer 4

आप पहले से ही इसे छोड़ चुके हैं लेकिन मैं समस्या से चिंतित था।

मेरा मानना ​​है कि यह एक आंशिक समाधान है ...

मूल निवासी regex:

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

जावा में:

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

यह ठीक से तार में एम्बेडेड टिप्पणी को संभालने के लिए प्रकट होता है और साथ ही तारों के अंदर उद्धरण से ठीक से बच निकला। मैंने जांच करने के लिए कुछ चीजें फेंक दी लेकिन पूरी तरह से नहीं।

एक समझौता है कि कोड में सभी ब्लॉक उनके बाद अंतरिक्ष के साथ समाप्त हो जाएंगे। इस सरल को हल करना और समस्या को हल करना बहुत मुश्किल होगा:

int/* some comment */foo = 5; 

एक साधारण Matcher।ढूंढें/संलग्न करें रिप्लेसमेंट लूप सशर्त रूप से किसी स्थान के साथ प्रतिस्थापित करने से पहले समूह (1) की जांच कर सकता है और केवल कोड की एक मुट्ठी भर होगी। शायद एक पूर्ण अप पार्सर से अभी भी आसान है। (यदि कोई दिलचस्पी लेता है तो मैं मैचर लूप भी जोड़ सकता हूं।)

Answer 5

मैं इस समाधान के साथ समाप्त हुआ।

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