नई करते-करते-स्वयं प्रोग्रामिंग भाषा

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

भाषा संकलित है, अनिवार्य है, वस्तु-उन्मुख नहीं है; शब्दार्थ सी से हटकर लिखा गया है और कई उपयोगी विशेषताओं के साथ पूरक है। चलो उनके साथ शुरू करते हैं।

शब्दार्थ संशोधन

सुरक्षित संकेत

आपने रूस्त से स्मार्ट पॉइंटर्स के बारे में अभी सोचा होगा, लेकिन वे नहीं हैं। मेरी भाषा में, स्मृति तक पहुँचने की सुरक्षा दो मुहावरों द्वारा प्रदान की जाती है। पहला: संकेत की एक dereferencing ऑपरेशन की कमी। इसके बजाय, घोषित पॉइंटर को एक्सेस करते समय, ऑब्जेक्ट को ही संदर्भित किया जाता है। यही है, आपको इस तरह लिखना चाहिए और लिखना चाहिए:

int # pointer ~~ new int(5) int variable ~ pointer + 7 

परिवर्तनशील चर में अब संख्या 12 होती है। अब आप एक अपरिचित वाक्यविन्यास देखते हैं और, शायद, आप थोड़ा हैरान हैं, लेकिन मैं लेख के पाठ्यक्रम में सब कुछ समझाऊंगा। दूसरा मुहावरा: संकेत पर संचालन की कमी। फिर से: असाइनमेंट, वेतन वृद्धि और वेतन वृद्धि सहित पॉइंटर्स तक पहुंचने पर सभी ऑपरेशन वस्तुओं पर किए जाते हैं। एकमात्र ऑपरेशन जो पॉइंटर से सीधे संबंधित होता है, पते द्वारा असाइनमेंट होता है, या, जैसा कि मैं इसे पहचानता हूं। ऊपर दिए गए कोड उदाहरण में, पहली पंक्ति में, यह सटीक पहचान है। किसी भी पॉइंटर को केवल पहले से आवंटित मेमोरी क्षेत्र के पते पर सेट किया जा सकता है, जो कि नया ऑपरेशन है। आप ढेर पर, यहां तक ​​कि स्टैक पर भी आवंटित एक अन्य चर के पते पर एक संकेतक रख सकते हैं। यहाँ एक उदाहरण है:

 int variable ~ 5 int # pointer ~~ variable 

यहां "~" सामान्य असाइनमेंट ऑपरेशन है। आप एक विशेष अशक्त सूचक के साथ संकेत भी पहचान सकते हैं। यह एक पॉइंटर के रूप में कार्य करता है जो अशक्त पते को संदर्भित करता है। अशक्तता के साथ पहचान (समान पते) पर तुलना और तुलना के संचालन की पहचान करने के बाद, वे सही उपज देंगे:

 int # pointer ~~ null if (pointer = null) nop ;; true if (pointer == nul) nop ;; true 

यहाँ "=" मूल्यों की तुलना है, "==" पतों की तुलना है, "एनओपी" एक खाली ऑपरेशन है, और उसके बाद ";;" - टिप्पणी। और हां, नल एकमात्र ऐसा पॉइंटर ऑपरेशन है जिसकी मदद से टाइप कम्पैटिबिलिटी की जांच संभव नहीं है।

इस प्रकार, संकेत केवल आवंटित स्मृति या अशक्त क्षेत्रों को सौंपा जा सकता है और कहीं भी स्थानांतरित नहीं किया जा सकता है। हालांकि, ये उपाय विभाजन की त्रुटि त्रुटियों से पूरी तरह से रक्षा नहीं करते हैं। इसे पाने के लिए, बस इन चरणों का पालन करें:

 int # pointer1 ~~ new int(5) int # pointer2 ~~ pointer1 delete pointer1 int variable ~ pointer2 ;; segmentation fault! 

मुझे लगता है कि यहां सब कुछ स्पष्ट है। लेकिन ऐसी गलती करना केवल उद्देश्य पर किया जा सकता है, और फिर, कड़ी मेहनत करना। आखिरकार, डिलीट ऑपरेशन कचरा कलेक्टर के समान ही करता है, केवल कम सुरक्षित रूप से। उसे बोलते हुए ...

कचरा इकट्ठा करने वाला

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

बिल्ट-इन Arrays

हालाँकि मैंने कहा था कि भाषा के शब्दार्थ C से लिखे गए हैं, इसलिए अंतर काफी महत्वपूर्ण हैं। यहाँ सरणियाँ संकेत हैं। Arrays का अपना सिंटैक्स और सुरक्षित पता है। नहीं, रेंज चेक के साथ नहीं। उनके साथ, सिद्धांत रूप में, एक रनटाइम त्रुटि प्राप्त करना मुश्किल है। ऐसा इसलिए है क्योंकि प्रत्येक सरणी चर की लंबाई को जावा के अनुसार चर आकार में संग्रहीत करती है, और सूचकांक से प्रत्येक अनुक्रमण के साथ ... इस आकार के द्वारा विभाजन शेष है! एक बेवकूफ निर्णय, पहली नज़र में, जब तक हम नकारात्मक सूचकांकों को नहीं देखते। यदि आप सरणी की लंबाई के आधार पर -1 को विभाजित करते हुए शेष पाते हैं, तो आपको आकार -1 के बराबर संख्या मिलती है, जो कि सबसे परिमित तत्व है। इस तरह के पैंतरेबाज़ी से, हम न केवल शुरुआत से, बल्कि सरणी के अंत से भी सूचकांकों तक पहुंच सकते हैं। एक और चाल किसी भी आदिम प्रकार को बाइट [] सरणी में डालने की है। लेकिन आप एक रनटाइम त्रुटि कैसे प्राप्त करते हैं, आप पूछते हैं? मैं इस प्रश्न को एक आसान पहेली के रूप में आपके लिए छोड़ दूंगा।

संदर्भ

मुझे यह पता नहीं है कि वर्तमान सी मानक में लिंक शामिल हैं या नहीं, लेकिन वे निश्चित रूप से लोलो में होंगे। शायद सी के पुराने संस्करणों में संदर्भों की कमी संकेत करने वाले बिंदुओं के मुख्य कारणों में से एक है। उन्हें पते की दलीलें पास करने की जरूरत होती है, नकल के बिना कार्यों से मूल्यों को वापस करने के लिए। पॉइंटर्स और सरणियों को संदर्भ द्वारा भी पारित किया जा सकता है (चूंकि मूल्य से गुजरने पर, सरणियों को पूरी तरह से कॉपी किया जाएगा, और ~~ ऑपरेशन द्वारा एक नए स्थान पर सेट किए गए पॉइंटर्स इसे नहीं बचाएंगे)।

बहु सूत्रण

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

इनलाइन स्ट्रिंग्स

यह स्ट्रिंग है, न कि स्ट्रिंग शाब्दिक, जैसा कि C ++ में है। प्रत्येक पंक्ति की अपनी लंबाई होगी, शेष को खोजने के साथ अनुक्रमण होगा। सामान्य तौर पर, लोलो में तार चरित्र सरणियों के समान होते हैं, सिवाय इसके कि सरणियों में "+", एनीमेशन के माध्यम से "*" और "<" और ">" के माध्यम से तुलना नहीं होती है। और जब से हम लाइनों के बारे में बात कर रहे हैं, हमें वर्णों का उल्लेख करना चाहिए। लोलो में प्रतीक संख्या नहीं हैं, जैसा कि C ++ में है। और उनमें एक बाइट नहीं है, लेकिन DKOTI वर्णों के लिए 4 और UTF वर्णों के लिए 6 हैं। मैं अगली बार DKOTI के बारे में बात करूंगा, लेकिन अभी के लिए, बस इतना पता है कि लोलो दो एन्कोडिंग में वर्ण और तार का समर्थन करता है। और हां, लंबाई की संपत्ति भी स्थिरांक से ली जा सकती है:

 int len ~ "Hello, world!".length ;; len = 13 

तीन प्रकार के साथ बूलियन प्रकार

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

संरचनाओं और सूचियों को आरम्भ करने के लिए सूचियाँ

यदि, एक संरचनात्मक चर घोषित करने के बाद, ~ साइन लगाएं और वर्ग कोष्ठक खोलें, तो आप इसके क्षेत्रों के मूल्यों को बदले में या शब्दकोश के रूप में सेट कर सकते हैं। यदि आप किसी सरणी के साथ इस तरह की प्रक्रिया को अंजाम देते हैं, तो आप इसके कोशों के मूल्यों को बिना शब्दकोश के ही सेट कर सकते हैं। बताने के लिए कुछ विशेष नहीं है, बस कोड देखें:

 struct { int i; real r; str s; } variable ~ [ i: 5, r: 3.14, s: "Hello!" ] int[5] arr ~ [ 1, 2, 3, 4, 5 ] 

फ़ंक्शन से कई मान लौटाएं

जैसे गो में! आप कई वैरिएबल नामों को अल्पविरामों द्वारा अलग-अलग लिख सकते हैं और उन्हें फ़ंक्शन से लौटाए गए सभी मानों को एक साथ सौंप सकते हैं:

 int, real function() { return 5, 3.14 } byte § { int i; real r i, r ~ function } 

हेडर के बजाय मॉड्यूल

यहाँ सब कुछ स्पष्ट है। सी-शर्मी हेडर के बजाय - जावा से मॉड्यूल।

के लिए (ऑटो आइटम: सरणी)

फिर से देशी जावा। चूंकि हमारे पास लंबाई के साथ सरणियाँ हैं, इसलिए प्रत्येक के लिए अभिव्यक्ति का उपयोग नहीं करना पाप है।

चयन ऑपरेटर सिर्फ इंट के लिए नहीं है

मुझे आपके बारे में पता नहीं है, लेकिन सी और सी ++ में मैं गैर-पूर्णांक चर के लिए स्विच-केस ऑपरेशन का उपयोग करने की क्षमता की कमी से बहुत नाराज हूं। और वाक्य विन्यास भी infuriates। यहाँ पास्कल में एक और मामला है। और अब लोलो में:

 case variable { "hello", "HELLO": nop "world": { nop; nop } "WORLD": nop } 

पॉवरिंग और डिवीजन ऑपरेटर

और यह पायथन से है।

 real r ~ 3.14 ** 2 int i ~ r // 3 

समारोह पैरामीटर tuples

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

 void function(...) { if (?.size > 1) { int i ~ ?[0] real r ~ ?[1] } } 

संख्यात्मक अंतराल

और एक अन्य चरित्र - अंतराल प्रकारों (रेंज, यूरेंज, लेंज, आदि) का एक परिवार। वे दो पूर्णांक दो बिंदुओं (..) के माध्यम से देते हैं और एक सरणी से एक सरणी काट सकते हैं, एक स्ट्रिंग से एक स्ट्रिंग, सामान्य रूप से, एक उपयोगी चीज, मुझे लगता है।

 int[5] arr ~ [ 1, 2, 3, 4, 5 ] int[3] subarr = arr[1..3] ;; [ 2, 3, 4 ] 

ऑपरेटर में

पास्कल से। तार, सरणियों, ट्यूपल्स के साथ काम करता है? और पर्वतमाला।

 int[5] arr ~ [ 1, 2, 3, 4, 5 ] if (4 in arr) nop 

समारोह पैरामीटर शब्दकोश

ईमानदारी से, मैं पहले से ही उलझन में हूँ कि इस चीज़ को सही तरीके से कैसे कहा जाता है, इसके साथ आप सीधे गैर-शुद्ध कार्यों के तर्कों को निर्दिष्ट कर सकते हैं:

 int pos = str_find(string, npos: -1) 

डिफ़ॉल्ट विकल्प

C ++ से। यहां, यहां तक ​​कि एक उदाहरण देने के लिए आवश्यक नहीं है, और इसलिए सब कुछ स्पष्ट है।

अपवाद

खैर, और उनके बिना कहाँ?

 try { raise SEGMENTATION_FAULT_EXCEPTION } except (Exception e) { print(e.rus) } 

बिना शर्त कूदना

क्योंकि 2019 में, मौत के गोटो ऑपरेटर का उपयोग करना समान है।

वाक्य-विन्यास

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

वास्तव में, उपरोक्त सभी में लोलो की आधी क्षमता शामिल नहीं है। मैं तुरंत इसकी सभी विशेषताओं को याद नहीं कर सकता। मैं जोड़ दूंगा क्योंकि कंपाइलर तैयार है।