बाइसन और फ्लेक्स के साथ ब्लॉक डिलीमीटर के रूप में इंडेंटेशन का उपयोग कैसे करें

Question

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

मैंने सी में पहले से ही एक कंपाइलर लिखा है (वास्तव में 'langToy' नासम अनुवादक), लेकिन असफल रहा। किसी कारण से यह केवल संपूर्ण स्रोत फ़ाइल में एक स्ट्रिंग को संभालने में सक्षम था (ठीक है, मैं 48 घंटे से अधिक समय तक जाग रहा था - इसलिए ... आप जानते हैं, मस्तिष्क मंदी)।

मुझे नहीं पता कि घुंघराले ब्रैकेट और/या शुरू -> अंत को कार्यान्वित करना आसान है (मुझे ऐसा करने में समस्या नहीं है) या यदि यह मेरा दिमाग है जो ताला लगा है।

अग्रिम धन्यवाद!

---

अद्यतन: ठीक है, मैं कैसे फ्लेक्स के साथ यह करने के लिए के बारे में कोई सुराग नहीं है। मुझे पार्सर में कई डीडेंट्स लौटने में समस्याएं हैं। फ्लेक्स/बाइसन मेरे लिए अपेक्षाकृत नए हैं।

---

अद्यतन 2: यह फ्लेक्स फ़ाइल मैं अब तक के साथ आ गया है; यह काफी यह नहीं मिलता है:

%x t 
%option noyywrap 

%{ 
    int lineno = 0, ntab = 0, ltab = 0, dedent = 0; 
%} 

%% 

<*>\n { ntab = 0; BEGIN(t); } 
<t>\t { ++ntab; } 
<t>. { int i; /* my compiler complains not c99 if i use for(int i=0... */ 
     if(ntab > ltab) 
      printf("> indent >\n"); 
     else if(ntab < ltab) 
      for(i = 0; i < ltab - ntab; i++) 
      printf("< dedent <\n"); 
     else 
      printf("=  =\n"); 

     ltab = ntab; ntab = 0; 
     BEGIN(INITIAL); 
     /* move to next rule */ 
     REJECT;} 
. /* ignore everything else for now */ 

%% 

main() 
{ 
    yyin = fopen("test", "r"); 
    yylex(); 
} 

आप इसे के साथ चारों ओर खेलने की कोशिश कर सकते हैं, हो सकता है आप को देखता है मैं क्या याद कर रहा हूँ। कई समर्पण लौटने से हेक्से में आसानी होगी (वापसी t_dedent (num);)।

यह कोड हमेशा इंडेंट/समर्पण से मेल नहीं खाता है।

---

अद्यतन 3: मुझे लगता है कि मैं फ्लेक्स पर उम्मीद छोड़ दे देंगे और यह अपने तरीके से करते हैं, किसी को भी जानता है कि कैसे फ्लेक्स में यह करने के लिए मैं इसे वैसे भी सुन कर खुशी होगी।

Answer 1

आपको क्या करना है, प्रत्येक पंक्ति की शुरुआत में व्हाइटस्पेस की मात्रा को फ्लेक्स गिनती है और समूह की चीजों के उपयोग के लिए पार्सर के लिए उचित संख्या में इंडेंट/यूनिवर्सेंट टोकन डालें।एक प्रश्न यह है कि आप टैब्स बनाम रिक्त स्थान के बारे में क्या करना चाहते हैं - क्या आप बस उन्हें निश्चित टैब स्टॉप के बराबर होना चाहते हैं, या आप लगातार होने के लिए इंडेंटिंग की आवश्यकता चाहते हैं (इसलिए यदि एक पंक्ति एक टैब और अगले के साथ शुरू होती है एक स्थान के साथ, आप एक त्रुटि संकेत करते हैं, जो शायद थोड़ा कठिन है)।

मान लिया जाये कि आप निश्चित 8-स्तंभ tabstops, आप आप सुनिश्चित करें कि आप मांगपत्र मोड में पार्स शुरू बनाने के लिए क्या है की तरह

%{ 
/* globals to track current indentation */ 
int current_line_indent = 0; /* indentation of the current line */ 
int indent_level = 0;   /* indentation level passed to the parser */ 
%} 

%x indent /* start state for parsing the indentation */ 
%s normal /* normal start state for everything else */ 

%% 
<indent>" "  { current_line_indent++; } 
<indent>"\t"  { current_line_indent = (current_line_indent + 8) & ~7; } 
<indent>"\n"  { current_line_indent = 0; /*ignoring blank line */ } 
<indent>.  { 
        unput(*yytext); 
        if (current_line_indent > indent_level) { 
         indent_level++; 
         return INDENT; 
        } else if (current_line_indent < indent_level) { 
         indent_level--; 
         return UNINDENT; 
        } else { 
         BEGIN normal; 
        } 
       } 

<normal>"\n"  { current_line_indent = 0; BEGIN indent; } 
... other flex rules ... 

कुछ का उपयोग करें (पहली पंक्ति पर खरोज प्राप्त करने के लिए) कर सकते हैं।

Answer 2

घुंघराले ब्रैकेट (और ऐसे) केवल सरल होते हैं यदि आप एक टोकनज़र का उपयोग करते हैं जो सभी सफेद जगहों को स्ट्रिप्स करता है (केवल टोकन को अलग करने के लिए)। पाइथन टोकनिंग पर कुछ विचारों के लिए this page देखें (अनुभाग "संकलक कैसे इंडेंटेशन पार्स करता है?")।

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

Answer 3

आप एक नियम है कि इस के अनुरूप लग रहा है की जरूरत है (मान आप अपने इंडेंट के लिए टैब का उपयोग):

\ t: {वापसी TABDENT; }

सच कहूं, मैं हमेशा पाया ब्रेसिज़ है (या शुरू/अंत) लिखने के लिए और दोनों एक मानव के रूप में और एक lexer/पार्सर लेखक के रूप में, पढ़ने में आसान हो सकता है।

Answer 4

क्रिस का जवाब उपयोग करने योग्य समाधान की ओर एक लंबा रास्ता तय करता है, इसके लिए एक गुच्छा धन्यवाद! दुर्भाग्य से, यह कुछ और महत्वपूर्ण पहलुओं जो मैं जरूरत याद आ रही है: एक बार में

• एकाधिक outdents (unindents)। पर विचार करें निम्नलिखित कोड baz करने के लिए कॉल के बाद दो outdents फेंकना चाहिए:

  def foo(): 
      if bar: 
      baz() 
  

• उत्सर्जन outdents जब फ़ाइल के अंत तक पहुँच जाता है और अभी भी कुछ खरोज स्तर में है।

• विभिन्न आकार के इंडेंटेशन स्तर। क्रिस 'वर्तमान कोड केवल 1-स्पेस इंडेंट्स के लिए सही तरीके से काम करता है।

क्रिस कोड के आधार पर, मैं एक ऐसे समाधान के साथ आया जो अब तक के सभी मामलों में काम करता है। मैंने जिथब पर फ्लेक्स (और बाइसन) का उपयोग करके इंडेंटेशन-आधारित टेक्स्ट को पार्स करने के लिए एक टेम्पलेट प्रोजेक्ट बनाया है: https://github.com/lucasb-eyer/flex-bison-indentation। यह एक पूरी तरह से काम कर रहा है (सीएमके-आधारित) प्रोजेक्ट जो लाइन टोकन और वर्तमान टोकन की कॉलम रेंज को ट्रैक करता है।

शायद ज़रुरत पड़े लिंक, किसी भी कारण का विश्लेषण करना चाहिए यहाँ lexer का मांस है:

#include <stack> 

int g_current_line_indent = 0; 
std::stack<size_t> g_indent_levels; 
int g_is_fake_outdent_symbol = 0; 

static const unsigned int TAB_WIDTH = 2; 

#define YY_USER_INIT { \ 
    g_indent_levels.push(0); \ 
    BEGIN(initial); \ 
} 
#include "parser.hh" 

%} 

%x initial 
%x indent 
%s normal 

%% 
    int indent_caller = normal; 

/* Everything runs in the <normal> mode and enters the <indent> mode 
    when a newline symbol is encountered. 
    There is no newline symbol before the first line, so we need to go 
    into the <indent> mode by hand there. 
*/ 
<initial>. { set_yycolumn(yycolumn-1); indent_caller = normal; yyless(0); BEGIN(indent); } 
<initial>\n { indent_caller = normal; yyless(0); BEGIN(indent); }  

<indent>" "  { g_current_line_indent++; } 
<indent>\t  { g_current_line_indent = (g_current_line_indent + TAB_WIDTH) & ~(TAB_WIDTH-1); } 
<indent>\n  { g_current_line_indent = 0; /* ignoring blank line */ } 
<indent><<EOF>> { 
        // When encountering the end of file, we want to emit an 
        // outdent for all indents currently left. 
        if(g_indent_levels.top() != 0) { 
         g_indent_levels.pop(); 

         // See the same code below (<indent>.) for a rationale. 
         if(g_current_line_indent != g_indent_levels.top()) { 
          unput('\n'); 
          for(size_t i = 0 ; i < g_indent_levels.top() ; ++i) { 
           unput(' '); 
          } 
         } else { 
          BEGIN(indent_caller); 
         } 

         return TOK_OUTDENT; 
        } else { 
         yyterminate(); 
        } 
       } 

<indent>.  { 
        if(!g_is_fake_outdent_symbol) { 
         unput(*yytext); 
        } 
        g_is_fake_outdent_symbol = 0; 
        // -2: -1 for putting it back and -1 for ending at the last space. 
        set_yycolumn(yycolumn-1); 

        // Indentation level has increased. It can only ever 
        // increase by one level at a time. Remember how many 
        // spaces this level has and emit an indentation token. 
        if(g_current_line_indent > g_indent_levels.top()) { 
         g_indent_levels.push(g_current_line_indent); 
         BEGIN(indent_caller); 
         return TOK_INDENT; 
        } else if(g_current_line_indent < g_indent_levels.top()) { 
         // Outdenting is the most difficult, as we might need to 
         // outdent multiple times at once, but flex doesn't allow 
         // emitting multiple tokens at once! So we fake this by 
         // 'unput'ting fake lines which will give us the next 
         // outdent. 
         g_indent_levels.pop(); 

         if(g_current_line_indent != g_indent_levels.top()) { 
          // Unput the rest of the current line, including the newline. 
          // We want to keep it untouched. 
          for(size_t i = 0 ; i < g_current_line_indent ; ++i) { 
           unput(' '); 
          } 
          unput('\n'); 
          // Now, insert a fake character indented just so 
          // that we get a correct outdent the next time. 
          unput('.'); 
          // Though we need to remember that it's a fake one 
          // so we can ignore the symbol. 
          g_is_fake_outdent_symbol = 1; 
          for(size_t i = 0 ; i < g_indent_levels.top() ; ++i) { 
           unput(' '); 
          } 
          unput('\n'); 
         } else { 
          BEGIN(indent_caller); 
         } 

         return TOK_OUTDENT; 
        } else { 
         // No change in indentation, not much to do here... 
         BEGIN(indent_caller); 
        } 
       } 

<normal>\n { g_current_line_indent = 0; indent_caller = YY_START; BEGIN(indent); }