कोको / आर ट्रांसलेटर जनरेटर के साथ काम करना

कोको / आर कंपाइलर्स और ट्रांसलेटर्स का एक जनरेटर है, जो कि विशेषता के अनुसार व्याकरण एक स्कैनर (लेक्सिकल विश्लेषक) और एक पार्सर (पार्सर) उत्पन्न करता है। स्कैनर का निर्माण नियतात्मक परिमित राज्य मशीन के रूप में किया जाता है, और पार्सर का निर्माण पुनरावर्ती वंश का उपयोग करके किया जाता है।


1. व्याकरण

जनरेटर RBNF के नियमों के अनुसार एक कोड उत्पन्न करता है। क्योंकि पार्सर एक पुनरावर्ती वंश के लायक है, और यह ऊपर से नीचे तक पार्स कर रहा है, फिर व्याकरण एलएल (के) से संबंधित होना चाहिए। आदर्श रूप से एलएल (1), लेकिन कोको / आर में संघर्ष समाधान किया जाता है।

एलएल (1) संघर्षों को शब्दार्थ कार्यों के माध्यम से हल किया जाता है और टोकन को आगे देखा जाता है।

व्याकरण एलएल (1) है यदि दो अलग-अलग उत्पादों के लिए S-> A | B शर्तों से संतुष्ट हैं:
1. ऐसा कोई टर्मिनल नहीं है जिसके लिए A और B एक से शुरू होने वाली रेखा उत्पन्न करते हैं।
2. एक खाली लाइन उत्पादों A या B में से किसी एक से अधिक द्वारा उत्पन्न की जा सकती है।
3. यदि e सेट FIRST (B) के अंतर्गत आता है, तो FIRST (A) FOLLOW (S) सेट - प्रतिच्छेद नहीं करते हैं। एफआईएसटी (ए) से संबंधित ई के लिए इसी तरह का एक बयान भी सच है।

2. भाषा कोको / आर

जनरेटर भाषाओं में कोड बना सकते हैं: जावा, C ++, C #, F #, VB.Net, Oberon।
उदाहरण में, C ++ लिया गया था।

सभी नियम एक अवधि के साथ समाप्त होने चाहिए।
फॉर्म S-> AB के उत्पादों को S = A B लिखा जाएगा।
| - या
() - समूह
[] - ० या १
{} - 0 या अधिक

२.१ आयात, अर्थात्। हेडर का कनेक्शन।

#include <string> #include <sstream> #include <iostream> #include <fstream> #include <vector> 

2.2 कंपाइलर आईडी , यानी COMPILER कीवर्ड निम्नानुसार है, जिसके बाद आपका व्याकरण शुरू होता है।

कम्पिलर एक्सप

2.3 वैश्विक चर और कार्य।
COMPILER कीवर्ड के बाद, आप चर और कार्यों के साथ एक अनुभाग सम्मिलित कर सकते हैं। यदि कई कार्य हैं, तो उन्हें एक अलग फ़ाइल में रखना बेहतर है, क्योंकि और उनके बिना व्याकरण बहुत डरावना और अपठनीय हो जाएगा।

 int toInt(const std::wstring& strbuf) { std::wstringstream converter; int value = 0; converter << strbuf; converter >> value; return value; } std::wstring toString ( int Number ) { std::wostringstream ss; ss << Number; return ss.str(); } 

2.4 स्कैनर बनाने के लिए नियम।
2.4.1 केस-असंवेदनशील के लिए IGNORECASE कीवर्ड।

२.४.२ अक्षर - वह खंड जिसमें हम मान्य वर्णों के समुच्चय का वर्णन करते हैं। उदाहरण के लिए, हमारे लिए एक पत्र क्या है और एक संख्या क्या है।

वर्ण
अक्षर = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"।
अंक = "0123456789"।

यहाँ विभाजक वर्णों का भी वर्णन किया जा सकता है।
cr = '\ r'।
lf = '\ n'।
टैब = '\ t'।

फॉर्म 1 का एक अंकन .. char2 char1 से char2 तक वर्णों के एक क्रम को दर्शाता है।
अंक = '0' .. '9'।

कोई भी - वर्णों का कोई भी क्रम।
+ कई सहित
- शामिल नहीं है

उदाहरण के लिए, आप बहुत सारे वर्णों का वर्णन कर सकते हैं जिनमें दोहरे उद्धरण शामिल नहीं हैं:
verbatimStringChar = कोई भी - '' ''।

हेक्साडेसिमल संकेतन के लिए वर्णों का समूह:
hexDigit = अंक + "ABCDEFabcdef"।

2.4.3 टोकन स्वयं, या दूसरा नाम - टोकन। अनुभाग कीवर्ड TOKENS है। हम बताते हैं कि पहचानकर्ता टोकन और संख्या टोकन से हमारा क्या मतलब है।

टोकन
पहचान = पत्र {पत्र | अंक | "_"}।
संख्या = अंक {अंक}।

स्ट्रिंग टोकन, दोहरे कोट्स में संलग्न वर्णों के किसी भी क्रम की तरह:
string = "\" "{verbatimStringChar}" \ ""।

हेक्साडेसिमल संख्या:
hex = "0x" {hexDigit hexDigit}।

२.४.४ विशेष विकल्पों की धारा।

2.4.5 टिप्पणियाँ।
टिप्पणियाँ "/ *" से "* /" नेस्टेड
टिप्पणियाँ FROM "//" के लिए cr lf

2.4.6 विभाजक। हम लिखते हैं कि हम किन विभाजकों को अनदेखा करते हैं।
IGNORE cr + lf + टैब

2.5 नियम एक पार्सर पैदा करने के लिए।
प्रोडक्शंस कीवर्ड से शुरू करें।
अभिव्यक्ति व्याकरण उदाहरण:
Expr = पहचान ': =' NumExpr ';'
NumExpr = शब्द {('+' | '-') NumExpr}
शब्द = गुणक {('*' | '/') शब्द}
गुणक = पहचान | नंबर | '(' NumExpr ')'

सभी विशेषताओं को कोष्ठक <> में लिखा गया है। यदि आप उदाहरण के लिए, स्टाल से कुछ का उपयोग करते हैं, तो सूची में, विशेषताओं को डॉट्स के साथ कोष्ठक में रखा जाना चाहिए, अर्थात। <। ।>।
विशेषताओं को गैर-टर्मिनलों पर लिखा जाता है और फ़ंक्शन मापदंडों के रूप में अनुवादित किया जाता है।
टर्मिनल में कोई विशेषता नहीं है, लेकिन यदि आप वास्तव में चाहते हैं, तो आप इसे एक गैर-विषयक में लपेट सकते हैं:
LogOp <std :: wstring & op> = ("(&&" | "||") (.op =--> val।)।

सिमेंटिक क्रियाएं कोष्ठक (..) के साथ कोष्ठक में लिखी जाती हैं। यह वह कोड है जिसे जनरेटर पार्सर में डालेगा। कोड उस भाषा में लिखा जाता है जिसमें लेसर और पार्सर उत्पन्न होते हैं।

कोई भी - पार्सर सेक्शन में यह कीवर्ड किसी भी टोकन को दर्शाता है। इसलिए हम "टेक्स्ट" को {Any} के रूप में वर्णित कर सकते हैं।

२.६ अंत कीवर्ड , आपके द्वारा २.२ में कंपाइलर के बाद दर्ज किया गया नाम।

3. संघर्ष का संकल्प।

यह समझना बहुत महत्वपूर्ण है कि व्याकरण विश्लेषक के प्रकार से मेल खाना चाहिए। यदि इस स्थिति का उल्लंघन किया जाता है, तो जनरेटर डरावने शब्दों में शपथ लेना शुरू कर देता है।

3.1 कारक।
नियम एक ही टोकन से शुरू होते हैं। जनरेटर कई विकल्प लिखता है
एक उदाहरण:
S-> a '=' B | a '(' C ')' '
जैसा कि आप देख सकते हैं, 2 नियम टोकन "ए" से शुरू होते हैं, जो पहले नियम एलएल (1) का उल्लंघन करता है। इसे S-> a ('=' B '(' C ')' 'के रूप में फिर से लिखें।
कुछ संघर्ष, जैसे कि-और, हल नहीं किया जा सकता है।
कथन = यदि '(' इप्र ')' कथन [और कथन]।
if (a> b) अगर (a> c) max = a; और अधिकतम = बी;
यह स्पष्ट नहीं है कि यहां क्या चुनना है, इसलिए एक समझौता किया गया था: पहला विकल्प चुनें। इस उदाहरण में, विकल्प सही है, लेकिन आपके व्याकरण में ऐसी अस्पष्टताओं से बचने के लिए बेहतर है।

बुरा रिकॉर्ड।
एस = [एक आईडी बी] ए।
ए = आईडी {.id}।
यह स्पष्ट नहीं है कि किस नियम को चुनना है, क्योंकि [आईडी बी] और एक ही टोकन के साथ एक शुरुआत। इस मामले में, व्याकरण को फिर से लिखना सबसे अच्छा है:
S = a id (b A | {{Id})।

३.२ वाम पुनरावृत्ति।
एलएल व्याकरण के लिए वाम पुनरावृत्ति वैध नहीं है। इसे रूपांतरण द्वारा हटाया जाना चाहिए। सौभाग्य से, किसी भी बाईं पुनरावृत्ति को दाईं ओर परिवर्तित किया जा सकता है।
उ०—> आ १ | ... | आन | ब १ ... | ब्म
पर
A-> b1B | .. | bmB
B-> a1B | .. | aB | e |

आरबीएनएफ में रिकॉर्ड:
ए = ए बी | सी।
पर
ए = सी {बी}।

३.३ अर्थ महत्व।
कुछ मामलों में, नियमों को उनके शब्दार्थ के आधार पर चुना जाता है। उदाहरण के लिए, एक अभिव्यक्ति प्रकार के साथ:
Expr = Factor {’+’ Factor}।
कारक = '(' पहचान ')' कारक | ’(Ex एक्सप्र’ ’) | पहचान | नंबर।

यानी ऐसा व्याकरण निम्नलिखित श्रृंखला की अनुमति देता है:
ए + बी
(a) + बी
(int) a + b
अंतिम श्रृंखला में, पहचानकर्ता के शब्दार्थ द्वारा '(' पहचान ') कारक नियम का चुनाव निर्धारित किया जाता है। यानी यदि हमारे पास प्रकार के रूप में पहचान है, तो यह नियम चुना गया है।

! भाषा के निर्माण के संदर्भ में एक अत्यंत असफल उदाहरण। आमतौर पर, एक व्याकरण में, "कीवर्ड" का वर्णन एक अलग नियम द्वारा किया जाता है। फिर पहचानकर्ता जांच की कोई आवश्यकता नहीं है।

एक और उदाहरण।
A = पहचान (। X = 1;;) {',' पहचान (.x ++ ++;)} ':' पहचान (.Foo ();) {',' पहचान (.bar) (;))} ';'।
इस मामले में, व्याकरण को संपादित नहीं किया जा सकता है, क्योंकि नियम के समान भागों में अलग-अलग शब्दार्थ क्रियाएं होती हैं। एक नियम को परिभाषित करने के लिए, आपको बृहदान्त्र या अर्धविराम से पहले सभी टोकन को देखने की जरूरत है। इसके बाद ही यह स्पष्ट होगा कि कौन सा नियम चुनना है।

समाधान:
आप व्याकरण में एक बूलियन फ़ंक्शन सम्मिलित कर सकते हैं जिसके द्वारा एक विकल्प का चयन किया जाएगा।
एस = [एक आईडी बी] ए।
ए = आईडी {.id}।

एस = एक [आईएफ (इलियास ()) आईडी बी] ए।
IsAlias ​​() एक फ़ंक्शन है जो सामने 2 टोकन स्कैन करता है। यदि यह b है, तो सही है।

टोकन टी - बस मान्यता प्राप्त टोकन
टोकन ला - अगले टोकन

t.val - टोकन मूल्य
t.kind - टोकन का प्रकार, जो लेक्सर द्वारा निर्धारित किया गया है

A = IF (FollowedByColon ())
पहचान (? x = 1;;) {',' पहचान (.x ++;);)}:
| पहचान (.Foo ();) {',' पहचान (बार ();))} ';'।

 bool FollowedByColon(){ //   Token x = la; //      while(x.kind==_comma || x.kind== _ident) //     x=scanner.Peek(); // true,     return x.kind==_colon; } 

टिप्पणी:
यदि जनरेटर भाषा कीवर्ड।
FollowedByColon () फ़ंक्शन पहले नियम को संदर्भित करता है। अगर वह सच है, तो यह वह है जो इसे मानता है।
स्कैनर के प्रकारों के नाम स्कैनर द्वारा दिए गए हैं। लेकिन अगर आप TOKENS सेक्शन में इस तरह की घोषणा करते हैं
पहचान = पत्र {पत्र | अंक | "_"}।
अल्पविराम = ','।
अर्धविराम = ';'।
कोलन = ':'।
यह स्कैनर अच्छे नामों के साथ स्थिरांक उत्पन्न करेगा:
const int _EOF = 0;
const int _ident = 1;
const int _comma = 2;
const int _semicolon = 3;
const int _colon = 4;

भाषा के निर्माण के दृष्टिकोण से, प्रत्येक विशेष प्रतीक के टोकन के रूप में एक अलग विवरण का कोई मतलब नहीं है। लेकिन अगर ऐसी स्थिति लिखने की आवश्यकता है जिसमें आगे टोकन का सत्यापन आवश्यक है, तो ऐसा विवरण उपयोगी हो सकता है।

यदि पहले नियम में आपके पास एक फ़ंक्शन था जिसमें आपने टोकन की जांच की थी, और दूसरे नियम में भी आपका एक फ़ंक्शन है, तो स्कैनर को अपनी मूल स्थिति में वापस आना चाहिए। आप स्कैनर के साथ स्थिति को रीसेट कर सकते हैं ।esetPeek () फ़ंक्शन।


4. नमूना कोड

हम अभिव्यक्ति को पोस्टफिक्स नोटेशन में तब्दील करते हैं। अभिव्यक्तियों को निम्नलिखित व्याकरण द्वारा घटाया जाना चाहिए:
Expr = पहचान ': =' NumExpr ';'
NumExpr = शब्द {('+' | '-') NumExpr}
शब्द = गुणक {('*' | '/') शब्द}
गुणक = पहचान | नंबर | '(' NumExpr ')'

atg फ़ाइल:

 #include <string> #include <sstream> #include <iostream> #include <fstream> #include <vector> COMPILER expr int toInt(const std::wstring& strbuf) { std::wstringstream converter; int value = 0; converter << strbuf; converter >> value; return value; } std::wstring toString ( int Number ) { std::wostringstream ss; ss << Number; return ss.str(); } IGNORECASE CHARACTERS letter = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz". digit = "0123456789". cr = '\r'. lf = '\n'. tab = '\t'. TOKENS ident = letter {letter | digit | "_"}. number = digit {digit}. COMMENTS FROM "/*" TO "*/" NESTED COMMENTS FROM "//" TO cr lf IGNORE cr + lf + tab PRODUCTIONS expr (.std::wstring str;.) = (.std::wstring s,s1,s2,s3,s4; .) ident (.s1=t->val;.)":=" NumExpr<s2> ";" (. str+=s1; str+=s2; str+=L":=\n";.) {ident(.s3=t->val; s4=L"";.)":=" NumExpr<s4> ";" (. s+=s3; s+=s4; s+=L":=\n"; .)} (. str+=s; std::wofstream outfile ("out.txt", std::ios_base::out); outfile << str << std::endl; outfile.close(); .) . NumExpr<std::wstring &str> = (.std::wstring s1,s2, op; .) Term<s1> (.str+=s1;.) { ("+" (.op=L"+";.)|"-" (.op=L"-";.)) NumExpr<s2> (. str+=s2; str+=op; .) }. Term<std::wstring &str> =(.std::wstring s1,s2, op;.) Multiplier<s1> (.str+=s1;.) { ("*" (.op=L"*";.)|"/"(.op=L"/";.)) Term<s2> (. str+=s2; str+=op; .) }. Multiplier<std::wstring &str> = ident (.str=t->val; .) | number (.str=t->val;.) | (.std::wstring s; .) "(" NumExpr<s> ")" (.str=s;.). END expr. 

मुख्य:

 #include <iostream> #include <wchar.h> #include "Parser.h" #include "Scanner.h" #include <string> using namespace std; main(int argc, char *argv[]) { if (argc == 2) { wchar_t *file = coco_string_create(argv[1]); Scanner *scanner = new Scanner(file); Parser *parser = new Parser(scanner); parser->Parse(); delete parser; delete scanner; delete file; return 0; } else { cout << "Use: translator filename" << endl; return 1; } } 

बनाने:

 all: translator translator: Coco scanner.o parser.o main.o g++ -o tr.exe scanner.o parser.o main.o main.o: main.cpp g++ -c main.cpp scanner.o: Scanner.cpp Scanner.h g++ -c Scanner.cpp -o scanner.o parser.o: Parser.cpp Parser.h g++ -c Parser.cpp -o parser.o Coco: expr.atg coco expr.atg clean: del Scanner.cpp Scanner.h Parser.cpp Parser.h del Scanner.cpp.old Scanner.h.old Parser.cpp.old Parser.h.old del scanner.o parser.o main.o del translator 

व्याकरण पार्सर फ़ंक्शन

 void Parser::NumExpr(std::wstring &str) { std::wstring s1,s2, op; Term(s1); str+=s1; while (la->kind == 5 || la->kind == 6) { if (la->kind == 5) { Get(); op=L"+"; } else { Get(); op=L"-"; } NumExpr(s2); str+=s2; str+=op; } } 

प्रविष्टि
a: = b;
a: = a-5;
a: = 9-5 + 2;
a: = 2 + 3 * 4;
a: = (5-4) * (3 + 2);

उत्पादन
ab: =
आ ५ -: =
a952 + -: =
a234 * +: =
a54-32 + *: =