पार्सिंग कैरेक्टर सिंटैक्स आरेख पर विचार

Question

लोग मैं एक अजीब चीज को लागू कर रहा हूं, मुझे सादे पाठ प्रारूप में सिंटैक्स आरेख को पार्स करने और इसे XML प्रारूप में बदलने के लिए उपयोगिता लिखनी है, यह मूल रूप से आईबीएम से समान है (जैसे "नो-कनवर्ज़न जॉब बनाना" भाग में): http://publib.boulder.ibm.com/infocenter/idshelp/v10/index.jsp?topic=/com.ibm.sqls.doc/sqls17.htm एंटएलआर/वाईएसी/बाइसन जैसे विशिष्ट पार्सर/लेक्सर इस तरह की चीजों से निपट नहीं सकते हैं, एक विचार है कि मेरे पास सिंटैक्स आरेख को किसी चरित्र में परिवर्तित करना है बिटमैप और समझने की प्रक्रिया को मानव नग्न आंख के रूप में अनुकरण करने के लिए पूरे आरेख को पार करने के लिए more_up, move_down, left, right या so जैसे कुछ फ़ंक्शन को परिभाषित करें। यह पर्याप्त कुशल नहीं लगता है, मुझे अन्य बेहतर दृष्टिकोण नहीं पता था। क्या कोई भी एक बार इसी तरह के परिदृश्य के साथ खेलता था? शायद आप इस पर कुछ प्रकाश डाल सकते हैं।

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

Answer 1

एकल वर्णों तक पहुंचने के लिए "चरित्र ग्रिड" विचार नींव चरण की तरह लगता है; एक और जवाब दिखाता है कि यह कैसे ठीक है। अब आप ग्रिड को यादृच्छिक रूप से एक्सेस कर सकते हैं और आसानी से क्षैतिज या लंबवत रेखाओं का पालन कर सकते हैं।

वास्तविक समस्या यह है कि आप ग्राफ ग्रिड का प्रतिनिधित्व करने वाले ग्राफ का निर्माण करना चाहते हैं। इस तरह के ग्राफ में (डुह), नोड्स, आर्क, और एनोटेशन शामिल होंगे।

संभावित रूप से ढूंढने की सबसे आसान चीज़ नोड्स हैं, जो चित्र में शाखाओं के बिंदुओं का प्रतिनिधित्व करने वाले वर्णों द्वारा संकेतित (अन्य उत्तर देखें) (उदा। +) हैं। प्रत्येक चाप चाप में एक मोड़, या किसी अन्य नोड के लिए अग्रणी characaters की एक स्ट्रिंग होगी। पात्रों के इस तरह के तारों के बाद सुंदर straighforward (:-)) होना चाहिए और चाप का प्रतिनिधित्व करने वाली एक स्ट्रिंग का उत्पादन कर सकते हैं भले ही इसमें झुकता हो।

आप संभवतः सभी नोड्स (केवल सरणी स्कैन करें) की गणना करना चाहते हैं। नोड एनोटेशन उचित रूप से पास होना चाहिए और आप नोड स्थानों के आस-पास एक छोटे से क्रूर को स्कैन कर सकते हैं।

आप प्रत्येक चाप को नोड छोड़कर गणना करना चाहते हैं, और चाप का प्रतिनिधित्व करने वाली स्ट्रिंग एकत्र करना चाहते हैं।

मैं इसे अलग करने के लिए आर्क लेयर को लेक्सर को खिलाऊंगा; इसमें दिलचस्प सामग्री हो सकती है (उदाहरण के लिए, पात्रों के इनलाइन अनुक्रम में एक टिप्पणी)।

इस बिंदु पर आपके पास संबंधित एनोटेशन के साथ नोड्स और आर्क हैं। इन से संबंधित ग्राफ का निर्माण करना बहुत आसान होना चाहिए।

Answer 2

मैंने पहले कभी ऐसा कुछ नहीं किया है, लेकिन इस तरह मैं इसे संपर्क करूंगा।

पहले, मैं कुछ इस तरह के साथ शुरू होता है: कि मैं 2 डी के माध्यम से पाठ में पात्रों का उपयोग कर सकते

class CharGrid(object): 
    def __init__(self, text): 
     self.lines = text.split('\n') 

    def __getitem__(self, pos): 
     try: 
      col, row = pos 
     except (TypeError, ValueError): 
      raise KeyError('%r not a 2-tuple' % (pos,)) 
     if row >= len(self.lines): 
      return ' ' 
     line = self.lines[row] 
     if col >= len(line): 
      return ' ' 
     return line[col] 

तो निर्देशांक:

grid = CharGrid("""Creating a No-Conversion Job 

>>-onpladm create job--job--+--------------+-- -n---------------> 
          '- -p--project-' 

>-- -d--device-- -D--database-- -t--table-----------------------> 

    .---------------------------------------------------------------------. 
    V                  | 
>----+-----------------------------------------------------------------+-+->< 
    |               (1) | 
    '-+-------------+--+-------------+--| Setting the Run Mode |------' 
     '- -S--server-' '- -T--target-' 
""") 

print ''.join((grid[0,0], grid[1,0], grid[2,0])) 
print ''.join((grid[0,2], grid[1,2])) 

(उपज)

Cre 
>> 

उसके बाद, कार्य अक्षरों के 2 डी ग्रिड को प्रतीकों के 1 डी अनुक्रम में परिवर्तित कर देगा:

1. पहली पंक्ति बंद लेबल
2. पहले कॉलम स्कैन नीचे पढ़ा जब तक आप पाते हैं वर्तमान स्थिति से >>
3. सही स्कैन जब तक आप पाते हैं [जो]

... आदि आंखों के क्रम में चार्ट का पालन करें।

एक बार जब आपके पास प्रतीकों का 1 डी अनुक्रम होता है, तो आप उस पर एक पारंपरिक पार्सिंग तकनीक का उपयोग कर सकते हैं।