जिग कैसे काम करता है?

अनुवादक से: यह पोस्ट 15 मार्च 2018 को लेखक के ब्लॉग पर प्रकाशित हुई थी। जैसे-जैसे कोई भाषा विकसित होती है, उसका वाक्य-विन्यास वर्तमान में भिन्न हो सकता है। वर्णित सब कुछ Zig 0.2.0 से संबंधित है, भाषा का वर्तमान संस्करण Zig 0.3.0 है।

मैंने पोस्ट के लेखक से संपर्क किया, और उन्होंने जिग 0.0.0 पर परियोजना स्रोतों के वर्तमान संस्करण के साथ रिपॉजिटरी का लिंक प्रदान किया

आपका स्वागत है! चलो एक Brainfuck दुभाषिया लिखें! "क्यों?" "आप पूछ सकते हैं, लेकिन आपको इसका जवाब नहीं मिलेगा।"

मैं इसे ज़िग पर करूंगा।

जिग है ...

... एक नई प्रोग्रामिंग भाषा। यह अभी भी बीटा में है और तेजी से विकसित हो रहा है। यदि आपने पहले Zig कोड देखा है, तो इस पोस्ट का कोड आपको कुछ अलग लग सकता है। वह वास्तव में अलग है! Zig 0.2.0 अभी जारी किया गया है, कुछ सप्ताह पहले LLVM 6 की रिलीज के साथ मेल खाता है, और इसमें कई सिंटैक्स परिवर्तन और सामान्य भाषा सुधार शामिल हैं। अधिकतर, कई "मंत्र" को कीवर्ड द्वारा बदल दिया गया है। सभी परिवर्तनों की गहन व्याख्या के लिए यहां देखें!

Zig को कुछ बिंदुओं पर, संकलित और टाइप की गई भाषाओं जैसे C, C ++, और कुछ बिंदुओं से परिचित लोगों के लिए पठनीय और अपेक्षाकृत सहज बनाया गया है ।

कोड को Zig 0.2.0 के साथ संकलित और परीक्षण किया गया था, जो होमबॉव सहित विभिन्न चैनलों के माध्यम से अभी उपलब्ध है, यदि आप OSX पर हैं: काढ़ा स्थापित करें।

चलिए शुरू करते हैं

यह जानने के लिए कि ब्रेनफक कैसे काम करता है, यहां देखें। वहाँ सीखने के लिए लगभग कुछ भी नहीं है, लेकिन यह एक ट्यूरिंग-पूर्ण भाषा है, जिसका अर्थ है कि आप इस पर कुछ भी लिख सकते हैं।

यदि आपने अंतिम उत्पाद या आरंभिक कमिट देखना चाहते हैं , तो मैंने यहां कोड पोस्ट किया है।

जिग एक संकलित भाषा है। जब आप एक प्रोग्राम संकलित करते हैं, तो परिणामी बाइनरी (यदि आप एक निष्पादन योग्य बाइनरी संकलित कर रहे हैं, तो पुस्तकालय नहीं) में एक मुख्य कार्य होना चाहिए जो प्रवेश बिंदु को चिह्नित करता है।

इसलिए ...

// main.zig fn main() void { } 

... और शुरू ...

 $ zig build-exe main.zig 

... बाहर देता है ...

 /zig/std/special/bootstrap.zig:70:33: error: 'main' is private /zigfuck/main.zig:2:1: note: declared here 

मॉड्यूल के बाहर दिखने के लिए मुख्य को सार्वजनिक घोषित किया जाना चाहिए ...

 // main.zig pub fn main() void { } 

ब्रेनफैक प्रोग्राम को स्मृति के रूप में 30,000 बाइट्स की एक सरणी का उपयोग करने दें, मैं इस तरह की एक सरणी बनाऊंगा।

 // main.zig pub fn main() void { const mem: [30000]u8; } 

मैं एक स्थिर (कॉन्स्टेंस) या एक वैरिएबल (var) घोषित कर सकता हूं। यहाँ, मैंने 30,000 अहस्ताक्षरित (यू) बाइट्स (8 बिट्स) की एक सरणी के रूप में मेम की घोषणा की।

यह संकलन नहीं है।

 /main.zig:3:5: error: variables must be initialized 

एक समतुल्य सी कार्यक्रम सामान्य रूप से संकलित करेगा: मैं एक चर को बिना किसी घोषणा के घोषित कर सकता हूं, लेकिन जिग मुझे एक निर्णय लेने के लिए मजबूर करता है, जिस समय चर घोषित किया जाता है। मुझे परवाह नहीं है कि इसमें क्या लिखा जाएगा, लेकिन मुझे स्पष्ट रूप से यह संकेत देना चाहिए। मैं अपरिभाषित मान (अपरिभाषित) के साथ चर को इनिशियलाइज़ करके ऐसा करूँगा।

 // main.zig pub fn main() void { const mem: [30000]u8 = undefined; } 

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

लेकिन शायद मुझे इस बात की परवाह नहीं है कि इस मेमोरी को कैसे इनिशियलाइज़ किया जाए। शायद मैं एक गारंटी चाहता हूं कि शून्य या कुछ मनमाना मूल्य वहां लिखे गए हैं। इस मामले में, मुझे यह स्पष्ट रूप से बताना चाहिए:

 // main.zig pub fn main() void { const mem = []u8{0} ** 30000; } 

यह अजीब लग सकता है, लेकिन ** ऑपरेटर को सरणियों का विस्तार करने के लिए उपयोग किया जाता है। मैं 0 बाइट्स की एक सरणी घोषित करता हूं, और फिर इसे 30,000 तक विस्तारित करता हूं, और 30,000 जीरो बाइट्स का अंतिम आरंभीकरण मूल्य प्राप्त करता हूं। यह ऑपरेशन एक बार, संकलन के समय होता है । compig Zig के महान विचारों में से एक है, और मैं इसमें से एक पोस्ट में वापस आऊंगा।

अब ब्रेनफैक पर एक प्रोग्राम लिखते हैं जो पांच मेमोरी स्लॉट को बढ़ाने के अलावा और कुछ नहीं करता है!

 pub fn main() void { const mem = []u8{0} ** 30000; const src = "+++++"; } 

ज़िग में, स्ट्रिंग बाइट सरणियाँ हैं। मुझे src को बाइट ऐरे के रूप में घोषित नहीं करना चाहिए, क्योंकि कंपाइलर इसका अर्थ है। यह वैकल्पिक है, लेकिन यदि आप चाहते हैं कि यह संभव है:

 const src: [5]u8 = "+++++"; 

यह ठीक संकलन करेगा। हालाँकि, यह:

 const src: [6]u8= "+++++"; 

नहीं होगा

 main.zig:5:22: error: expected type '[6]u8', found '[5]u8' 

एक और ध्यान दें: चूंकि तार सिर्फ सरणियाँ हैं, वे शून्य के साथ समाप्त नहीं होते हैं। हालांकि, आप एक शून्य-समाप्त स्ट्रिंग सी घोषित कर सकते हैं। एक शाब्दिक के रूप में, यह इस तरह दिखेगा:

 c"Hello I am a null terminated string"; 

आम अच्छे के लिए ...

मैं हर किरदार के साथ एक स्ट्रिंग में कुछ करना चाहता हूं। मैं यह कर सकता हूँ! Main.zig की शुरुआत में, मैं मानक पुस्तकालय से कुछ कार्यों का आयात करता हूं:

 const warn = @import("std").debug.warn; 

आयात , वस्तुतः @ चिह्न के साथ शुरू होने वाली सब कुछ, एक अंतर्निहित संकलक फ़ंक्शन है । ऐसी सुविधाएँ हमेशा विश्व स्तर पर उपलब्ध हैं। यहां आयात जावास्क्रिप्ट के समान काम करता है - आप नाम स्थान में खुदाई करके और किसी भी सार्वजनिक रूप से उपलब्ध कार्यों या चर से इसे निकालकर कुछ भी आयात कर सकते हैं। ऊपर दिए गए उदाहरण में, मैं सीधे चेतावनी फ़ंक्शन को आयात करता हूं और इसे अचानक असाइन करता हूं, चेतावनी देने वाले को। अब उसे बुलाया जा सकता है। यह एक सामान्य पैटर्न है: हम सीधे std नाम स्थान से आयात करते हैं और फिर या तो std.debug.warn () कॉल करते हैं या इसे चेतावनी चर में असाइन करते हैं। यह इस तरह दिखता है:

 const std = @import("std"); const warn = std.debug.warn; 

 const warn = @import("std").debug.warn; // main.zig pub fn main() void { const mem = []u8{0} ** 30000; const src = "+++++"; for (src) |c| { warn("{}", c); } } 

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

चेतावनी स्वरूपित स्ट्रिंग लेता है, जैसे C में Printf! ऊपर का कोड प्रिंट होगा:

 4343434343 

43 एससीआई वर्ण कोड + है। मैं भी लिख सकता हूं:

 warn("{c}", c); 

और:

 +++++ 

इसलिए, हमने मेमोरी स्पेस को इनिशियलाइज़ किया, और प्रोग्राम लिखा। अब हम भाषा को ही साकार कर रहे हैं। मैं + के साथ शुरू करूंगा, और स्विच के साथ लूप के शरीर को बदलूंगा:

 for (src) |c| { switch(c) { '+' => mem[0] += 1 } } 

मुझे दो त्रुटियां मिलीं:

 /main.zig:10:7: error: switch must handle all possibilities switch(c) { ^ /main.zig:11:25: error: cannot assign to constant '+' => mem[0] += 1 ^ 

बेशक, मैं एक वैरिएबल को नया मान नहीं दे सकता, जो एक स्थिर है! मेम को एक चर बनाने की जरूरत है ...

 var mem = []u8{0} ** 30000; 

अन्य त्रुटियों की तरह, मेरे स्विच निर्माण को पता होना चाहिए कि यदि चरित्र नहीं है तो क्या करना है, भले ही कुछ भी करने की आवश्यकता न हो। मेरे मामले में, यह वही है जो मैं चाहता हूं। मैं इस मामले को एक खाली ब्लॉक से भरता हूं:

 for (src) |c| { switch(c) { '+' => mem[0] += 1, else => {} } } 

अब मैं कार्यक्रम को संकलित कर सकता हूं। अंत में चेतावनी दें और चलाएं:

 const warn = @import("std").debug.warn; pub fn main() void { var mem = []u8{0} ** 30000; const src = "+++++"; for (src) |c| { switch(c) { '+' => mem[0] += 1, else => {} } } warn("{}", mem[0]); } 

जैसा कि मैंने उम्मीद की थी, मुझे नंबर 5 में मिला हुआ है।

चलो आगे बढ़ते हैं ...

इसी तरह, हम समर्थन करते हैं।

 switch(c) { '+' => mem[0] += 1, '-' => mem[0] -= 1, else => {} } 

> और <का उपयोग करने के लिए, आपको एक अतिरिक्त चर का उपयोग करने की आवश्यकता है, जो उस मेमोरी में "पॉइंटर" के रूप में कार्य करता है जिसे मैंने उपयोगकर्ता के ब्रेनफक प्रोग्राम के लिए आवंटित किया था।

 var memptr: u16 = 0; 

चूंकि एक अहस्ताक्षरित 16-बिट अधिकतम 65535 हो सकता है, यह पता स्थान के 30,000 बाइट्स को अनुक्रमित करने के लिए पर्याप्त से अधिक है।

वास्तव में, 15 बिट्स हमारे लिए पर्याप्त होंगे, जो हमें 32767 बाइट्स को संबोधित करने की अनुमति देता है। Zig विभिन्न चौड़ाई वाले प्रकारों की अनुमति देता है, लेकिन u15 अभी तक नहीं।

आप वास्तव में इस तरह से कर सकते हैं:

 const u15 = @IntType(false, 15): 

यह प्रस्तावित है कि कोई भी [iu] \ d + प्रकार पूर्णांक प्रकार के रूप में मान्य हो।

अब मेम [0] का उपयोग करने के बजाय, मैं इस चर का उपयोग कर सकता हूं।

 '+' => mem[memptr] += 1, '-' => mem[memptr] -= 1, 

<और> बस इस सूचक को बढ़ाएँ और घटाएँ।

 '>' => memptr += 1, '<' => memptr -= 1, 

अद्भुत। हम अब एक वास्तविक कार्यक्रम लिख सकते हैं!

1,2,3 की जाँच करें

जिग में बिल्ट-इन टेस्ट इंजन है। कहीं भी किसी भी फाइल में मैं एक टेस्ट ब्लॉक लिख सकता हूं:

 test "Name of Test" { // test code } 

और कमांड लाइन से टेस्ट रन करें: zig test $ FILENAME। बाकी परीक्षण ब्लॉक नियमित कोड के समान हैं।

आइए इसे देखें:

 // test.zig test "testing tests" {} zig test test.zig Test 1/1 testing tests...OK 

बेशक, एक खाली परीक्षण बेकार है। मैं वास्तव में परीक्षणों के निष्पादन की पुष्टि करने के लिए मुखर का उपयोग कर सकता हूं।

 const assert = @import("std").debug.assert; test "test true" { assert(true); } test "test false" { assert(false); } 

 zig test test.zig "thing.zig" 10L, 127C written :!zig test thing.zig Test 1/2 test true...OK Test 2/2 test false...assertion failure [37;1m_panic.7 [0m: [2m0x0000000105260f34 in ??? (???) [0m [37;1m_panic [0m: [2m0x0000000105260d6b in ??? (???) [0m [37;1m_assert [0m: [2m0x0000000105260619 in ??? (???) [0m [37;1m_test false [0m: [2m0x0000000105260cfb in ??? (???) [0m [37;1m_main.0 [0m: [2m0x00000001052695ea in ??? (???) [0m [37;1m_callMain [0m: [2m0x0000000105269379 in ??? (???) [0m [37;1m_callMainWithArgs [0m: [2m0x00000001052692f9 in ??? (???) [0m [37;1m_main [0m: [2m0x0000000105269184 in ??? (???) [0m [37;1m??? [0m: [2m0x00007fff5c75c115 in ??? (???) [0m [37;1m??? [0m: [2m0x0000000000000001 in ??? (???) [0m 

परीक्षण गिर गया। त्रुटि को पुन: उत्पन्न करने के लिए निम्न आदेश का उपयोग करें:

 ./zig-cache/test 

खसखस पर स्टैक ट्रेस अभी भी विकास के अधीन है।

इसे कुशलतापूर्वक परीक्षण करने के लिए, मुझे इसे टुकड़ों में तोड़ने की आवश्यकता है। आइए इसकी शुरुआत करें:

 fn bf(src: []const u8, mem: [30000]u8) void { var memptr: u16 = 0; for (src) |c| { switch(c) { '+' => mem[memptr] += 1, '-' => mem[memptr] -= 1, '>' => memptr += 1, '<' => memptr -= 1, else => {} } } } pub fn main() void { var mem = []u8{0} ** 30000; const src = "+++++"; bf(src, mem); } 

यह काम करना चाहिए, है ना?

लेकिन ...

 /main.zig:1:29: error: type '[30000]u8' is not copyable; cannot pass by value 

यह https://github.com/zig-lang/zig/issues/733 पर वर्णित है।

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

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

 fn bf(src: []const u8, mem: []u8) void { ... } 

और फ़ंक्शन को कॉल करते समय यह इस तरह दिखता है:

 bf(src, mem[0..mem.len]); 

ध्यान दें कि मैंने सरणी की लंबाई का उल्लेख करके ऊपरी सीमा को परिभाषित किया है। ऐसे मामलों के लिए एक संक्षिप्त संकेतन है:

 bf(src, mem[0..]); 

अब मैं सीधे बीएफ () फ़ंक्शन का परीक्षण करने वाले परीक्षण लिखना शुरू कर सकता हूं। मैं अभी के लिए फ़ाइल के अंत में परीक्षण कार्य जोड़ूंगा ...

 test "+" { var mem = []u8{0}; const src = "+++"; bf(src, mem[0..]); assert(mem[0] == 3); } 

मैं एक बाइट से मेम सरणी लेता हूं और फिर जांचता हूं कि क्या होना चाहिए (तीन बार बाइट बढ़ जाती है)। यह काम करता है!

 Test 1/1 +...OK 

"-" उसी तरह से जांचा जाता है:

 test "-" { var mem = []u8{0}; const src = "---"; bf(src, mem[0..]); assert(mem[0] == 253); } 

काम नहीं करता है! जब मैं 0 से 1 को घटाने की कोशिश करता हूं, तो मुझे मिलता है ...

 Test 2/2 -...integer overflow 

मेम अहस्ताक्षरित बाइट्स की एक सरणी है, और 0 से 1 घटाना एक अतिप्रवाह का कारण बनता है। फिर से, जिग मुझे घोषणा करता है कि मैं स्पष्ट रूप से क्या चाहता हूं। इस मामले में, मुझे अतिप्रवाह के बारे में चिंता करने की ज़रूरत नहीं है, वास्तव में, मैं चाहता हूं कि ऐसा हो, क्योंकि हम मॉड्यूलर अंकगणित के साथ काम कर रहे हैं, मस्तिष्क के विनिर्देश के अनुसार । इसका मतलब यह है कि 0 नंबर के साथ एक सेल घटने से मुझे 255 मिलेगा, और 255 का इंक्रीमेंट मुझे 0 देगा।

ज़िग के पास कई सहायक अंकगणितीय ऑपरेशन हैं जो गारंटीकृत "रैपिंग" के शब्दार्थ की पेशकश करते हैं।

 '+' => mem[memptr] +%= 1, '-' => mem[memptr] -%= 1, 

यह संपूर्ण अतिप्रवाह समस्या को हल करता है और वही करता है जिसकी मुझे उम्मीद थी।

<और> के परीक्षण के लिए, मैं एक छोटे सरणी के माध्यम से नेविगेट करता हूं और बढ़े हुए सेल के मूल्य की जांच करता हूं:

 test ">" { var mem = []u8{0} ** 5; const src = ">>>+++"; bf(src, mem[0..]); assert(mem[3] == 3); } 

और ...

 test "<" { var mem = []u8{0} ** 5; const src = ">>>+++<++<+"; bf(src, mem[0..]); assert(mem[3] == 3); assert(mem[2] == 2); assert(mem[1] == 1); } 

बाद के मामले में, मैं सीधे परिणाम का उपयोग करके स्थैतिक सरणी के साथ तुलना कर सकता हूं ...

 const mem = std.mem; 

याद रखें कि मैंने पहले ही std आयात कर लिया है। नीचे दिए गए उदाहरण में, मैं इस नाम स्थान में मेम का उपयोग करता हूं:

 test "<" { var storage = []u8{0} ** 5; const src = ">>>+++<++<+"; bf(src, storage[0..]); assert(mem.eql(u8, storage, []u8{ 0, 1, 2, 3, 0 })); } 

... और याद रखें, स्ट्रिंग शाब्दिक, ये सिर्फ u8 सरणियां हैं जिग में, और मैं उनमें हेक्साडेसिमल शाब्दिक डाल सकता हूं, अर्थात्। निम्नलिखित कोड उसी तरह से काम करेगा!

 assert(mem.eql(u8, storage, "\x00\x01\x02\x03\x00")); 

"जोड़ें!" यह केवल उस कक्ष में एक बाइट मान के रूप में प्रिंट करता है जो सूचक को इंगित करता है। मैं अब चेतावनी का उपयोग कर रहा हूं, लेकिन बाद में मैं इसे स्टडआउट से बदल दूंगा। यह वैचारिक रूप से करना आसान है, लेकिन कार्यान्वयन में कुछ हद तक उलझन में है। मैं इसे बाद में करूंगा!

 '.' => warn("{c}", storage[memptr]), 

चक्र
[और] - यहां से शुरू होता है जादू ...।

[- यदि वर्तमान सेल का मान शून्य है, तो कोड को निष्पादित किए बिना समापन ब्रैकेट में कदम छोड़ें।
] - यदि वर्तमान सेल का मान शून्य नहीं है, तो ओपनिंग ब्रैकेट में लौटें और कोड को फिर से निष्पादित करें।

इस बार मैं एक परीक्षण के साथ शुरू करूंगा, मैं उन्हें एक साथ परीक्षण करूंगा (जाहिर है, इसका अलग से परीक्षण करने का कोई मतलब नहीं है)। पहला परीक्षण मामला - स्टोरेज [2] सेल खाली होना चाहिए, हालांकि लूप शुरू होने पर इसे बढ़ाना चाहिए:

 test "[] skips execution and exits" { var storage = []u8{0} ** 3; const src = "+++++>[>+++++<-]"; bf(src, storage[0..]); assert(storage[0] == 5); assert(storage[1] == 0); assert(storage[2] == 0); } 

और मैं स्विच स्टेटमेंट के लिए रिक्त स्थान बनाऊंगा:

 '[' => if (storage[memptr] == 0) { }, ']' => if (storage[memptr] == 0) { }, 

अब क्या करें? आप एक भोली दृष्टिकोण का उपयोग कर सकते हैं। मैं अभी तक src पॉइंटर को बढ़ाता हूं जब तक कि मुझे यह नहीं मिल जाता]। लेकिन मैं इसके लिए zig में लूप के लिए उपयोग नहीं कर सकता, यह केवल उनके तत्वों को याद किए बिना, संग्रह के माध्यम से पुनरावृत्ति के लिए बनाया गया था। एक उपयुक्त निर्माण यहाँ है:

यह था:

 var memptr: u16 = 0; for (src) |c| { switch(c) { ... } } 

बन गया ...

 var memptr: u16 = 0; var srcptr: u16 = 0; while (srcptr < src.len) { switch(src[srcptr]) { ... } srcptr += 1; } 

अब मैं ब्लॉक के बीच में srcptr पॉइंटर को पुन: असाइन कर सकता हूं, मैं यह करूंगा:

 '[' => if (storage[memptr] == 0) { while (src[srcptr] != ']') srcptr += 1; }, 

यह परीक्षण को संतुष्ट करता है "[] कोड निष्पादन को समाप्त करता है और बाहर निकलता है"
यह परीक्षण को संतुष्ट करता है "[निष्पादन को रोक देता है और बाहर निकलता है", हालांकि पूरी तरह से विश्वसनीय नहीं है, जैसा कि हम देखेंगे।

कोष्ठक बंद करने के बारे में क्या? मेरा मानना ​​है कि इसे सादृश्य द्वारा लिखा जा सकता है:

 test "[] executes and exits" { var storage = []u8{0} ** 2; const src = "+++++[>+++++<-]"; bf(src, storage[0..]); assert(storage[0] == 0); assert(storage[1] == 25); } ']' => if (storage[memptr] != 0) { while (src[srcptr] != '[') srcptr -= 1; }, 

आप देख सकते हैं कि क्या होता है ... दो कोष्ठक के साथ एक भोले समाधान में एक घातक दोष होता है और पूरी तरह से नेस्टेड छोरों पर टूट जाता है। निम्नलिखित पर विचार करें:

 ++>[>++[-]++<-] 

परिणाम {2, 0} होना चाहिए, लेकिन पहला खुला ब्रैकेट केवल बेवकूफी से पहले समापन ब्रैकेट में जाता है, और सब कुछ गड़बड़ हो जाता है। आपको घोंसले के शिकार के समान अगले समापन ब्रैकेट में कूदने की आवश्यकता है। एक गहराई काउंटर को जोड़ना और इसे ट्रैक करना आसान है क्योंकि आप लाइन के साथ आगे बढ़ते हैं। हम इसे दोनों दिशाओं में करते हैं:

 '[' => if (storage[memptr] == 0) { var depth:u16 = 1; srcptr += 1; while (depth > 0) { srcptr += 1; switch(src[srcptr]) { '[' => depth += 1, ']' => depth -= 1, else => {} } } }, ']' => if (storage[memptr] != 0) { var depth:u16 = 1; srcptr -= 1; while (depth > 0) { srcptr -= 1; switch(src[srcptr]) { '[' => depth -= 1, ']' => depth += 1, else => {} } } }, 

और संबंधित परीक्षण: ध्यान दें कि दोनों परीक्षणों में src में एक आंतरिक लूप शामिल है।

 test "[] skips execution with internal braces and exits" { var storage = []u8{0} ** 2; const src = "++>[>++[-]++<-]"; try bf(src, storage[0..]); assert(storage[0] == 2); assert(storage[1] == 0); } test "[] executes with internal braces and exits" { var storage = []u8{0} ** 2; const src = "++[>++[-]++<-]"; try bf(src, storage[0..]); assert(storage[0] == 0); assert(storage[1] == 2); } 

अलग से, ध्यान दें [-] - ब्रेनफक का मुहावरा, जिसका अर्थ है "इस सेल को शून्य करें।" आप देख सकते हैं कि इससे कोई फर्क नहीं पड़ता कि सेल की शुरुआत में क्या मूल्य था, इसे 0 तक पहुंचने तक घटाया जाएगा, और फिर निष्पादन जारी रहेगा।

अशुभ मार्ग

मैंने इस संभावना पर भरोसा नहीं किया कि बीएफ पर कार्यक्रम टूट जाएगा। यदि मैं अपने दुभाषिया को गलत इनपुट प्रोग्राम प्रस्तुत करता हूं तो क्या होगा? उदाहरण के लिए, बस [एक बंद ब्रैकेट के बिना, या <, जो तुरंत मेमोरी एरे से आगे निकल जाता है? (मैं मेमोरी पॉइंटर को लपेट सकता हूं, लेकिन इसे एक त्रुटि के रूप में मानना ​​बेहतर है)।

मैं थोड़ा आगे देखने जा रहा हूं और कोड के सभी अंतरों को समझाऊंगा। मैं bf दुभाषिया फ़ंक्शन को एक अलग फ़ाइल में डालूँगा और अपने छोटे कार्यों में भी चाहना और चाहने वाली कार्यक्षमता डाल सकता हूँ।

 const warn = @import("std").debug.warn; const sub = @import("std").math.sub; fn seekBack(src: []const u8, srcptr: u16) !u16 { var depth:u16 = 1; var ptr: u16 = srcptr; while (depth > 0) { ptr = sub(u16, ptr, 1) catch return error.OutOfBounds; switch(src[ptr]) { '[' => depth -= 1, ']' => depth += 1, else => {} } } return ptr; } fn seekForward(src: []const u8, srcptr: u16) !u16 { var depth:u16 = 1; var ptr: u16 = srcptr; while (depth > 0) { ptr += 1; if (ptr >= src.len) return error.OutOfBounds; switch(src[ptr]) { '[' => depth += 1, ']' => depth -= 1, else => {} } } return ptr; } pub fn bf(src: []const u8, storage: []u8) !void { var memptr: u16 = 0; var srcptr: u16 = 0; while (srcptr < src.len) { switch(src[srcptr]) { '+' => storage[memptr] +%= 1, '-' => storage[memptr] -%= 1, '>' => memptr += 1, '<' => memptr -= 1, '[' => if (storage[memptr] == 0) srcptr = try seekForward(src, srcptr), ']' => if (storage[memptr] != 0) srcptr = try seekBack(src, srcptr), '.' => warn("{c}", storage[memptr]), else => {} } srcptr += 1; } } 

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

मैंने कुछ महत्वपूर्ण बातें जोड़ीं! ध्यान दें कि सभी तीन फ़ंक्शंस अब एक प्रकार लौट रहे हैं! .. यह नया सिंटैक्स है जो टाइप% T (त्रुटि संघ) के रूप में उपयोग किया जाता है। इसका मतलब है कि फ़ंक्शन कुछ निश्चित प्रकार या त्रुटि को वापस कर सकता है। जब मैं ऐसे फ़ंक्शन को कॉल करने का प्रयास करता हूं, तो मुझे फ़ंक्शन को कॉल करने से पहले या तो उपयोग करने का प्रयास करना चाहिए, जो त्रुटि होने पर कॉल स्टैक को त्रुटि को फेंकता है, या कैच का उपयोग करें:

 const x = functionCall() catch {} 

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

 const x = functionCall() catch { @panic("TODO") } 

याद रखें कि ऐसा मामला उत्पादन कोड में कभी नहीं होगा। मैं संकलक को सूचित कर रहा हूं कि मुझे पता है कि मैं क्या कर रहा हूं। यदि कोई त्रुटि हो सकती है, तो मुझे त्रुटि हैंडलिंग को जोड़ना होगा।

तो मुझे सीकबैक या सीकवर्ड से क्या त्रुटियां वापस आनी चाहिए?

तलाश में:

 ptr = sub(u16, ptr, 1) catch return error.OutOfBounds; 

मैंने std lib के उप फ़ंक्शन का उपयोग करने के लिए डिक्रिमेंट पॉइंटर को प्रतिस्थापित किया, जो ओवरफ्लो होने पर एक अतिप्रवाह त्रुटि को फेंकता है। मैं इस त्रुटि को पकड़ना चाहता हूं और इसके बजाय आउटऑफबाउंड त्रुटि लौटाता हूं, जिसे मैं सिर्फ इसका उपयोग करके बनाता हूं।

त्रुटियाँ Zig मूल रूप से त्रुटि कोड की एक सरणी है जो कंपाइलर द्वारा त्रुटि का उपयोग करने पर उत्पन्न होती है। किसी प्रकार की त्रुटि। वे अद्वितीय होने की गारंटी देते हैं और एक स्विच ब्लॉक में मूल्यों के रूप में उपयोग किया जा सकता है।

मैं यहां आउटऑफबाउंड्स का उपयोग करना चाहता हूं क्योंकि, शब्दार्थ, यदि मेमोरी पॉइंटर शून्य से कम हो जाता है, तो मैं रनटाइम को उस मेमोरी स्पेस से परे जाने के लिए कहता हूं जिसे मैंने आवंटित किया था।

इसी तरह के चाहने वाले समारोह में:

 if (ptr >= src.len) return error.OutOfBounds; 

इस स्थिति में, यदि सूचक src.len से बड़ा है, तो मैं यहां त्रुटि पकड़ता हूं और उसी त्रुटि को वापस करता हूं।

कॉल करते समय:

 '[' => if (storage[memptr] == 0) srcptr = try seekForward(src, srcptr), ']' => if (storage[memptr] != 0) srcptr = try seekBack(src, srcptr), 

मैं इन कार्यों को कॉल करने का प्रयास करता हूं। यदि उन्हें सफलतापूर्वक कहा जाता है, तो उन्हें सही तरीके से निष्पादित किया जाता है, और रिटर्न srcptr का प्रयास करें। यदि वे असफल होते हैं, तो फ़ंक्शन को समाप्त करने का प्रयास करें और कॉल के स्थान पर संपूर्ण फ़ंक्शन bf में त्रुटि देता है।

कॉल मुख्य से हो सकता है!

 const bf = @import("./bf.zig").bf; // yes, hello const hello_world = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>."; pub fn main() void { storage = []u8{0} ** 30000; bf(hello_world, storage[0..]) catch {}; } 

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

नया प्रयास / कैच सिंटैक्स, %% और% जैसे कई मंत्रों को समाप्त कर देता है, जिसे लोग इतना नापसंद करते हैं।

अब मैंने 8 में से 7 ब्रेनफुक वर्णों को लागू किया है, और यह एक "सार्थक" कार्यक्रम चलाने के लिए पर्याप्त है।

एक सार्थक कार्यक्रम

यहाँ कार्यक्रम है:

 //   ,   const fib = "++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++>++++++++++++++++>>+<<[>>>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>[<+>-]>[-]>>>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]>>[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]<[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]<<<++++++++++++++++++++++++++++++++++++++++++++++++.[-]<<<<<<<.>.>>[>>+<<-]>[>+<<+>-]>[<+>-]<<<-]<<++..."; 

चलिए ...

 pub fn main() void { storage = []u8{0} ** 30000; bf(fib, storage[0..]) catch {}; } 

देखा!

 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 121, 98, 219, 

80 के दशक में पीबीएस (पब्लिक ब्रॉडकास्टिंग सर्विस, एक अमेरिकन नॉन-कमर्शियल टेलीविज़न ब्रॉडकास्टिंग सर्विस) प्रोग्राम के बारे में पता चलने पर मुझे एक स्मृति हर बार मेरे पास वापस आती है। मुझे लगा कि इसे भुला दिया जाएगा, लेकिन Youtube बहुत अच्छी चीज है ।

मैं इसे कैसे सुधार सकता हूं?

मैंने पहले ही कुछ TODO पर संकेत दिया है। मुझे आउटपुट के लिए stderr का उपयोग नहीं करना चाहिए था। मैं स्टडआउट का उपयोग करना चाहता हूं।

हर बार जब मैं दुभाषिया खोलता हूं, मैं स्ट्रीम को स्ट्रीमआउट में खोलता हूं और उसमें प्रिंट करता हूं:

 const io = std.io; ... pub fn bf(src: []const u8, storage: []u8) !void { const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream); ... '.' => stdout.print("{c}", storage[memptr]) catch unreachable, ... 

यहाँ क्या हो रहा है?मैं io.getStdOut () को कॉल करता हूं, जो त्रुटियों को उत्पन्न कर सकता है (और फिर से, मैं स्पष्ट रूप से पकड़ में नहीं आने वाली संभावित त्रुटि को निगल सकता हूं - यदि यह फ़ंक्शन त्रुटि देता है, तो प्रोग्राम क्रैश हो जाएगा!)। मैं स्ट्रीम को इनिशियलाइज़ करता हूं, इसके लिए एक पॉइंटर लेता हूं, और इसे एक आउटपुट स्ट्रीम के रूप में इनिशियलाइज़ करता हूं, जिसे मैं प्रिंट कॉल करके लिख सकता हूं। प्रिंट एक स्वरूपित स्ट्रिंग को स्वीकार करता है, ठीक उसी तरह जैसे कि चेतावनी देता है, इसलिए सीधे जगह लेता है। प्रिंट भी एक त्रुटि उत्पन्न कर सकता है, और मैं इन त्रुटियों को भी निगलता हूं।

एक सही ढंग से लिखे गए कार्यक्रम में, मुझे stdout खोलने की संभावित त्रुटियों को ध्यान में रखना चाहिए, साथ ही stdout को लिखने के प्रयासों की संभावित त्रुटियों को भी ध्यान में रखना चाहिए। Zig इन त्रुटियों को अनदेखा करना बहुत आसान बनाता है जब तक आप जानते हैं कि आप उन्हें अनदेखा कर रहे हैं।

क्या होता है अगर मैं तय करता हूं कि मैं अपने प्रोटोटाइप को रिलीज़ में बदलना चाहता हूं? क्या मैं एक कप कॉफी के साथ बैठूंगा और त्रुटियों के हर संभव मामले को सूचीबद्ध करने के लिए दशकों के अनुभव और ज्ञान पर भरोसा करते हुए त्रुटियों को संभालने का एक कृतघ्न काम करूंगा, और मैं इसे कैसे संभाल सकता हूं? लेकिन क्या होगा अगर मेरे पास दशकों का अनुभव और ज्ञान नहीं है? यह ठीक है, Zig यह कर देगा!

मैं एक शक्तिशाली चीज, त्रुटि आउटपुट प्रदर्शित करना चाहता हूं!

 const bf = @import("./bf.zig").bf; const warn = @import("std").debug.warn; const serpinsky = "++++++++[>+>++++<<-]>++>>+<[-[>>+<<-]+>>]>+[ -<<<[ ->[+[-]+>++>>>-<<]<[<]>>++++++[<<+++++>>-]+<<++.[-]<< ]>.>+[>>]>+ ] "; pub fn main() void { var storage = []u8{0} ** 30000; bf(serpinsky, storage[0..]) catch unreachable; } 

मुझे पता है कि bf त्रुटियों को उत्पन्न कर सकता है क्योंकि यह वापस आ जाता है! मैं मुख्य समारोह में, कॉल पक्ष पर इस त्रुटि को निगलता हूं। जब मैं अपने भाग्य को स्वीकार करने और सही काम करने के लिए तैयार हूं, तो मैं इस तरह की संभावित त्रुटियों को पकड़ सकता हूं:

 const bf = @import("./bf.zig").bf; const warn = @import("std").debug.warn; const serpinsky = "++++++++[>+>++++<<-]>++>>+<[-[>>+<<-]+>>]>+[ -<<<[ ->[+[-]+>++>>>-<<]<[<]>>++++++[<<+++++>>-]+<<++.[-]<< ]>.>+[>>]>+ ] "; pub fn main() void { var storage = []u8{0} ** 30000; bf(serpinsky, storage[0..]) catch |err| switch (err) { }; } 

संकलक अब मेरा दोस्त है!

 /Users/jfo/code/zigfuck/main.zig:7:46: error: error.OutOfBounds not handled in switch shell returned 1 

यह त्रुटि आपको परिचित होनी चाहिए, क्योंकि इसे bf और सहायक कार्यों से उठाया गया था! लेकिन आइए कल्पना करें कि मैं stdout द्वारा उत्पन्न त्रुटियों को देखता हूं जो मैंने bf में निगल लिया था। उन्हें निगलने के बजाय, मुझे कोशिश करके चेन को धक्का देना चाहिए। याद रखें कि फंक्शन के लिए कॉल का उपयोग करना जो बिना पकड़ के त्रुटियों को उत्पन्न करता है, हम कोशिश का उपयोग करते हैं, जो किसी भी संभावित त्रुटि के हैंडलिंग के साथ कॉलिंग फ़ंक्शन प्रदान करते हुए फ़ंक्शन को समाप्त करता है।

इसलिए, इसके बजाय:

 const io = std.io; ... pub fn bf(src: []const u8, storage: []u8) !void { const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream); ... '.' => stdout.print("{c}", storage[memptr]) catch unreachable, ... 

हम करते हैं:

 const io = std.io; ... pub fn bf(src: []const u8, storage: []u8) !void { const stdout = &(io.FileOutStream.init(&(try io.getStdOut())).stream); ... '.' => try stdout.print("{c}", storage[memptr]), ... 

हम संकलन करते हैं:

 const bf = @import("./bf.zig").bf; const warn = @import("std").debug.warn; const serpinsky = "++++++++[>+>++++<<-]>++>>+<[-[>>+<<-]+>>]>+[ -<<<[ ->[+[-]+>++>>>-<<]<[<]>>++++++[<<+++++>>-]+<<++.[-]<< ]>.>+[>>]>+ ] "; pub fn main() void { var storage = []u8{0} ** 30000; bf(serpinsky, storage[0..]) catch |err| switch (err) { }; } 

और सभी संभावित त्रुटियों की एक सूची प्राप्त करें जो मैं फ़ंक्शन को कॉल करके प्राप्त कर सकता हूं!

 /Users/jfo/code/zigfuck/main.zig:7:46: error: error.SystemResources not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.OperationAborted not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.IoPending not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.BrokenPipe not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.Unexpected not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.WouldBlock not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.FileClosed not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.DestinationAddressRequired not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.DiskQuota not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.FileTooBig not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.InputOutput not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.NoSpaceLeft not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.AccessDenied not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.OutOfBounds not handled in switch /Users/jfo/code/zigfuck/main.zig:7:46: error: error.NoStdHandles not handled in switch shell returned 1 

जिग मुझे इन त्रुटियों को ध्यान से संभालने का अवसर देता है यदि मैं चाहता हूं या कर सकता हूं! मैं त्रुटि मानों के आधार पर एक स्विच बना रहा हूं, यदि मैं चाहता हूं तो मामलों को संभालना और अगर मैं उन्हें छोड़ना चाहता हूं तो स्किप करना।

 pub fn main() void { var storage = []u8{0} ** 30000; bf(serpinsky, storage[0..]) catch |err| switch (err) { error.OutOfBounds => @panic("Out Of Bounds!"), else => @panic("IO error") }; } 

यह अभी भी सही त्रुटि से निपटने, सख्ती से बोलने नहीं है, लेकिन मैं सिर्फ यह दिखाना चाहता हूं कि कॉलिंग फ़ंक्शन में सभी प्रकार के त्रुटि मामलों की रिपोर्ट करके स्मार्ट जिग कितना अच्छा है! और जब कोई त्रुटि होती है, तो आपको स्टैक ट्रेस के बजाय एक त्रुटि ट्रेस मिलता है ! मस्त चीज़!

तोदो

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

निष्कर्ष

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

मैंने ज़िग के सिंटैक्स और विशेषताओं का केवल एक छोटा सा हिस्सा वर्णित किया है, कई दिलचस्प बदलाव हैं जो संस्करण 0.2.0 और उच्चतर भाषा में आए हैं! मेरे द्वारा लिखे गए सभी कोड को डिबग मोड में संकलित किया गया है, जो सुरक्षा जांच के लिए इष्टतम है और पुनरावृत्तियों को तेज करने के लिए संकलन समय को कम करने के लिए! --Release-fast और --release-safe मोड हैं, और भविष्य में और भी बहुत कुछ होगा । आप यहाँ इन विधियों के बारे में उनके मतभेदों और स्पष्टीकरणों के बारे में अधिक पढ़ सकते हैं ।

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

, #zig freenode , .