ऑपरेटर प्राथमिकता बदलें

Question

कंक्रीट अभिव्यक्ति के लिए ऑपरेटर प्राथमिकता को बदलने का सबसे अच्छा तरीका क्या होगा?

उदाहरण के लिए मैं एक वर्ग है:

class A(){ 
    def multiply(a) { 
     ... 
    } 

    def plus(a) { 
     ... 
    } 

    def minus(b) { 
     ... 
    } 

} 

a = new A() 
b = new A() 
c = new A() 

d = a + (b - c) * d 

गुणा अधिक पूर्वता + और - की तुलना में मैं फार्म की एक एएसटी मिलता है के रूप में

+ 
/\ 
a * 
/\ 
    - d 
/\ 
b c 

सबसे आसान तरीका करने के लिए इसे परिवर्तित करने के लिए किया जाएगा क्या एक पेड़ जहां *+ और - से कम प्राथमिकता है। मुझे लगता है कि कोष्ठक को केवल - और + समूह करने की अनुमति है, यानी एक अभिव्यक्ति (a * b - c) * d मान्य नहीं है और इनपुट के रूप में अपेक्षा नहीं की जानी चाहिए।

Answer 1

आप बस अपने कोड में ब्रांड्स जोड़ सकते हैं। इससे एएसटी परिवर्तन का उपयोग करने से आपके कोड को अधिक आसानी से समझ लिया जाएगा।

Answer 2

आप यह एक एएसटी परिवर्तन का उपयोग कर बदल सकता है, लेकिन यह सही करने के लिए एक मुश्किल बात होगी ...

आप GroovyConsole में अपनी स्क्रिप्ट लोड, और फिर एएसटी ब्राउज़र खोलते हैं, तो आप करेंगे कार्य के लिए इस पेड़ देखें:

Binary - (d = (a & (b >> c))) 
    Variable - d 
    Binary - (a & (b >> c)) 
    Variable - a 
    Binary - (b >> c) 
     Variable - b 
     Variable - c 

तो जैसा कि आप देख सकते हैं, नोड्स डिफ़ॉल्ट ऑपरेटर पूर्वता के आधार पर क्रियान्वित कर रहे हैं, और org.codehaus.groovy.ast.expr.BinaryExpression और org.codehaus.groovy.ast.expr.VariableExpression एएसटी नोड्स के एक पेड़ बन जाता है।

आपको एएसटी ट्रांसफॉर्म लिखना होगा जो बाइनरीएक्सप्रेस नोड्स के लिए पेड़ को स्कैन करेगा और फिर इन पेड़ों को दोबारा ऑर्डर करें ताकि उन्हें operation फ़ील्ड के लिए अपनी प्राथमिकता से क्रमबद्ध किया जा सके। ऑपरेटर ओवरलोडिंग * * भ्रम की स्थिति हो सकती और बदलते ऑपरेटर पूर्वता और भी दे सकते हैं:

या, आप कोष्ठकों अपने कोड में के रूप में डॉन पता चलता है :-)