Pegjs: व्हाइटस्पेस विभाजक कैसे संरक्षित करें?

@futagoza आपको परेशान करने के लिए अविश्वसनीय रूप से खेद है लेकिन यह पहली बार है जब मैं पीईजी.जेएस से निपट रहा हूं और यह मुद्दा मेरे लिए महत्वपूर्ण है। क्या मैं आपसे थोड़ा संकेत मांग सकता हूं?

सादर,
मारेक

मैंने आपके व्याकरण (कल और अभी) को देखने की कोशिश की, लेकिन क्योंकि इसे समझना वाकई मुश्किल है (एक तरफ सम्मेलनों का नामकरण, प्रारूप, ईमानदार होने के लिए, सभी जगह है), मुझे समाधान को ट्रैक करने में कुछ समय लगा:

1. नियम जो अंतरिक्ष और डेटा की खपत करते हैं, उसे वापस कर देते हैं (जैसे const रिटर्न [left_space, cnst, right_space] )
2. कोई भी नियम/कार्रवाई जो परिणाम देती है उसे कुछ इस तरह करना चाहिए: [].concat.apply([], con)

फिर भी, आपके साथ ईमानदार होने के लिए यह मेरे लिए एक हैकी समाधान की तरह लगता है। क्या आपके पास किसी विशिष्ट या किसी चीज़ का लिंक है? यह जानने में मदद करेगा कि उपरोक्त हैकी समाधान के बिना वांछित परिणाम प्राप्त करने के लिए मैं कौन से नियम बदल सकता हूं और नहीं बदल सकता।

यदि नहीं, जब तक आप व्याकरण को व्यवस्थित करने और कुछ नियमों का नाम बदलने के लिए तैयार हैं (इसलिए यह पता लगाना आसान है कि आप क्या चाहते हैं), तो मैं खुशी से इस पर एक और छुरा लेने की कोशिश करूंगा

@ मारेक-बारानोवस्की - क्षमा करें, मैंने इसे अब तक नहीं देखा। उम्मीद है कि यह अभी भी आपके लिए उपयोगी है

यदि आप रिक्त स्थान रखना चाहते हैं, तो बस उनके साथ मेल खाने योग्य सामग्री की तरह व्यवहार करें।

यह वास्तव में बिल्कुल स्पष्ट नहीं है कि आप दो रिक्त स्थान के लिए क्या चाहते हैं। आपके पास या तो दो रिक्त स्थान की एक स्ट्रिंग हो सकती है, या दो एक-स्पेस स्ट्रिंग्स की एक सरणी हो सकती है। आम तौर पर मैं पूर्व की अपेक्षा करता हूं, लेकिन ... आपकी हर चीज प्रति-चरित्र है

इसके अलावा ... आप फंक्शन कॉल को छोड़कर, इस तरह के आवारा पात्रों को क्यों चाहते हैं? पार्सर आपके लिए उनको संक्षेप में प्रस्तुत करना चाहिए।

वैसे भी

आपने यही मांगा है:

Document = Expression*

Whitespace
  = tx:[ \r\n]+ { return tx.join(''); }

Number
  = str:[0-9]+ { return str.join(''); }

Oper
  = '+'
  / '-'
  / '/'
  / '*'
  / ','

Label
  = l:[a-zA-Z]+ { return l.join(''); }

Parens 
  = '(' Whitespace? ex:Expression* Whitespace? ')' { return ex; }

Expression 
  = Number 
  / Oper
  / Whitespace
  / Label
  / Parens
  / [^()]+

बात यह है कि, मैं अत्यधिक आश्वस्त नहीं हूं कि वास्तव में आप यही चाहते हैं। उदाहरण के बजाय आप संख्याओं और ऑपरेटरों को पार्स कर सकते हैं, और प्रत्येक के लिए एक मानकीकृत नोड आकार वापस कर सकते हैं:

Document = Expression*

Whitespace
  = tx:[ \r\n]+ { return { 
    ast: 'whitespace', value: tx.join('') 
  }; }

Number
  = str:[0-9]+ { return {
    ast: 'number', value: parseInt(str,10)
  }; }

Oper
  = '+' { return { ast: 'oper', value: 'add' }}
  / '-' { return { ast: 'oper', value: 'subtract' }}
  / '/' { return { ast: 'oper', value: 'divide' }}
  / '*' { return { ast: 'oper', value: 'multiply' }}
  / ',' { return { ast: 'oper', value: 'sequence' }}

Label
  = l:[a-zA-Z]+ { return { 
    ast: 'label', value: l.join('') 
  }; }

Parens 
  = '(' Whitespace? ex:Expression* Whitespace? ')' { 
    return { ast: 'parens', value: ex 
  }; }

Expression 
  = Number 
  / Oper
  / Whitespace
  / Label
  / Parens
  / [^()]+

अब आपके पास अभी भी आपका व्हाइटस्पेस है, लेकिन आपके पास एक उचित पार्स किया हुआ पेड़ भी है, और अपने पार्सर के आउटपुट को पार्स करने के लिए एक पार्सर लिखने की आवश्यकता नहीं है, और यह भी आसान है क्योंकि पाई अब लाइन नंबर जैसी नियमित सुविधाओं को जोड़ना शुरू कर देता है और आगे

@ मारेक-बारानोवस्की - मैं इस समस्या ट्रैकर के आकार को कुछ हद तक कम करना चाहता हूं

यदि आपको उपरोक्त की आवश्यकता है, तो क्या आप कृपया इस मुद्दे को बंद करने पर विचार करेंगे? धन्यवाद

अगर ऐसा नहीं है, तो कृपया मुझे बताएं कि क्यों, और मैं फिर से कोशिश करूंगा

@ मारेक-बारानोवस्की एक और कोमल पिंग: स्माइली_कैट:

इसके अलावा, मैंने व्याकरण के डिबगिंग की सुविधा के लिए एक PEG.js प्लगइन pegjs-syntactic-actions लिखा है, और विशेष रूप से देखें कि कौन से वर्ण क्रियाओं से स्वतंत्र रूप से किस नियम द्वारा कैप्चर किए जाते हैं, जो शायद यहां आपकी समस्या है जैसा कि @StoneCypher द्वारा समझाया गया है।

इस प्लगइन का तर्क है: मुझे लगता है कि वैश्विक परिणाम को समझना अक्सर/कभी-कभी मुश्किल होता है, जब यह वह नहीं होता है जिसकी हम अपेक्षा करते हैं, क्योंकि यह कई छोटी क्रियाओं के संयोजन से उत्पन्न होता है, और उस क्रिया को ढूंढना जो बुरी तरह से/अजीब व्यवहार करती है बहुत समय लगेगा। इस प्लगइन के साथ, हम देखते हैं कि कौन सा नियम किस चरित्र को पकड़ता है, और यह उस क्रिया का नाम देता है जिस पर कार्य करना है।

अरे वाह यह वास्तव में वास्तव में साफ है