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

लेख का पहला भाग यहां पाया जा सकता है ।

दृश्यपटल

फ्रंटेंड का कार्य स्रोत कोड से एक मध्यवर्ती प्रतिनिधित्व उत्पन्न करना और इसे एलएलवीएम में स्थानांतरित करना है। इस प्रक्रिया को 8 चरणों में विभाजित किया जा सकता है। लगभग प्रत्येक का परिणाम संकलक के लिए एक विशेष पैरामीटर पारित करके प्रदर्शित किया जा सकता है।

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

{{{678}}} 

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

प्रत्येक स्कोप में एक ओपनिंग ब्रैकेट, कंटेंट और एक क्लोजिंग ब्रैकेट होता है। इसे इस तरह लिखा जा सकता है:

 scope ::= open_brace x close_brace open_brace ::= "{" close_brace ::= "}" 

सामग्री समान क्षेत्र, संख्या, या यहाँ इंगित की गई कुछ भी हो सकती है :

 scope ::= open_brace x close_brace x ::= scope | number | <empty> open_brace ::= "{" close_brace ::= "}" 

प्रतीक | का अर्थ है "या।" एक संख्या में एक या अधिक अंक होते हैं:

 scope ::= open_brace x close_brace x ::= scope | number | <empty> open_brace ::= "{" close_brace ::= "}" number ::= digit | number digit digit :: = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" 

इस तरह के रिकॉर्ड को बैकस-नौर (बीएनएफ) फॉर्म कहा जाता है, और सभी नियमों की समग्रता को भाषा या वाक्य रचना का व्याकरण कहा जाता है।

एक बढ़ा हुआ BPF (RBNF) भी है। अतिरिक्त विशेष वर्ण इसमें जोड़े गए थे, उदाहरण के लिए, समूहन के लिए कोष्ठक।

घुंघराले ब्रेसिज़ पुनरावृत्ति का संकेत देते हैं। इस तरह के रिकॉर्ड का मतलब है कि A, B की किसी भी संख्या के बराबर या बराबर है:

 A ::= { B } 

स्क्वायर ब्रैकेट का उपयोग सशर्त घटनाओं के लिए किया जाता है। इस तरह के रिकॉर्ड का मतलब है कि A या तो खाली है या B के बराबर है:

 A ::= [B] 

RBNF को लघुकोणीय संकलक के व्याकरण का उपयोग करके, आप इसे इस रूप में परिवर्तित कर सकते हैं:

 scope ::= open_brace [scope | number] close_brace open_brace ::= "{" close_brace ::= "}" number ::= digit {digit} digit :: = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" 

कोष्ठक संकलक के अलावा, मैं दिखाऊंगा कि एक सरल अभिव्यक्ति के उदाहरण का उपयोग करके प्रत्येक चरण के परिणाम प्राप्त करने के लिए स्विफ्ट संकलक का उपयोग कैसे करें:

 let x = 16 

कोड को समझना आसान बनाने के लिए इतना सरल है। एक वास्तविक प्रोग्रामिंग भाषा का व्याकरण उपरोक्त की तुलना में बहुत अधिक जटिल है। आप आधिकारिक वेबसाइट पर स्विफ्ट सिंटैक्स को देख सकते हैं।

lexer

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

यह लेक्सिकल एनालाइज़र (lexer / tokenizer) द्वारा किया जाता है। वह जो शब्द चाहता है, उसे टोकन या टोकन कहा जाता है (हम अनावश्यक विवरणों में नहीं जाएंगे और इन शब्दों को समान रूप से स्वीकार करेंगे)। इसलिए, इस प्रक्रिया को टोकन भी कहा जाता है।

लेक्सर भाषा के वाक्य-विन्यास के अनुसार विश्लेषण करता है। प्रतीक द्वारा स्कैन करना, यह स्रोत कोड के पत्राचार और रिकॉर्ड के दाईं ओर पाता है, और फिर बाईं ओर से संबंधित टोकन उत्पन्न करता है।

लेक्सर कार्यान्वयन उदाहरण

व्याकरण तीन टोकन की अनुमति देता है: एक उद्घाटन ब्रैकेट, एक समापन ब्रैकेट और एक संख्या। उन्हें एक प्रतिज्ञान के रूप में प्रस्तुत किया जाता है। साथ ही संभावित त्रुटियों की सूची:

 enum Token: CustomStringConvertible { case openBraceToken case closeBraceToken case number(Int) var description: String { switch self { case .openBraceToken: return "openBraceToken" case .closeBraceToken: return "closeBraceToken" case .number(let value): return "\(value)" } } } enum LexerError: Error { case unexpectedCharacted case invalidNumber } 

लेक्सर में ही, वर्तमान वर्ण के इनपुट स्ट्रिंग और इंडेक्स को संग्रहीत किया जाता है:

 class Lexer { private let string: String private var index: String.Index private var currentCharacter: Character? { return index != string.endIndex ? string[index] : nil } init(string: String) { self.string = string index = string.startIndex } 

विश्लेषण startAnalyze () विधि को कॉल करके शुरू किया गया है। इसमें, अगले टोकन को प्राप्त करने के लिए एक विधि को लूप में कहा जाता है, जिसे सरणी में जोड़ा जाता है। अंत में - मान्यता त्रुटियों की अवरोधन:

 func startAnalyzing() -> [Token] { var result: [Token] = [] do { while let token = try getNextToken() { result.append(token) } } catch LexerError.unexpectedCharacted { print("Unexpected character at index \(index.encodedOffset)") result = [] } catch LexerError.invalidNumber { print("Invalid number at index \(index.encodedOffset)") result = [] } catch { print("Unexpected error") result = [] } return result } 

टोकन प्राप्त करने में वर्तमान वर्ण की जांच करना और सूचकांक को एक या अधिक वर्णों को आगे बढ़ाना शामिल है:

 private func getNextToken() throws -> Token? { guard let character = currentCharacter else { return nil } switch character { case "{": return getOpenBrace() case "}": return getCloseBrace() default: break } if let scalar = character.unicodeScalars.first, CharacterSet.decimalDigits.contains(scalar) { return try getNumber() } throw LexerError.unexpectedCharacted } private func getOpenBrace() -> Token { moveIndex() return Token.openBraceToken } private func getCloseBrace() -> Token { moveIndex() return Token.closeBraceToken } 

यदि कोई अंक पाया जाता है, तो गेटनंबर () विधि को इसे पार्स करने के लिए कहा जाता है। यह बस सभी अंकों को एक पंक्ति में एकत्रित करता है और इसे Int में परिवर्तित करता है:

 private func getNumber() throws -> Token { var numberString = "" while let character = currentCharacter, let scalar = character.unicodeScalars.first, CharacterSet.decimalDigits.contains(scalar) { numberString.append(character) moveIndex() } guard let number = Int(numberString) else { throw LexerError.invalidNumber } return Token.number(number) } 

लेसर को शुरू करने के लिए, आपको इसे स्रोत कोड के साथ एक लाइन पास करने की आवश्यकता है और स्टार्टअनलीज़ () विधि को कॉल करें:

 let lexer = Lexer(string: "{{5678}}") let tokens = lexer.startAnalyzing() 

परिणाम अपेक्षाओं को पूरा करता है:

 [openBraceToken, openBraceToken, 5678, closeBraceToken, closeBraceToken] 

स्विफ्ट में, लेसर पार्सर का हिस्सा है, और आपको स्रोत कोड के अनुरूप टोकन की सूची नहीं मिल सकती है।

स्रोत कोड:

• Lexer.h
• Lexer.cpp

पार्सर

पार्सर पार्सिंग करता है। टोकन का एक अनुक्रम इनपुट को प्रेषित किया जाता है, और कार्य का परिणाम एएसटी है।

एएसटी एक ग्राफ है जिसमें कोने ऑपरेटर हैं और पत्तियां उनके ऑपरेंड हैं। उदाहरण के लिए, अभिव्यक्ति 1 + (2 * 3) में दो ऑपरेटर होते हैं: जोड़ और गुणा। जोड़ का पहला ऑपरेंड 1 है, और दूसरा उत्पादों 2 और 3 का परिणाम है। ग्रुपिंग ब्रैकेट एएसटी में उपयोग नहीं किए जाते हैं, क्योंकि वे आवश्यक नहीं हैं। ग्राफ़ स्वयं ऑपरेशनों के घोंसले का निर्धारण करता है:

प्रत्येक नोड का प्रतिनिधित्व किया जा सकता है, उदाहरण के लिए, एक संरचना या बाल तत्वों से युक्त एक गणना द्वारा।

पेड़ के निर्माण के दौरान, पार्सर भाषा के व्याकरण की जांच करता है: क्या सही अनुक्रम "शब्दों" से बना है। उदाहरण के लिए, स्ट्रिंग "{{}" को सफलतापूर्वक लेक्सर द्वारा पार्स किया जाएगा, लेकिन यह गलत है क्योंकि दूसरा समापन ब्रैकेट गायब है।

स्विफ्ट पार्सर एक पुनरावर्ती अवरोही पार्सर है। इसका मतलब यह है कि वह पहले एक बाहरी इकाई पाता है, और फिर अपनी सामग्री का पुनरावर्ती विश्लेषण करता है। आरोही पार्सर पहले सबसे नेस्टेड इकाई पाता है, और फिर ऊपर उठता है।

पार्सर कार्यान्वयन उदाहरण

पार्सर्स के प्रकार और कार्यान्वयन की एक बड़ी संख्या है। नीचे स्पष्ट रूप से अंतर प्रदर्शित करने के लिए एक अवरोही और आरोही पार्सर का सबसे सरल कार्यान्वयन है।

दोनों पार्सरों के लिए आम एक गणना होगी जो त्रुटियों और एएसटी नोड में से एक का प्रतिनिधित्व करती है:

 indirect enum ASTNode: CustomStringConvertible { case brace(childNode: ASTNode?) case number(value: Int) var description: String { switch self { case let .brace(childNode?): return "brace(\(childNode.description))" case .brace(nil): return "brace(nil)" case let .number(value): return "\(value)" } } } enum ParserError: Error { case expectedOpenBrace case expectedCloseBrace case expectedNumber case expectedEndOfArray } 

अवरोही परसर

एक नीचे वाला पार्सर टोकन की एक सरणी और वर्तमान टोकन का एक सूचकांक संग्रहीत करता है:

 class TopDownParser { private let tokens: [Token] private var index: Int private var currentToken: Token? { return index != tokens.endIndex ? tokens[index] : nil } init(tokens: [Token]) { self.tokens = tokens index = tokens.startIndex } 

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

 func startParsing() -> ASTNode? { var rootNode: ASTNode? do { rootNode = try parseBraces() guard currentToken == nil else { rootNode = nil throw ParserError.expectedEndOfArray } } catch ParserError.expectedCloseBrace { print("Expected close brace at index \(index)") } catch ParserError.expectedOpenBrace { print("Expected open brace at index \(index)") } catch ParserError.expectedEndOfArray { print("Expected end of tokens array at index \(index)") } catch { print("Unexpected error") } return rootNode } 

जब कोष्ठक को पार्स करते हैं, तो खोलने वाले ब्रैकेट को पहले स्कैन किया जाता है, फिर जोड़ी (यदि कोई है) के भीतर पुनरावर्ती सामग्री, और अंत में समापन ब्रैकेट।

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

 private func parseBraces() throws -> ASTNode? { try consumeOpenBrace() print("Pair found") let node: ASTNode? if let currentToken = self.currentToken, case .openBraceToken = currentToken { node = .brace(childNode: try parseBraces()) } else if let currentToken = self.currentToken, case let .number(value) = currentToken { node = .brace(childNode: .number(value: value)) try consumeNumber() } else { node = .brace(childNode: nil) } try consumeCloseBrace() return node } 

स्कैनिंग में टोकन की जांच करना और वर्तमान सूचकांक को स्थानांतरित करना शामिल है:

 private func consumeOpenBrace() throws { if let currentToken = self.currentToken, case .openBraceToken = currentToken { print("Open brace found") moveIndex() } else { throw ParserError.expectedOpenBrace } } 

आरोही पार्सर

एक अपस्ट्रीम पार्सर को लागू करना थोड़ा अधिक जटिल है। उसे अपना राज्य, टोकन का एक ढेर और राज्यों के बीच एक रूपांतरण तालिका रखने की आवश्यकता है।

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

 class BottomUpParser { private enum State { case state1 case state2 } 

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

 private let tokens: [Token] private var index: Int private var state: State = .state1 private var stack: [Token] = [] private var rootNode: ASTNode? private var currentToken: Token? { return index != tokens.endIndex ? tokens[index] : nil } init(tokens: [Token]) { self.tokens = tokens index = tokens.startIndex } 

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

 func startParsing() -> ASTNode? { do { guard !tokens.isEmpty else { throw ParserError.expectedOpenBrace } while index != tokens.endIndex { try parseNextToken() moveIndex() } guard stack.isEmpty else { rootNode = nil throw ParserError.expectedCloseBrace } } catch ParserError.expectedCloseBrace { rootNode = nil print("Expected close brace at index \(index)") } catch ParserError.expectedOpenBrace { rootNode = nil print("Expected open brace at index \(index)") } catch ParserError.expectedEndOfArray { rootNode = nil print("Expected end of tokens array at index \(index)") } catch { rootNode = nil print("Unexpected error") } return rootNode } 

स्विच में अगले टोकन को वर्तमान स्थिति को ध्यान में रखते हुए संसाधित किया जाता है। यदि एक उद्घाटन ब्रैकेट आता है और राज्य 1 है, तो इसे स्टैक में जोड़ा जाता है। यदि बंद हो जाता है, तो पार्सर यह देखने के लिए जांचता है कि क्या इसके लिए स्टैक पर एक उद्घाटन ब्रैकेट है, तो इसे स्टैक से हटा देता है और 2 पर स्विच करता है। एक नंबर मिलने पर दूसरे राज्य में संक्रमण भी किया जाता है।

पार्सर प्रत्येक समापन ब्रैकेट के लिए स्टैक से एक तत्व को निकालना जारी रखता है। यदि इस समय एक उद्घाटन ब्रैकेट या संख्या आती है, तो यह इनपुट सरणी में एक त्रुटि है।

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

 private func parseNextToken() throws { guard let currentToken = currentToken else { return } switch (state, currentToken) { case (.state1, .openBraceToken): print("Open brace found") stack.append(.openBraceToken) case (.state1, .number(let value)): if stack.isEmpty { throw ParserError.expectedOpenBrace } else { consumeNumber(value: value) state = .state2 } case (.state1, .closeBraceToken): if stack.isEmpty { throw ParserError.expectedOpenBrace } else { consumeCloseBrace() state = .state2 } case (.state2, .closeBraceToken): if stack.isEmpty { throw ParserError.expectedEndOfArray } else { consumeCloseBrace() } case (.state2, .number), (.state2, .openBraceToken): if stack.isEmpty { throw ParserError.expectedEndOfArray } else { throw ParserError.expectedCloseBrace } } } private func consumeCloseBrace() { print("Close brace found") _ = stack.popLast() print("Pair found") if rootNode == nil { rootNode = .brace(childNode: nil) } else { rootNode = .brace(childNode: rootNode) } } private func consumeNumber(value: Int) { rootNode = .number(value: value) } 

दोनों पार्सर शुरू करने के लिए, आपको लेक्सर से प्राप्त टोकन की एक सरणी को पास करना होगा और स्टार्टपर्सिंग () विधि को कॉल करना होगा :

 let parserTD = TopDownParser(tokens: tokens) let ast1 = parserTD.startParsing() let parserBU = BottomUpParser(tokens: tokens) let ast2 = parserBU.startParsing() 

दोनों पार्सर्स के लिए परिणाम सही था:

 brace(brace(5678)) 

स्विफ्ट पार्सर का उपयोग करना

स्विफ्ट पार्सर शुरू करने के लिए, आपको कंपाइलर को -dump-parse फ्लैग पास करना होगा:

 swiftc -dump-parse main.swift 

एक असली एएसटी में एक कोष्ठक पार्सर की तुलना में अधिक जटिल संरचना होती है। लेकिन चूंकि यह छोटा है, आप इसे आसानी से समझ सकते हैं और पूर्णांक 16 और स्थिर x ज्ञात कर सकते हैं:

 (source_file (top_level_code_decl (brace_stmt (pattern_binding_decl (pattern_named 'x') (integer_literal_expr type='<null>' value=16)) )) (var_decl "x" type='<null type>' let storage_kind=stored)) 

एएसटी का यह रूप एक अप्राप्त वृक्ष है। इसलिए, स्थिर x में प्रकार = '' निर्दिष्ट नहीं है। यदि आप इसे स्पष्ट रूप से निर्दिष्ट करते हैं - चलो x: इंट = 16 पेड़ बदल जाएगा, लेकिन प्रकार वैसे भी पंजीकृत नहीं होगा:

 (source_file (top_level_code_decl (brace_stmt (pattern_binding_decl (pattern_typed (pattern_named 'x') (type_ident (component id='Int' bind=none))) (integer_literal_expr type='<null>' value=16)) )) (var_decl "x" type='<null type>' let storage_kind=stored)) 

स्रोत कोड:

• पार्सर हेडर
• पार्सर कार्यान्वयन फ़ाइलें

सेमा

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

स्विफ्ट सिमेंटिक विश्लेषक का उपयोग करना

सिमेंटिक विश्लेषक शुरू करने के लिए, -dump-ast ध्वज का उपयोग करें:

 swiftc -dump-ast main.swift 

आदेश का परिणाम:

 (source_file (top_level_code_decl (brace_stmt (pattern_binding_decl (pattern_named type='Int' 'x') (call_expr implicit type='Int' location=main.swift:1:9 range=[main.swift:1:9 - line:1:9] nothrow arg_labels=_builtinIntegerLiteral: (constructor_ref_call_expr implicit type='(_MaxBuiltinIntegerType) -> Int' location=main.swift:1:9 range=[main.swift:1:9 - line:1:9] nothrow (declref_expr implicit type='(Int.Type) -> (_MaxBuiltinIntegerType) -> Int' location=main.swift:1:9 range=[main.swift:1:9 - line:1:9] decl=Swift.(file).Int.init(_builtinIntegerLiteral:) function_ref=single) (type_expr implicit type='Int.Type' location=main.swift:1:9 range=[main.swift:1:9 - line:1:9] typerepr='Int')) (tuple_expr implicit type='(_builtinIntegerLiteral: Int2048)' location=main.swift:1:9 range=[main.swift:1:9 - line:1:9] names=_builtinIntegerLiteral (integer_literal_expr type='Int2048' location=main.swift:1:9 range=[main.swift:1:9 - line:1:9] value=16)))) )) (var_decl "x" type='Int' interface type='Int' access=internal let storage_kind=stored)) 

स्थिरांक में टाइप प्रकार = 'Int' है , साथ ही पहुंच स्तर भी है। स्थिरांक का प्रारंभ थोड़ा अधिक जटिल है। जोड़ा गया निर्माता कॉल _builtinIntegerLiteral । यदि आप एक स्विफ्ट कोड के रूप में इस पेड़ का प्रतिनिधित्व करते हैं, तो आपको मिलता है:

 internal let x: Int = Int(_builtinIntegerLiteral: 16) 

निम्न उदाहरण में एक त्रुटि है:

 let x: Bool = 16 

यदि आप इसे पार्सर के पास भेजते हैं, तो यह किसी भी विचलन का पता नहीं लगाएगा:

 (source_file (top_level_code_decl (brace_stmt (pattern_binding_decl (pattern_typed (pattern_named 'x') (type_ident (component id='Bool' bind=none))) (integer_literal_expr type='<null>' value=16)) )) (var_decl "x" type='<null type>' let storage_kind=stored)) 

लेकिन सिमेंटिक एनालाइज़र यह संकेत देगा कि इसमें दिए गए कोड में क्या गलत है:

 error: cannot convert value of type 'Int' to specified type 'Bool' let x: Bool = 16 

जाहिर है, त्रुटि एक प्रकार के बूल के एक निरंतर प्रकार के मूल्य को निर्दिष्ट करने की कोशिश कर रही थी। स्विफ्ट इसकी अनुमति नहीं देता है। सिमेंटिक एनालाइजर की बदौलत।

स्रोत कोड:

• सेमा

दबंग आयातक

इस स्तर पर, हम क्लैंग मॉड्यूल को आयात करते हैं और स्विफ्ट से संबंधित कॉल में सी और ऑब्जेक्टिव-सी एपीआई को मैप करते हैं।

स्रोत कोड:

• दबंग आयातक

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

स्रोत कोड का पूर्ण संस्करण रिपॉजिटरी में पाया जा सकता है ।