गेट दुभाषिया

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

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

व्याकरण के साथ काम करने के सभी साधनों में से, मैंने केवल कुछ का उल्लेख किया है। सबसे पहले, ये निश्चित रूप से lex, flex, yacc, bison और antlr हैं, जो मुख्य रूप से C / C ++ कंपाइलर के लिए उपयोग किए जाते हैं। दूसरे, यह ओसमलैलेक्स और ओक्मलैकैक है - जो एक कंपाइलर विकसित करने के लिए डिज़ाइन किए गए हैं, जैसा कि आप अनुमान लगा सकते हैं, ओकामला पर। और तीसरा, यह fslexx और fsyacc है - एक ही चीज़, केवल F # भाषा के लिए, जो कि ocaml से पूरी तरह से थोड़ी कम नकल की जाती है, लेकिन बाद में बन्स की बजाय बड़ी संख्या के साथ उग आती है। एफ # मैंने अपने सिस्टम में अनुपस्थित के रूप में खारिज कर दिया, और सभी प्लसस - उनकी बहुतायत के कारण। हां, कभी-कभी एक विस्तृत पसंद भी खराब होती है, मुझे इन सभी लेकर्स और पार्सर्स में भ्रमित होने का डर था।

वैसे, यह मेरे लिए एक अजीब और अप्रिय खोज थी, जो यह बताती है कि किसी भी भाषा के विश्लेषण में दो अलग-अलग चरण होते हैं, जो विभिन्न उपकरणों द्वारा किए जाते हैं, मुझे यह प्रतीत हुआ कि एक में सब कुछ क्यों नहीं करना चाहिए। लेकिन अफसोस।

भाषा के प्रकार

मैं झूठ नहीं बोलता, मैंने तुरंत भाषा की पूरी वास्तुकला के बारे में नहीं सोचा था और धीरे-धीरे सुविधाओं को धीरे-धीरे खत्म कर रहा था। लेकिन सामग्री के आकार को कम करने के लिए (और जल्दी से उस रास्ते पर जाने के लिए जो मुझे छह सुंदर रविवार सुबह घंटों तक ले गया), हम यह दिखावा करेंगे कि सब कुछ पहले से योजनाबद्ध था। हमारी भाषा का प्रत्येक निर्देश एक वस्तु है। C ++ में, यह एक निश्चित इंस्ट्रक्शन बेस क्लास के वंशजों में से एक या एक जटिल संरचना के रूप में या सामान्य रूप से एक संघ के रूप में प्रतिनिधित्व किया जा सकता है। सौभाग्य से, ओकामल हमें हर चीज को यथासंभव सरल बनाने की अनुमति देता है। हमारी पहली फ़ाइल, yobaType.ml, जो सभी प्रकार के निर्देशों का वर्णन करती है, को यथासंभव सरल बनाया गया है:

type action =
DoNothing
| AddFunction of string * action list
| CallFunction of string
| Stats
| Create of string
| Conditional of int * string * action * action
| Decrement of int * string
| Increment of int * string;;

प्रत्येक भाषा निर्माण को इनमें से किसी एक प्रकार का बनाया जाएगा। DoNothing सिर्फ एक एनओपी बयान है, यह बिल्कुल कुछ भी नहीं करता है। क्रिएट एक वैरिएबल बनाता है (हमारे साथ वे हमेशा पूर्णांक होते हैं), कुछ संख्या द्वारा क्रमशः दिए गए वैरिएबल को घटाते और बढ़ाते हैं। इसके अलावा, सभी बनाए गए चर और सशर्त के लिए आंकड़े प्रदर्शित करने के लिए आँकड़े हैं - हमारा यदि कार्यान्वयन, जो यह जांच सकता है कि किसी दिए गए चर में एक आवश्यक मान (या एक बड़ा) है या नहीं। बहुत अंत में, मैंने AddFunction और CallFunction जोड़ा - अपने स्वयं के कार्यों को बनाने और कॉल करने की क्षमता, जो वास्तव में बहुत प्रक्रियाएं हैं।

भाषा का व्याकरण

अगला कदम व्याकरण का वर्णन करना है, हमारी भाषा के निर्माण जो एक तरह के निर्देशों में बदल जाएंगे।

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

%{
open YobaType
%}

%token <string> ID
%token <int> INT

%token RULEZ
%token GIVE TAKE
%token WASSUP DAMN
%token CONTAINS THEN ELSE
%token FUCKOFF
%token STATS
%token MEMORIZE IS
%token CALL

%start main
%type <YobaType.action> main

%%

main:
expr { $1 }
expr:
fullcommand { $1 }
| MEMORIZE ID IS fullcommandlist DAMN { AddFunction($2, $4) }
fullcommandlist:
fullcommand { $1 :: [] }
| fullcommand fullcommandlist { $1 :: $2 }
fullcommand:
WASSUP command DAMN { $2 }
| STATS { Stats }
command:
FUCKOFF { DoNothing }
| GIVE ID INT { Increment($3, $2) }
| GIVE INT ID { Increment($2, $3) }
| TAKE ID INT { Decrement($3, $2) }
| TAKE INT ID { Decrement($2, $3) }
| RULEZ ID { Create($2) }
| CALL ID { CallFunction($2) }
| CONTAINS ID INT THEN command ELSE command { Conditional($3, $2, $5, $7) }
| CONTAINS INT ID THEN command ELSE command { Conditional($2, $3, $5, $7) }
%%

पहली चीज जो हम करते हैं वह है हेडिंग - योबटाइप मॉड्यूल को खोलना, जिसमें हमारा एक्शन टाइप होता है, जो बहुत शुरुआत में वर्णित है। संख्या और स्ट्रिंग के लिए जो भाषा (चर) के कीवर्ड नहीं हैं, हम दो विशेष प्रकारों की घोषणा करते हैं, जो इंगित करते हैं कि वास्तव में वे क्या हैं। % टोकन निर्देशन का उपयोग करने वाले प्रत्येक कीवर्ड के लिए, हम अपना स्वयं का प्रकार भी बनाते हैं जो व्याकरण में इस शब्द की पहचान करेगा। कोई भी कम से कम एक पंक्ति में उन सभी को इंगित कर सकता है, बस ऐसे रिकॉर्ड समूह निर्देश के प्रकार के अनुसार सब कुछ। ध्यान रखें कि हमारे द्वारा बनाए गए सभी टोकन ठीक प्रकार के प्रतिस्थापन हैं जिनके द्वारा व्याकरण पार्सर निर्धारित करता है कि उसे क्या करना चाहिए। आप उन्हें अपनी पसंद के अनुसार कुछ भी कह सकते हैं, जिस तरह से वे स्वयं भाषा में देखेंगे, हम बाद में वर्णन करेंगे। हम इंगित करते हैं कि व्याकरण के लिए प्रवेश बिंदु मुख्य है, और यह कि टाइप एक्शन का ऑब्जेक्ट हमेशा इसे वापस करना चाहिए - दुभाषिया के लिए एक निर्देश। अंत में, दो %% संकेतों के बाद, हम व्याकरण का स्वयं वर्णन करते हैं:

• निर्देश में एक कमांड (फुलकमैंड) या एक फंक्शन का निर्माण होता है।
• फ़ंक्शन, बदले में, कमांड (फुलकैंडलिस्ट) की एक सूची होती है।
• एक कमांड या तो सेवा (STATS) या नियमित (कमांड) हो सकती है, जिस स्थिति में इसे कीवर्ड में लपेटा जाना चाहिए।
• एक साधारण टीम के साथ, सब कुछ सरल है, मैंने पेंट भी नहीं किया है।

घुंघराले कोष्ठक में हम इंगित करते हैं कि क्या करना है जब स्ट्रिंग इस विकल्प से मेल खाती है, जिसमें $ N निर्माण के Nth सदस्य को दर्शाती है। उदाहरण के लिए, यदि हम "CALL ID" से मिलते हैं (ID एक स्ट्रिंग है, तो मत भूलो), तो हम एक CallFunction निर्देश बनाते हैं, जिसे हम एक पैरामीटर के रूप में $ 2 (बस ID) - फंक्शन के नाम कहते हैं।

Lexer - भाषा को खोजशब्दों में बदलना

हम एक ही समय में लगभग सबसे सरल और सबसे सुनसान भाग पर पहुँचे। यह सरल है, क्योंकि यह सिर्फ भाषा के शब्दों के हमारे टोकन में परिवर्तन का वर्णन करता है। एक सुनसान, क्योंकि लेक्सर्स (या शायद केवल ओकामलोव्स्की लेक्सर) खराब तरीके से रूसी भाषा के साथ काम करने के लिए डिज़ाइन किए गए हैं, इसलिए आप केवल तार के साथ रूसी पात्रों के साथ काम कर सकते हैं। चूँकि मैं भाषा के मामलों को असंवेदनशील बनाना चाहता था, इसने बवासीर का एक गुच्छा जोड़ दिया - केवल लिखने के लिए "दे", मुझे प्रत्येक अक्षर के लिए एक वर्तनी विकल्प चुनना था। सामान्य तौर पर, अपने लिए देखें, yobLexer.mll फ़ाइल:

1. {
2. YOBParser खोलें
3. अपवाद eof
4. }
5. शासन टोकन = पार्स
6. ( "और" | "और" ) ( "डी" | "डी" ) ( "और" | "और" ) ( ' ' ) +
7. ( "n" | "H" ) ( "a" | "A" ) ( "x" | "X" ) ( "y" | "Y" | "Y" ) ( "y" | "Y" ) { FUCKOFF }
8. | ( "बी" | "बी" ) ( "ए" | "ए" ) ( "एल" | "एल" ) ( "ए" | "ए" )
9. ( "एन" | "एच" ) ( "सी" | "सी" ) ( ' ' ) +
10. ( "n" | "H" ) ( "a" | "A" ) ( "x" | "X" ) { STATD }
11. | [ ' ' ' \ t ' ' \ n ’ \ r ' ] { टोकन लेक्सबुफ़ }
12. | [ ' 0 ' - ' 9 ' ] + { INT ( int_of_string ( लेक्सिंग । लेक्समे लेक्सबोर्न ) ) }
13. | ( "d" | "D" ) ( "a" | "A" ) ( "y" | "Y" ) { GIVE }
14. | ( "n" | "H" ) ( "a" | "A" ) { TAKE }
15. | ( "एच" | "एच" ) ( "ओ" | "ओ" ) { WASSUP }
16. | ( "थ" " | " थ " ) ( " ओ " | " ओ " ) ( " बी " | " बी " ) ( " ए " | " ए " ) { DAMN }
17. | ( "l" | "l" ) ( "y" | "y" ) ( "b" | "b" ) ( "l" ) ( "l" | " l " ) ( "y" | " y " ) { RULEZ }
18. | ( "e" | "E" ) ( "c" | "C" ) ( "t" | "T" ) ( "b" | "b" | "b" ) { CONTAINS }
19. | ( "t" | "T" ) ( "a" | "A" ) ( "d" | "D" ) ( "a" | "A" ) { THEN }
20. | ( "और" | "और" ) ( "एल" | "एल" ) ( "और" | "और" ) { ELSE }
21. | ( "y" | "Y" ) ( "c" | "C" ) ( "e" | "E" ) ( "k" | " k" | "K" ) ( "और" | "और" ) { MEMORIZE }
22. | ( "ई" | "ई" ) ( "टी" | "टी" ) ( "ओ" | "ओ" ) { आईएस }
23. | ( "x" | "X" ) ( "y" | "Y" ) ( "y" | "Y" ) "Y" ) ( "n" | "H" ) ( "और" | "और" ) { CALL }
24. |
25. ( "a" | "b" | "c" | "g" | "d" | "e" | "e" | " e ")
26. | "z" | "और" | "ध" | "से" | "ल" | "म" | "एन" | 'ओ'
27. | "पी" | "पी" | "s" | "टी" | "यू" | "च" | x | "Ts"
28. | "ज" | "w" | "यू" | "बी" | "s" | "बी" | "ई" | "यू" | "I" ) + { ID ( लेक्सिंग । लेक्सेम लेक्सबुफ ) }
29. | eof { Eof बढ़ाएँ }

मैं बस ध्यान देता हूं कि यह कोड बच्चों और नाजुक मानसिक संगठन वाले लोगों को नहीं दिखाया जाना चाहिए, क्योंकि सभी अश्लील भाषा की शब्दावली यहां वर्णित है। इसके अलावा, शुरुआत में हम अपने पार्सर के मॉड्यूल को खोलते हैं, जिसमें सभी प्रकार परिभाषित होते हैं (STATS, GIVE, TAKE, आदि) और एक अपवाद बनाएं जो इनपुट समाप्त होने पर फेंक दिया जाएगा। 11 वीं पंक्ति पर ध्यान दें, यह इंगित करता है कि रिक्त स्थान और अन्य कचरे को अनदेखा किया जाना चाहिए, जबकि यह उन निर्देशों के बाद विशेष रूप से जाता है जिनमें रिक्त स्थान होते हैं। 12 वीं और 25-28वीं पंक्तियाँ चर की संख्या और नामों को संसाधित करती हैं, और 29 वां बहुत अपवाद फेंकता है जो फ़ाइल के अंत को इंगित करता है।

दुभाषिया

आखिरी हिस्सा बना हुआ है - दुभाषिया ही, जो हमारी भाषा के निर्माण की प्रक्रिया करता है। पहले कोड, फिर स्पष्टीकरण:

1. YOBType खोलें
3. आइडेंटिफायर्स = हैशटैब । 10 बनाएं ;;
4. आज्ञा देना = हश्टबल । 10 बनाएं ;;
6. let प्रिंट_स्टेट्स ( ) =
7. let प्रिंट_इटेम आईडी राशि =
8. छापा । प्रिंटफ ">> यो! आपके पास% s:% d" आईडी राशि है ;
9. Print_newline ( ) ;
10. में बहना
11. हशब्बल । iter Print_item पहचानकर्ता ;;
13. आज्ञा देना arithm आईडी op मान ( ) =
14. कोशिश
15. हशब्बल । आइडेंटिफ़ायर आईडी ( op ( हैशटैब । आइडेंटीज़र्स आईडी ) मान ) बदलें ;
16. छापा । प्रिंटफ ">> शिट प्रश्न \ n" ; फ्लश स्टडआउट
17. Not_found के साथ -> Printf Printf ">> X @ # पर, आपको% s पसंद नहीं है \ n" आईडी ; फ्लश स्टडआउट ;;
19. आइए rec cond id id act1 act2 ( ) =
20. कोशिश
21. अगर हैशटैब । आइडेंटीफायर्स आईडी > = राशि फिर प्रोसेस_एक्शन एक्ट 1 ( ) और प्रोसेस_एक्शन एक्ट 2 ( )
22. Not_found के साथ ->
23. छापा । Printf ">> यह क्या है? \ n" ;
24. फ्लश स्टडआउट
25. और process_action = फ़ंक्शन
26. | बनाएँ ( आईडी ) -> ( फ़ंक्शन ( ) -> हैशटैब । पहचानकर्ता आईडी जोड़ें 0 )
27. | विकृतीकरण ( राशि, आईडी ) -> अंकगणित आईडी ( - ) राशि
28. | वृद्धि ( राशि, आईडी ) -> अंकगणित आईडी ( + ) राशि
29. | सशर्त ( राशि, आईडी, अधिनियम 1, अधिनियम 2 ) -> कंडोम राशि आईडी अधिनियम 1 अधिनियम 2
30. | DoNothing -> ( फ़ंक्शन ( ) -> ( ) )
31. | आँकड़े -> Print_stats
32. | AddFunction ( id, funclist ) -> ( फंक्शन ( ) -> Hashtbl । फंक आईडी id funclist जोड़ें )
33. | कॉलफंक्शन ( आईडी ) -> कॉलफुन आईडी
34. और कॉलफुन आईडी ( ) =
35. चलो एफ : YOBType । क्रिया सूची = हैशटैब । में funcs id खोजें
36. सूची। iter ( फ़ंक्शन x -> process_action x ( ) ) f
37. ;;
39. जबकि सच है
40. कोशिश
41. लेक्सबुफ = लेक्सिंग । from_channel स्टडिन इन
42. process_action ( YOBParser । मुख्य YOBLexer । टोकन लेक्सबुफ ) ( )
43. साथ
44. YOBLexer । ईओएफ ->
45. प्रिंट_स्टेट्स ( ) ;
46. बाहर निकलें 0
47. | पार्सिंग । Parse_error ->
48. छापा । Printf ">> न तो @ # मैं समझ गया b @ #! \ n" ;
49. फ्लश स्टडआउट
50. | असफलता ( _ ) ->
51. छापा । Printf ">> न तो @ # मैं समझ गया b @ #! \ n" ;
52. फ्लश स्टडआउट
53. किया

सबसे पहले, हम दो हैश टेबल बनाएंगे - चर और कार्यों के लिए। प्रारंभिक आकार 10 को टॉर्च से लिया गया है, हमारे पास एक ही प्रशिक्षण भाषा है, हमें एक साथ कई कार्यों की आवश्यकता क्यों है।
फिर हम दो छोटे कार्यों की घोषणा करते हैं: एक आउटपुट आंकड़ों के लिए, और दूसरा चरों के बढ़ने / घटने के लिए।

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

ध्यान दें कि process_action में सभी विकल्प एक क्रिया नहीं करते हैं, लेकिन केवल एक फ़ंक्शन वापस करते हैं जो इसे निष्पादित करेगा। प्रारंभ में, यह ऐसा नहीं था, लेकिन यह छोटा परिवर्तन था जिसने मुझे आसानी से और आसानी से उपयोगकर्ता के कार्यों के लिए भाषा में समर्थन जोड़ने की अनुमति दी।

अंत में, कोड का अंतिम भाग, लूप में नीला होने से पहले, पार्सर के परिणाम को पढ़ता है और संसाधित करता है।

इसमें मेफाइल जोड़ें और आप खेल सकते हैं:

all:
ocamlc -c yobaType.ml
ocamllex yobaLexer.mll
ocamlyacc yobaParser.mly
ocamlc -c yobaParser.mli
ocamlc -c yobaLexer.ml
ocamlc -c yobaParser.ml
ocamlc -c yoba.ml
ocamlc -o yoba yobaLexer.cmo yobaParser.cmo yoba.cmo

clean:
rm -f *.cmo *.cmi *.mli yoba yobaLexer.ml yobaParser.ml

भाषा की जाँच

अब, ध्यान दें, मैंने मूल्यों और चर के एक अलग क्रम का समर्थन क्यों किया? तथ्य यह है कि भाषा बहुत निकली, उम, प्राकृतिक, दुभाषिया सचमुच आपसे बात कर रहा है। इसलिए, मैं खुद लगातार इस उलझन में हूँ कि क्या लिखना है:

$ ./yoba



3
4
2

@#
>>
>>
>>

>> ! : 7
>> ! : -2
4 1 @#
>>

>> ! : 7
>> ! : -1
4 @# @#
>>
>>
>>

>> ! : 14
>> ! : -3

कमियों में से एक यह है कि जब कार्यों को कॉल किया जाता है, तो संचालन की संख्या से सफलतापूर्वक वृद्धि / कमी के बारे में टिप्पणियां सामने आती हैं।

मुझे उम्मीद है कि यह दिलचस्प था। सभी दुभाषिया कोड यहां डाउनलोड किए जा सकते हैं (2kb) ।
यदि अधिक अनुभवी लोग कोड के बारे में टिप्पणी साझा करते हैं, तो मैं आभारी रहूंगा।