कॉमा-डिलीमिटेड तर्क सूची को पार्स करने के लिए फ्लेक्स/बाइसन नियमों को कैसे सेट करें

Question

मैं एक गैर-खाली, एक या कई तत्व, अल्पविराम-सीमित (और वैकल्पिक रूप से ब्रांडेड) सूची का उपयोग करके फ्लेक्स/बाइसन पार्स नियम।

कुछ उदा। parseable सूचियों का:

• 1,2
• (1,2)
• (3)
• 3,4,5
• (3,4,5,6)

आदि

मैं निम्नलिखित नियमों का उपयोग कर रहा पार्स करने के लिए सूची (अंतिम परिणाम पार्स तत्व 'शीर्ष स्तर की सूची' है), लेकिन जब वे पार्सिंग करते हैं तो वांछित परिणाम नहीं देते हैं (मुझे वैध सूची की आपूर्ति करते समय वाक्यविन्यास-त्रुटि मिलती है)। इस पर कोई सुझाव है कि मैं इसे कैसे स्थापित कर सकता हूं?

cList : ELEMENT 
      { 
       ... 
      } 
     | cList COMMA ELEMENT 
      { 
       ... 
      } 
     ; 

topLevelList : LPAREN cList RPAREN 
       { 
        ...     
       } 
       | cList 
       { 
        ... 
       } 
      ; 

Answer 1

यह आसान लगता है। मुझे बताओ कि अगर मैं कुछ छूट गया हो या अगर मेरे उदाहरण नहीं करता है

RvalCommaList: 
      RvalCommaListLoop 
    | '(' RvalCommaListLoop ')' 

RvalCommaListLoop: 
     Rval 
    | RvalCommaListLoop ',' Rval 

Rval: INT_LITERAL | WHATEVER 

हालांकि काम अगर आप rvals के साथ ही इस सूची में आप एक संघर्ष एक आइटम की सूची के साथ एक नियमित रूप से rval भ्रामक होगा स्वीकार करते हैं। इस मामले में आप उपयोग कर सकते हैं जो नीचे या तो की आवश्यकता होगी '(' ')' उनके आसपास या 2 आइटम की आवश्यकता होती है इससे पहले कि यह एक सूची

RvalCommaList2: 
     Rval ',' RvalCommaListLoop 
    | '(' RvalCommaListLoop ')' 

Answer 2

मैं भी पता करने के लिए कि यह कैसे करना चाहते हैं, इस बारे में सोच संक्षेप में, प्राप्त करने के लिए इस फॉर्म की एक लिंक्ड सूची का उपयोग करने के होगा एक ही रास्ता है,

struct list; 
struct list { 
    void *item; 
    struct list *next; 
}; 

struct list *make_list(void *item, struct list *next); 

और नियम का उपयोग कर: 0123:

{ $$ = make_list($1, $2); } 

यह समाधान करने के लिए डिजाइन में बहुत समान है

हार्ड बिट यह पता लगाने के लिए है कि बाइनरी एएसटी (मुझे लगता है) की योजना में सूचियों को कैसे संभाला जाए।

Answer 3

%start input 
%% 
input: 
%empty 
| integer_list 
; 

integer_list 
: integer_loop 
| '(' integer_loop ')' 
; 

integer_loop 
: INTEGER 
| integer_loop COMMA INTEGER 
; 
%%