Pegjs: इंडेंटेशन-आधारित भाषाओं का समर्थन पार्सिंग

इंडेंटेशन आधारित व्याकरणों को पार्स करने के लिए कस्टम हैंडलर में आपके द्वारा जोड़े जाने वाले साइड-इफेक्ट्स पर भरोसा करना बहुत खतरनाक है। बस मत करो। पार्सिंग इंडेंटेशन (और अन्य संदर्भ संवेदनशील व्याकरण) को सुरक्षित बनाने के लिए पेगज को सशर्त स्थिति को धक्का देने और पॉप करने की कुछ क्षमता जोड़नी होगी।

मैं अभी यही करता हूं, और मैं आपको यह करने की सलाह देता हूं: इनपुट फ़ाइल को प्रीप्रोसेस करें और अपना इंडेंट/आउटडेंट टोकन डालें। मैं क्रमशः {{{{ और }}}} का उपयोग करता हूं। तब आपका व्याकरण संदर्भ मुक्त होता है और इसे सामान्य रूप से पार्स किया जा सकता है। यह आपकी लाइन/कॉलम मानों को गड़बड़ कर सकता है, लेकिन आप उन्हें पोस्टप्रोसेसर में ठीक कर सकते हैं।

यदि आपको जावास्क्रिप्ट को लक्षित करने की आवश्यकता नहीं है, तो Pegasus , मेरे pegjs क्लोन C# के लिए, राज्य को पुश/पॉपिंग करने के लिए समर्थन है। आप जो चाहते हैं उसे ठीक से कैसे करें, इस पर यहां एक विकी आलेख है: https://github.com/otac0n/Pegasus/wiki/Significant-Whitespace-Parsing

मैं यह प्रस्तावित करना चाहता हूं कि pegjs राज्य-आधारित पार्सिंग के लिए प्रारंभिक बिंदु के रूप में मेरे सिंटैक्स का उपयोग करें।

सुरक्षित रूप से पुश करने और राज्य को पॉप करने की क्षमता अच्छी है। मैं इसका इस्तेमाल करूंगा अगर यह जावास्क्रिप्ट आधारित था। सिर्फ पार्सिंग के लिए सीएलआर को एकीकृत करने के लायक नहीं है।

यह वह है जिसका मैंने अंदाज़ लगाया था। मुझे लगता है, उस स्थिति में, मुझे शायद अपने सुधारों को pegjs में बैक-पोर्ट करने का प्रयास करना चाहिए।

हालांकि, मैं जरूरी नहीं कि @dmajda के साथ बातचीत किए बिना ऐसा करना चाहता हूं।

@ otac0n यह अच्छा है। मैं सी # नहीं लिखता। जावास्क्रिप्ट मेरे लिए बहुत बेहतर है।

इंडेंटेशन-आधारित भाषाएं महत्वपूर्ण हैं। मैं 1.0.0 के बाद उनकी पार्सिंग को सरल बनाना चाहता हूं।

मुझे लगता है कि इस समस्या को सामान्य रूप से राज्य को अनुमति देकर हल किया जाता है, जैसे पेगासस करता है और जैसा कि #285 में सुझाया गया है। यहाँ एक विचार है (निम्नलिखित है पेगासस का महत्वपूर्ण व्हॉट्सएप व्याकरण जिसका अनुवाद पेगज में किया गया है और मेरे सिंटैक्स विचार के साथ जोड़ा गया है):

{var indentation = 0}

program
  = s:statements eof { return s }

statements
  = line+

line
  = INDENTATION s:statement { return s }

statement
  = s:simpleStatement eol { return s }
  / "if" _ n:name _? ":" eol INDENT !"bar " s:statements UNDENT {
      return { condition: n, statements: s }
    }
  / "def" _ n:name _? ":" eol INDENT s:statements UNDENT {
      return { name: n, statements: s }
    }

simpleStatement
  = a:name _? "=" _? b:name { return { lValue: a, expression: b } }

name
  = [a-zA-Z] [a-zA-Z0-9]* { return text() }

_ = [ \t]+

eol = _? comment? ("\r\n" / "\n\r" / "\r" / "\n" / eof)

comment = "//" [^\r\n]*

eof = !.

INDENTATION
  = spaces:" "* &{ return spaces.length == indentation }

INDENT
  = #STATE{indentation}{ indentation += 4 }

UNDENT
  = #STATE{indentation}{ indentation -= 4 }

नीचे के पास #STATE{indentation} ब्लॉक पर ध्यान दें (जाहिर है पेगासस से प्रेरित)। मैं उन राज्य ब्लॉकों को बुलाता हूं। विचार यह है कि कार्रवाई से पहले राज्य को ब्लॉक करने की अनुमति दी जाए। यहाँ एक अधिक जटिल राज्य ब्लॉक है:

#STATE{a, b, arr: {arr.slice()}, obj: {shallowCopy(obj)}, c}

यह इसके लिए आशुलिपि है:

#STATE{a: {a}, b: {b}, arr: {arr.slice()}, obj: {shallowCopy(obj)}, c: {c}}

दूसरे शब्दों में, शॉर्टहैंड विस्तार लागू होने के बाद, राज्य ब्लॉक की सामग्री identifier ":" "{" code "}" की एक सूची है। किसी क्रिया से पहले एक राज्य ब्लॉक जोड़ना pegjs को बताता है कि यह क्रिया सूचीबद्ध पहचानकर्ताओं को संशोधित करेगी, और यदि नियम को पीछे कर दिया जाता है तो उन पहचानकर्ताओं को ब्रेसिज़ के बीच कोड पर रीसेट कर दिया जाना चाहिए।

उपरोक्त व्याकरण से INDENT और UNDENT के लिए संकलित कार्य यहां दिए गए हैं, जिसमें indentation चर जोड़ा गया है:

    function peg$parseINDENT() {
      var s0, s1, t0;

      s0 = peg$currPos;
      t0 = indentation;
      s1 = [];
      if (s1 !== peg$FAILED) {
        peg$reportedPos = s0;
        s1 = peg$c41();
      } else {
        indentation = t0;
      }
      s0 = s1;

      return s0;
    }

    function peg$parseUNDENT() {
      var s0, s1, t0;

      s0 = peg$currPos;
      t0 = indentation;
      s1 = [];
      if (s1 !== peg$FAILED) {
        peg$reportedPos = s0;
        s1 = peg$c42();
      } else {
        indentation = t0;
      }
      s0 = s1;

      return s0;
    }

और यहां बताया गया है कि ऊपर से "जटिल राज्य ब्लॉक" को कैसे संकलित किया जा सकता है:

s0 = peg$currPos;
t0 = a;
t1 = b;
t2 = arr.slice();
t3 = shallowCopy(obj);
t4 = c;
// ...
if (s1 !== peg$FAILED) {
  // ...
} else {
  peg$currPos = s0;
  a = t0;
  b = t1;
  arr = t2;
  obj = t3;
  c = t4;
}

सक्षम होने के इस विचार के बारे में आप क्या सोचते हैं:

• pegjs को बताएं कि किसी क्रिया द्वारा कौन से स्टेटफुल वेरिएबल को संशोधित किया जाएगा।
• उन चरों को संग्रहीत करने के लिए आवश्यक कोड की आपूर्ति करें यदि उन्हें रीसेट करने की आवश्यकता है। (साधारण मामले के लिए शॉर्टहैंड सिंटैक्स सहित जहां चर एक आदिम मान है।)

और आप वाक्य रचना के बारे में क्या सोचते हैं?

संपादित करें: यहां प्रस्तावित वाक्यविन्यास व्याकरण है (केवल मनोरंजन के लिए):

diff --git a/src/parser.pegjs b/src/parser.pegjs
index 08f6c4f..09e079f 100644
--- a/src/parser.pegjs
+++ b/src/parser.pegjs
@@ -116,12 +116,31 @@ ChoiceExpression
     }

 ActionExpression
-  = expression:SequenceExpression code:(__ CodeBlock)? {
+  = expression:SequenceExpression code:((__ StateBlock)? __ CodeBlock)? {
       return code !== null
-        ? { type: "action", expression: expression, code: code[1] }
+        ? {
+            type:       "action",
+            expression: expression,
+            code:       code[2],
+            stateVars:  (code[0] !== null ? code[0][1] : [])
+          }
         : expression;
     }

+StateBlock "state block"
+  = "#STATE{" __ first:StateBlockItem rest:(__ "," __ StateBlockItem)* __ "}" {
+      return buildList(first, rest, 3);
+    }
+
+StateBlockItem
+  = varName:Identifier expression:(__ ":" __ CodeBlock)? {
+      return {
+        type:       "stateVar",
+        name:       varName,
+        expression: expression !== null ? expression[3] : varName
+      };
+    }
+
 SequenceExpression
   = first:LabeledExpression rest:(__ LabeledExpression)* {
       return rest.length > 0

हाय दोस्तों,
बस स्पष्ट करने के लिए, क्या मैं सही हूं कि इस मुद्दे के बंद होने तक इंडेंटेशन-आधारित भाषाओं के साथ PEG.js (इस मुद्दे के शीर्ष से वर्कअराउंड के साथ) का उपयोग नहीं करना बेहतर है?
धन्यवाद।

@ होहो मैं आपको अर्थ नहीं जैसे पार्सर कॉम्बिनेटर के साथ इंडेंटेशन को

मेरा मतलब है कि इंडेंटेशन को पार्स करने के लिए वर्कअराउंड हैं, लेकिन टिप्पणियों का कहना है कि कुछ निश्चित मामलों में ये वर्कअराउंड विफल हो जाएंगे।

मुझे स्थिति स्पष्ट करने दें: PEG.js में इंडेंटेशन-आधारित भाषाओं को पार्स करना संभव है। ऊपर वर्णित विभिन्न समाधान हैं और मैंने अभी एक और बनाया है क्योंकि मैंने इसके लिए "महसूस" करने की कोशिश की है (यह दो बयानों के साथ एक साधारण भाषा का व्याकरण है, जिनमें से एक में इंडेंट उप-कथन हो सकते हैं - उदाहरण के लिए if पायथन में)।

सभी समाधानों में एक सामान्य बात यह है कि उन्हें इंडेंटेशन स्थिति को मैन्युअल रूप से ट्रैक करने की आवश्यकता होती है (क्योंकि PEG.js ऐसा नहीं कर सकते हैं)। इसका मतलब है कि दो सीमाएँ हैं:

1. आप व्याकरण को सुरक्षित रूप से कैशिंग के साथ संकलित नहीं कर सकते (क्योंकि पार्सर राज्य-हेरफेर कोड निष्पादित करने के बजाय कैश किए गए परिणामों का उपयोग कर सकता है)।
2. आप इंडेंटेशन स्तरों पर बैकट्रैक नहीं कर सकते (क्योंकि वर्तमान में बैकट्रैकिंग करते समय राज्य को अनियंत्रित करने का कोई तरीका नहीं है)। दूसरे शब्दों में, आप ऐसी भाषा का विश्लेषण नहीं कर सकते हैं जहां दो मान्य संरचनाएं हैं जिन्हें केवल एक नई लाइन और इंडेंटेशन स्तर परिवर्तन के बाद ही स्पष्ट किया जा सकता है।

सीमा 1 कुछ मामलों में प्रदर्शन के मुद्दों का कारण बन सकती है, लेकिन मुझे नहीं लगता कि ऐसी कई भाषाएं हैं जिनके लिए सीमा 2 एक समस्या होगी।

मैं 1.0.0 तक इस स्थिति के साथ ठीक हूं और मेरी योजना कुछ समय बाद इस विषय पर वापस जाने की है। सुधार का पहला स्तर अधिक स्पष्ट राज्य ट्रैकिंग (जैसा कि ऊपर सुझाया गया है) का उपयोग करके या बैकट्रैकिंग हुक प्रदान करके सीमा 2 से छुटकारा पाना हो सकता है (ताकि कोई राज्य को सही ढंग से अनियंत्रित कर सके)। दूसरा स्तर ऐसा करने के लिए कुछ घोषणात्मक तरीका प्रदान करके इंडेंटेशन स्थिति को मैन्युअल रूप से ट्रैक करने की आवश्यकता से छुटकारा पा सकता है। यह सीमा 1 के साथ मदद कर सकता है।

एच, मैंने पीईजी.जेएस के लिए एक (छोटा, हैकी) पैच लिखा है जो उचित बैकट्रैकिंग का समर्थन करता है, जैसा कि मैंने यहां बताया: https://github.com/pegjs/pegjs/issues/45

टक्कर के लिए खेद है

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

1) पुश/पॉप राज्य पर निर्भर नहीं है
2) कार्यों के भीतर कोड के माध्यम से इंडेंट स्तर पर जोर देना

यह मेरे साथ हुआ था कि उपरोक्त 2 समाधानों में से कोई भी वास्तव में जेनरेट किए गए पार्सर्स में प्रदर्शन समस्याओं को जोड़ता है। इसके अतिरिक्त मेरी राय में:

1) राज्य के भरोसे न केवल एक बदसूरत PEG.js सिंटैक्स जोड़ता है बल्कि यह भी प्रभावित कर सकता है कि किस प्रकार के पार्सर उत्पन्न किए जा सकते हैं क्योंकि उन्हें कार्रवाई आधारित राज्य सौंपने का समर्थन करने की आवश्यकता होगी।
2) कभी-कभी क्रियाओं में कुछ कोड जोड़ने से भाषा पर निर्भर नियम बनता है, और कुछ डेवलपर्स के लिए इसका मतलब है कि वे नियमों पर क्रियाओं को संभालने के लिए अधिक प्लगइन का सहारा लिए बिना सी या पीएचपी जैसी अन्य भाषाओं के लिए पार्सर उत्पन्न करने के लिए प्लगइन का उपयोग नहीं कर सकते हैं, जो सिर्फ मतलब सिर्फ 1 या 2 परिवर्तनों का समर्थन करने के लिए एक बड़ी बिल्ड सिस्टम।

थोड़ी देर बाद मैंने पीईजी.जेएस पार्सर का अपना खुद का संस्करण बनाने के बारे में सोचा और सोचा: क्यों न केवल वेतन वृद्धि ("++") और कमी ("--") उपसर्ग ऑपरेटरों (__++ अभिव्यक्ति__ और __-- अभिव्यक्ति__ का उपयोग करें) ) मैच एक्सप्रेशन (__एक्सप्रेशन *__ या __एक्सप्रेशन +__) के परिणामों को संभालने के लिए।

निम्नलिखित एक उदाहरण व्याकरण है जो @dmajda की सरल आशय-आधारित भाषा पर आधारित है , जिसे __& {predicate }__ के बजाय नई __++ अभिव्यक्ति__ और __-- अभिव्यक्ति__ का उपयोग करने के लिए फिर से लिखा गया है:

Start
  = Statements

Statements
  = Statement*

Statement
  = Indent* statement:(S / I) { return statement; }

S
  = "S" EOS {
      return "S";
    }

I
  = "I" EOL ++Indent statements:Statements --Indent { return statements; }
  / "I" EOS { return []; }

Indent "indent"
  = "\t"
 / !__ "  "

__ "white space"
 = " \t"
 / " "

EOS
  = EOL
  / EOF

EOL
  = "\n"

EOF
  = !.

आंख को ज्यादा भाता है, नहीं? समझने में भी आसान, इंसानों और सॉफ्टवेयर दोनों के लिए।

यह कैसे काम करता है? सरल:

1) Indent* पार्सर को बताता है कि हम जो Indent लौट रहे हैं उसमें से 0 या अधिक चाहते हैं
2) ++Indent पार्सर को Indent लिए आवश्यक न्यूनतम मैचों की मात्रा बढ़ाने के लिए कहता है
3) अब जब भी पार्सर Indent लिए मैचों को वापस करने वाला है, तो यह पहले __1 और __ मैच होने की उम्मीद करता है, अन्यथा _peg$SyntaxError_ फेंक दिया जाता है।
4) --Indent पार्सर को Indent लिए आवश्यक न्यूनतम मैचों की मात्रा को कम करने के लिए कहता है
5) अब किसी भी समय पार्सर Indent और उन मैचों को लौटाता है जिनकी वह __1 कम __ मैच की अपेक्षा करता है, अन्यथा _peg$SyntaxError_ फेंक दिया जाता है।

यह समाधान PEG.js व्याकरण में एक बदसूरत सिंटैक्स जोड़े बिना या तृतीय पक्ष जनरेटर को अवरुद्ध किए बिना 'महत्वपूर्ण व्हाइटस्पेस पार्सिंग' के लिए समर्थन जोड़ने का सबसे अच्छा तरीका है।

इसे _src/parser.pegjs_ में पार्स करने के लिए समर्थन जोड़ने के लिए बदले गए नियम यहां दिए गए हैं:

{
  const OPS_TO_PREFIXED_TYPES = {
    "$": "text",
    "&": "simple_and",
    "!": "simple_not",
    "++": "increment_match",
    "--": "decrement_match"
  };
}

PrefixedOperator
  = "$"
  / "&"
  / "!"
  / "++"
  / "--"

SuffixedOperator
  = "?"
  / "*"
  / "+" !"+"

क्या मुझे यह मानने का अधिकार है कि इसे कंपाइलर/जनरेटर पक्ष का समर्थन करने के लिए हमें यह करना होगा:

1) एक कंपाइलर पास जोड़ें जो सुनिश्चित करता है कि __++ अभिव्यक्ति__ या __-- अभिव्यक्ति__ का उपयोग केवल __अभिव्यक्ति *__ या __अभिव्यक्ति +__ पर किया जा रहा है, जहां __अभिव्यक्ति__ प्रकार के होने चाहिए: पसंद, अनुक्रम या नियम_रेफ
2) __एक्सप्रेशन *__ या __एक्सप्रेशन +__ के लिए जेनरेट किए गए पार्सर में कैश आधारित चेक जोड़ें जो दावा करता है कि मैचों को वापस करने से पहले न्यूनतम आवश्यक मैच पूरा हो गया है
3) वैकल्पिक रूप से जेनरेट किए गए पार्सर्स के लिए एक सहायक विधि जोड़ें जो किसी दिए गए नियम के लिए आवश्यक मैचों की संख्या लौटाता है, उदाहरण के लिए। nMatches( name: String ): Number

@futagoza , यह साफ और चालाक है। मुझें यह पसंद है। मैं एक ऐसे पार्सर पर काम कर रहा हूं जो राज्य को संभालता है, लेकिन एकमात्र राज्य जिसकी हमें वास्तव में आवश्यकता है वह है इंडेंटेशन स्तर। मैं इस विचार का उपयोग कर सकता हूं और आपको इसका श्रेय दे सकता हूं। इंडेंटेशन स्तर को ट्रैक करने के लिए अभी भी प्रभावी ढंग से पुश/पॉपिंग स्टेट की आवश्यकता होती है और इसलिए यह अभी भी कुछ अनुकूलन को रोक सकता है लेकिन इसके अर्थशास्त्र बहुत अच्छे हैं।

यदि आप किसी व्याकरण में ऑपरेटर जोड़ रहे हैं, तो मेरा सुझाव है कि @ उपसर्ग ऑपरेटर भी जोड़ें। इसका उद्देश्य अनुक्रम से केवल एक नियम परिणाम निकालना है। इसके प्रयोग से नमूना व्याकरण और भी साफ हो जाता है। कोई और अधिक तुच्छ {वापसी x} क्रियाएँ नहीं।

Start
  = Statements

Statements
  = Statement*

Statement
  = Indent* @(S / I)

S
  = "S" EOS {
      return "S";
    }

I
  = "I" EOL ++Indent <strong i="8">@Statements</strong> --Indent
  / "I" EOS { return []; }

Indent "indent"
  = "\t"
 / !__ "  "

__ "white space"
 = " \t"
 / " "

EOS
  = EOL
  / EOF

EOL
  = "\n"

EOF
  = !.

@kodyjking आप इस बारे में क्या सोचते हैं?

@futagoza क्या आपके पास इंडेंटेशन पैच सक्षम और एक छोटा नमूना व्याकरण वाला कांटा/शाखा है?

मैं इस कांटा/शाखा इंडेंटेशन पर काम कर रहा हूँ

@krinye "मैं @ उपसर्ग ऑपरेटर को भी जोड़ने की सलाह देता हूं। इसका उद्देश्य अनुक्रम से केवल एक नियम परिणाम निकालना है"

क्या आप में से कोई एक देख सकता है और फिक्स के साथ टिप्पणी या पीआर बना सकता है। धन्यवाद :)

रीडमी: कांटा परिवर्तन

मैंने डिबग किया... वेतन वृद्धि_मैच

आह, चेतावनी पर ध्यान नहीं दिया:

क्या मुझे यह मानने का अधिकार है कि इसे कंपाइलर/जनरेटर पक्ष का समर्थन करने के लिए हमें यह करना होगा:

• एक कंपाइलर पास जोड़ें जो सुनिश्चित करता है कि ++ अभिव्यक्ति या - अभिव्यक्ति केवल अभिव्यक्ति * या अभिव्यक्ति + पर उपयोग की जा रही है, जहां अभिव्यक्ति प्रकार की होनी चाहिए: पसंद, अनुक्रम या नियम_रेफ
• अभिव्यक्ति * या अभिव्यक्ति + के लिए जेनरेट किए गए पार्सर में कैश आधारित चेक जोड़ें जो दावा करता है कि मैचों को वापस करने से पहले न्यूनतम आवश्यक मिलान पूरा हो गया है
• वैकल्पिक रूप से जेनरेट किए गए पार्सर्स को लागू करने के लिए एक सहायक विधि जोड़ें जो किसी दिए गए नियम के लिए आवश्यक मैचों की संख्या लौटाता है, उदाहरण के लिए। nMatches (नाम: स्ट्रिंग): संख्या:

केवल किक के लिए, मैंने इसे visitor.js में जोड़ने का प्रयास किया

      increment_match: visitExpression,
      decrement_match: visitExpression,

अब मुझे Invalid opcode: undefined.

@kristianmandrup @ ऑपरेटर से संबंधित अनुक्रमों से एकल मान निकालने के लिए, मेरे पास केवल उस सुविधा के साथ एक कांटा है जो यहां उपलब्ध PegJS में जोड़ा गया है:

https://github.com/krisnye/pegjs

यह एक बहुत ही सरल जोड़ है।

व्याकरण आधारित कार्यान्वयन के लिए @krisnye +1, अच्छा और सरल। अगर आपको कोई आपत्ति नहीं है, तो मैं इसे PEG.js के अपने संस्करण में जोड़ दूंगा

@kristianmandrup देखें कि आप मेरे सुझाव के लिए प्रतिबद्ध हैं

@futagoza कृपया करें।

मैं एक सहकर्मी के साथ इंडेंटेशन लॉजिक पर चर्चा कर रहा था और हम निम्नलिखित वाक्यात्मक तत्वों का सुझाव देते हैं:

// नामित राज्य चर को बढ़ाता है
पहचानकर्ता++
// नामित राज्य चर को घटाता है
पहचानकर्ता--

// निरंतर राशि या राज्य चर दोहराएं (यदि चर अभी तक वृद्धि नहीं हुई है तो डिफ़ॉल्ट शून्य के साथ)
नियम {पूर्णांक | पहचानकर्ता}
// स्थिरांक या राज्य चर का उपयोग करके न्यूनतम / अधिकतम दोहराएं
नियम {पूर्णांक | पहचानकर्ता, पूर्णांक | पहचानकर्ता}

हम जिस पार्सर पर काम कर रहे हैं, वह मनमानी स्थिति को संभाल सकता है, लेकिन ईमानदारी से, उपरोक्त वह सब है जो इंडेंटेशन पार्सिंग के लिए आवश्यक है।

बहुत बहुत धन्यवाद दोस्तों! यदि ऐसा करना इतना आसान है, तो "समर्पित" कांटा क्यों न बनाएं जहां आप जिन चीजों का उल्लेख करते हैं "बस काम करता है";)
चीयर्स!

@krisnye

1. __identifier++__ का उपयोग करना आसानी से एक गड़बड़ त्रुटि का कारण बन सकता है यदि डेवलपर का अर्थ __identifier+__ है, इसलिए मैंने __++पहचानकर्ता__ के साथ जाना चुना और, स्थिरता के लिए, __--identifier__
2. जैसा कि श्रेणियों के बारे में एक अलग मुद्दे में बताया गया है, rule{ STATE_REPEAT / RANGE } को rule{ ACTION } साथ भ्रमित किया जा सकता है, खासकर यदि आप पीईजी.जेएस के लिए सिंटैक्स हाइलाइटर बना रहे हैं, तो इस दृष्टिकोण को @dmajda द्वारा अस्वीकार कर दिया गया है

@kristianmandrup _(OFF TOPIC)_ मैं सुविधाओं को डिजाइन करने और कभी-कभी कार्यान्वयन करने में अच्छा हूं, लेकिन परीक्षण और बेंचमार्किंग में भयानक हूं, इसलिए आमतौर पर मैं अपने पीसी पर निजी गैर-रेपो निर्देशिकाओं में काम करने वाले वेरिएंट (बिना किसी परीक्षण या बेंचमार्क के) बनाता हूं। , और फिर उनके बारे में भूल जाओ । PEG.js के मेरे वर्तमान संस्करण के लिए (नाम ePEG.js , PEG.js का एक विस्तारित पुनर्लेखन) मैं यहां उल्लिखित सामग्री के साथ-साथ अन्य सुविधाओं (श्रेणियों, आयात, टेम्प्लेट, आदि) को जोड़ रहा हूं, इसलिए मैं जोड़ रहा हूं परीक्षण और बेंचमार्क, लेकिन मैं वर्तमान में एक सी ++ प्रोजेक्ट पर भी काम कर रहा हूं जिसमें मेरा समय लग रहा है, इसलिए उस पर कोई ईटीए नहीं है।

@futagoza धन्यवाद दोस्त :) फीचर एक्सटेंशन को देखते हुए, लेकिन इंडेंटेशन सपोर्ट का उल्लेख नहीं करता है। क्या इसमें शामिल है लेकिन अनिर्दिष्ट है या सड़क पर आ रहा है?

इस सूची में से किसी और ने मुझे अन्य पार्सर बिल्डर/जनरेटर समाधानों की ओर इशारा किया, जिन्हें मैं भी देख सकता हूं। मुझे तैनात रखें! चीयर्स!

@kristianmandrup यह जहाँ तक मैं बता सकता है शामिल नहीं है, लेकिन @dmajda 3 साल पहले कहा था कि वह PEG.js v1 रिहा होने के बाद इस पर गौर करेंगे, लेकिन मैं क्या कहता हूँ कि, एक और 2 साल के लिए हो सकता है नहीं होते जब तक कि वह करने की योजना कर सकते हैं से PEG.js v0 (_0.12_, _0.13_, _etc_) के और छोटे संस्करण जारी करें

मेरा मतलब था कि अगर आपने पहले से ही ईपीईजी में या रोडमैप पर इंडेंटेशन सपोर्ट शामिल किया था?

@kristianmandrup ओह , यह रोडमैप पर है। मैंने कुछ समय के लिए ePEG.js रेपो को अपडेट नहीं किया है, और अभी हाल ही में इसे प्लग इन के बजाय PEG.js के पूर्ण पुनर्लेखन में बदलने का निर्णय लिया है।

@futagoza पूर्व संचालन के रूप में ++/- पर सहमत हुआ, और मैं क्रिया वाक्यविन्यास के बारे में भूल गया, हमने इसे [न्यूनतम, अधिकतम] में बदल दिया

इसलिए

++identifier
--identifier
rule[integer | identifier]
rule[integer | identifier, integer | identifier]

@krisnye [ ... ] चरित्र वर्गों के लिए प्रयोग किया जाता है, देखें https://github.com/pegjs/pegjs#characters

मैं ePEG.js में जो कर रहा हूं वह आपके द्वारा वर्णित किए गए कार्यों को प्राप्त करने के लिए श्रेणियां (रोडमैप पर भी) जोड़ रहा है:

space = [ \t]*
rule = range|expression

• __अभिव्यक्ति__ इनमें से कोई भी हो सकता है: __++स्पेस__, __--स्पेस__ या __स्पेस__
• __रेंज__ __ min.. __, __ min..max __, __ ..max __ या __ exact __ हो सकता है
• __min__, __max__ या __exact__ केवल एक __अहस्ताक्षरित पूर्णांक__ हो सकता है
• __अभिव्यक्ति__ (जैसे 2|अभिव्यक्ति) के साथ __रेंज__ का उपयोग करने से हम __rule__ को सफलतापूर्वक पार्स करने के लिए आवश्यक __अभिव्यक्ति__ की कुल राशि निर्धारित कर सकते हैं।
• __सटीक__ श्रेणी का उपयोग __++अभिव्यक्ति__ या __--अभिव्यक्ति__ (जैसे 3|++अभिव्यक्ति) के साथ करने से हमें __++__ या __--__ के लिए __integer__ राशि निर्धारित करने की अनुमति मिल सकती है, जो डिफ़ॉल्ट रूप से __1__ है।
• या तो __min__ या __max__ श्रेणी का __++ अभिव्यक्ति__ या __--अभिव्यक्ति__ के साथ उपयोग करने से सिंटैक्स त्रुटि उत्पन्न होती है।

मैं राज्य चर का उपयोग नहीं कर रहा हूं क्योंकि यह केवल नियम पहचानकर्ताओं के साथ भ्रमित करने वाला होगा।

__range__, __++__, __--__ या __ @__ के संयोजन का उपयोग करके मैं पीईजी व्याकरण फाइलें बनाने की उम्मीद कर रहा हूं जो उनके परिणाम के लिए नियमों __action__ पर कम भरोसा करते हैं, जिससे व्हाइटस्पेस के विकास समय में वृद्धि होनी चाहिए (उदाहरण के लिए इंडेंटेशन -आधारित, ASCII कला, आदि) भाषाओं के रूप में भाषा डिजाइनरों और/या कार्यान्वयनकर्ताओं को यह पुष्टि करने की कोशिश करने के बारे में चिंता करने की ज़रूरत नहीं है कि क्या व्हाइटस्पेस की सही मात्रा को पार्स किया गया है।
इससे प्लगइन डेवलपर्स को पार्सर जेनरेटर बनाने की भी अनुमति मिलनी चाहिए जो हमारी __action__ की भाषा के _less डर_ के साथ अनुकूलित कर सकते हैं (डिफ़ॉल्ट रूप से जावास्क्रिप्ट, लेकिन प्लगइन के साथ इसे कॉफीस्क्रिप्ट, पीएचपी, आदि में बदल सकते हैं)।

तो ऐसा लगता है कि बॉक्स के बाहर PEG.js के साथ पायथन को पार्स करना आज भी संभव नहीं है, है ना?

यदि नहीं, तो क्या यह कुछ ऐसा है जो जल्द ही आने वाला है? क्या इस कार्य को करने के लिए आवश्यक कार्यों का एक समूह है जिसमें लोग योगदान दे सकते हैं?

मेरे पास एक प्रोजेक्ट है जहां मैं जेएस में पायथन एएसटी प्राप्त करने में सक्षम होना चाहता हूं, इसे संशोधित करता हूं और फिर इसे उसी स्वरूपण के साथ स्रोत कोड में परिवर्तित करता हूं, इसलिए यदि कोई स्पष्ट है तो मुझे ऐसा करने में दिलचस्पी होगी रोडमैप

@mindjuice अभी नहीं, यह पोस्ट 1.0 के लिए योजनाबद्ध है।

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

https://github.com/krisnye/pegs

आप शेवरोटेन जैसे समर्थन के साथ एक और पार्सर जनरेटर भी आज़मा सकते हैं

पायथन इंडेंटेशन उदाहरण

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

{
    let prevIndentCount = 0;
    function print(...s) { console.log(...s); }
}

Indent 'indent'
    = i:("    "+) { 
        let currentIndentCount = i.toString().replace(/,/g, "").length;
        if (currentIndentCount === prevIndentCount + 4) { 
            // DEBUG //
            print("=== Indent ===");
            print("    current:"+currentIndentCount); 
            print("    previous:"+prevIndentCount);
            print("    lineNumber:"+location().start.line); 
            // DEBUG //
            prevIndentCount += 4;
            return "[indent]";
        }
        error("error: expected a 4-space indentation here!")
    } // 4 spaces 

Samedent 'samedent'
    = s:("    "+ / "") &{
        let currentIndentCount = s.toString().replace(/,/g, "").length;
        if (currentIndentCount === prevIndentCount) {
            print("=== Samedent ===");
            return true;
        }
        return false;
    }

Dedent 'dedent'
    = d:("    "+ / "") {
        let currentIndentCount = d.toString().replace(/,/g, "").length;
        if (currentIndentCount < prevIndentCount) {
            // DEBUG //
            print("=== Dedent ===");
            print("    current:"+currentIndentCount); 
            print("    previous:"+prevIndentCount);
            print("    lineNumber:"+location().start.line); 
            // DEBUG //
            prevIndentCount -= 4;
            return "[dedent]";
        }
        error("error: expected a 4-space dedentation here!");
    }

उपरोक्त व्याकरण के साथ, आप इस तरह एक इंडेंट ब्लॉक नियम बना सकते हैं:

FunctionDeclaration 
    = 'function' _ Identifier _ FunctionParameterSection _ ":" _ FunctionBody

FunctionBody
    = Newline Indent FunctionSourceCode (Newline Samedent FunctionSourceCode)* Dedent