पार्स और एमएस एक्सेल सूत्र की गणना

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



और आज मैं आपको इसके काम, चाल और नुकसान के सिद्धांतों के बारे में बताना चाहता हूं। और "जीवन से" पूरक के साथ पतला प्रलेखन की सूखी छलनी को उबालने के लिए नहीं - उसी समय मैं आपको संक्षेप में बताऊंगा कि हमने इस तरह के तंत्र को कैसे लागू किया।



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

एक अभिव्यक्ति का आंतरिक प्रतिनिधित्व

एक्सेल में अभिव्यक्ति रिवर्स पोलिश नोटेशन , आरपीएन में संग्रहीत है। आरपीएन फॉर्म में एक अभिव्यक्ति एक सरल सरणी है, जिसके तत्वों को पार्सडहिंग कहा जाता है।



पूर्ण ParsedThing सूट में निम्नलिखित तत्व होते हैं:









मैं आपको कुछ उदाहरण देता हूं।

1. "= ए 1 * (1 + सच)"। आंतरिक दृश्य में यह इस तरह दिखेगा: {ParsedThingRef (A1), ParsedThingInt (1), ParsedThingBool (true), ParsedThingAdd, ParsedThingMultiply}
2. "" SUM (A1,1, "2",) "। आंतरिक प्रतिनिधित्व में यह इस तरह दिखेगा: {ParsedThingRef (A1), ParsedThingInt (1), ParsedThingString ("2"), ParsedThingMissing, PededThingFuncVar ("SUM", 4 तर्क)}}

कंप्यूटिंग

स्टैक मशीन का उपयोग करके रिवर्स पोलिश नोटेशन में लिखे गए एक्सप्रेशन की गणना की जाती है। एक अच्छा उदाहरण विकिपीडिया पर दिया गया है।



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



तीन प्रकार के ऑपरेंड हैं:

• संदर्भ;
• मूल्य;
• सरणी।

प्रत्येक ऑपरेंड डिफ़ॉल्ट प्रकार का होता है:

सभी प्रकार के लिंक	संदर्भ
निरंतर को छोड़कर	मूल्य
सरणियों	सरणी
फंक्शन कॉल	मान, संदर्भ, सरणी

किसी फ़ंक्शन का मूल्यांकन करने का परिणाम किसी भी प्रकार का हो सकता है। अधिकांश फ़ंक्शन मान लौटाते हैं, कुछ (उदाहरण के लिए, INDIRECT) -Reference, शेष - Array (MMULT)।



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



प्रकार के मान को Array में बदला जा सकता है , इस स्थिति में एक मान का एक सरणी बनाया जाएगा। विपरीत दिशा ( सरणी-> मान ) में, रूपांतरण भी काफी सरल है - पहला तत्व सरणी से लिया गया है।



जैसा कि आप आरेख से देख सकते हैं, मान या एरे से प्रकार के संदर्भ को प्राप्त नहीं किया जा सकता है । यह एक संख्या, एक स्ट्रिंग आदि से काफी तार्किक है। लिंक प्राप्त करें काम नहीं करता है।



संदर्भ को सरणी में परिवर्तित करते समय , श्रेणी के कक्षों से सभी मान किसी सरणी में ओवरराइट हो जाते हैं। मामले में जब सीमा जटिल होती है (दो या अधिक श्रेणियों से मिलकर), रूपांतरण का परिणाम त्रुटि #VALUE के बराबर होता है!



एक दिलचस्प तरीका संदर्भ के मूल्य में रूपांतरण है। हमने इस नियम को आपस में "क्रॉसिंग" कहा। इसके सार को समझाने का सबसे आसान तरीका है:





मान लें कि हम A4 के माध्यम से A1 के मानों को मान में लाना चाहते हैं, जिसमें एक ही सूत्र "= B2: B3" है, जो कि प्रकार के संदर्भ में है। रेंज बी 2: बी 3 में एक कॉलम होता है। यदि यह मामला नहीं था और अधिक कॉलम होंगे, तो A1 से A4 तक के सभी सेल के मान का संदर्भ #VALUE! और वह अंत होगा। कक्ष A2 और A3, B2: B3 की सीमा को पार करने वाली पंक्तियों में हैं। संदर्भ-> इन कोशिकाओं के लिए मूल्य परिवर्तन बी 2: बी 3, अर्थात् से सीमा के अनुरूप मान लौटाएगा। A2 के लिए रूपांतरण 1 वापस आ जाएगा, और A3 के लिए यह वापस आ जाएगा। 2 अन्य कोशिकाओं, जैसे A1 और A4 के लिए, रूपांतरण # 1% वापस आ जाएगा!



ठीक यही व्यवहार B7: C7 श्रेणी के लिए होगा, जिसमें एक रेखा होती है। B6 और C6 के लिए, रूपांतरण क्रमशः 3 और 4 मान लौटाएगा, और A6 और - D6 #VALUE के लिए! इसी तरह, यदि सीमा में अधिक पंक्तियाँ थीं, तो रूपांतरण #VALUE! A6 से D6 तक की सभी कोशिकाओं के लिए



कई प्रकार के रूपांतरण नियम हैं।



कोशिकाओं के अंदर सभी फॉर्मूलों का मान हमेशा वैल्यू टाइप पर होता है।



उदाहरण के लिए:

• "= 123" इस सूत्र में एक स्थिरांक निर्दिष्ट किया गया है, यह पहले से ही प्रकार मान है। कुछ भी रूपांतरित करने की आवश्यकता नहीं है।
• "= {1,2,3}" यहां एक सरणी निर्दिष्ट है। मूल्य द्वारा नियम में बदलना हमें सरणी का पहला तत्व देता है - 1. यह अभिव्यक्ति का मूल्यांकन करने का परिणाम होगा।
• सूत्र "= A1: B1" सेल B2 में है। रेंज संदर्भ ऑपरेंड डिफ़ॉल्ट रूप से संदर्भ का प्रकार है। इसकी गणना करते समय, इसे "क्रॉसिंग" नियम के अनुसार मान तक घटा दिया जाएगा। इस मामले में परिणाम सेल बी 1 से मूल्य होगा।

गणितीय, तार्किक और पाठ संचालक लिंक के साथ काम नहीं कर सकते । इसलिए, उनके लिए तर्क तैयार किए जाते हैं और या तो मूल्य या अर्रे में डाल दिए जाते हैं। दूसरा विकल्प केवल ऐरे फॉर्मूले के अंदर संभव है। उदाहरण के लिए, जब कक्ष A1 में दर्ज "= B1: B2 + A3: B3" अभिव्यक्ति की गणना करते हैं, तो गणितीय जोड़ ऑपरेटर के दोनों तर्क पहले क्रॉसिंग नियम द्वारा मूल्य प्रकार में बदल जाएंगे, और फिर परिणाम जोड़ दिए जाएंगे। यानी मान B1 और A3 के मानों के योग के बराबर होगा।



लिंक ऑपरेटर संदर्भ के अलावा किसी अन्य प्रकार के साथ काम नहीं कर सकते हैं । उदाहरण के लिए, सूत्र "= A1:" परीक्षण "" गलत होगा, ऐसे सूत्र में प्रवेश करने से त्रुटि होगी - Excel बस ऐसे सूत्र को सेल में लिखने की अनुमति नहीं देगा।



"नाम" और कुछ अन्य निर्माणों के अंदर अभिव्यक्तियाँ डिफ़ॉल्ट प्रकार पर डाली जाती हैं । कोशिकाओं के अंदर सूत्रों के विपरीत, भाव जिसमें मूल्य प्रकार के लिए डाला जाता है। गणना के परिणामस्वरूप कुछ "नाम" नाम "= A1: B1" के अंदर की अभिव्यक्ति रेंज A1: B1 के बराबर होगी। सेल में समान अभिव्यक्ति की गणना की जाएगी और परिणामस्वरूप एक एकल मान या #VALUE त्रुटि होगी! लेकिन सेल "= नाम" में अभिव्यक्ति पहले से ही टाइप वैल्यू की होगी और वर्तमान सेल के आधार पर गणना की जाएगी।

पार्सर

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



बेशक, इस लेख के हिस्से के रूप में, मैं कोको / आर दस्तावेज़ीकरण की विशेषताओं का वर्णन करने और उसे वापस लेने पर ध्यान नहीं दूंगा। सौभाग्य से, प्रलेखन मेरी राय में लिखा है बहुत स्पष्ट है। इसके अलावा, मैं हैबर पर लेख पढ़ने की सलाह देता हूं ।

हम स्रोत से कोको / आर एकत्र करते हैं

कुछ स्थानों पर, कोको / आर गैर-सीएलएस-अनुरूप कोड उत्पन्न करता है।



समस्या सार्वजनिक स्थिरांक में है, जिसका नाम अंडरस्कोर से शुरू होता है। स्थिति से बाहर केवल एक ही सही तरीका है - सही कोको / आर, क्योंकि इसका पूर्ण स्रोत कोड डेवलपर्स वेबसाइट पर उपलब्ध है।



स्रोत कोड में अफवाह फैलने के बाद तीन जगह मिलीं जहां सार्वजनिक स्थिरांक बनाए गए हैं। वे सभी ParserGen.cs फ़ाइल में हैं। उदाहरण के लिए:

void GenTokens() { foreach (Symbol sym in tab.terminals) { if (Char.IsLetter(sym.name[0])) gen.WriteLine("\tpublic const int _{0} = {1};", sym.name, sym.n); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इसके अलावा, परिणामी कोड अमान्य हो गया है, अब FxCop के अनुसार। हमारी कंपनी में, बड़ी संख्या में नियमों के अनुपालन के लिए विधानसभाओं का लगातार परीक्षण किया जाता है। बेशक, चूंकि कोड उत्पन्न होता है, इसलिए इसके लिए एक अपवाद बनाना और उत्पन्न वर्गों के सत्यापन को दबाने के लिए संभव होगा। लेकिन यह सबसे अच्छा समाधान नहीं है। सौभाग्य से, केवल एक ही समस्या है - सार्वजनिक क्षेत्र Microsoft.Design नियम का अनुपालन नहीं करते हैं : CA1051 । सब कुछ ठीक करने के लिए, बस Parser.frame और Scanner.frame फ़ाइलों में आवश्यक परिवर्तन करें, जो व्याकरण फ़ाइल के बगल में स्थित हैं। यही है, कोको / आर खुद को पुनर्निर्माण करने की आवश्यकता नहीं है। यहाँ कुछ उदाहरण हैं:

 public Scanner scanner; public Errors errors; public Token t; // last recognized token public Token la; // lookahead token
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इन क्षेत्रों में से कुछ का उपयोग कक्षा के बाहर बिल्कुल नहीं किया जाता है - हम बस उन्हें निजी बनाते हैं, और हम बाकी के लिए सार्वजनिक संपत्ति बनाते हैं।



कोको / आर के लिए व्याकरण विकसित करते समय, मैंने एक स्टूडियो प्लगइन का उपयोग किया।





प्लगइन को सीएलएस अनुरूप कोड उत्पन्न करने के लिए भी सिखाया जाना था। प्लगइन का स्रोत कोड डाउनलोड करें, और कोको / आर के साथ ही संचालन को दोहराएं।

हम स्कैनर और पार्सर को अपग्रेड करते हैं

आपको याद दिला दूं कि अभिव्यक्ति को पार्स करने के लिए कोको / आर कुछ वर्गों का निर्माण करता है - पार्सर और स्कैनर। प्रत्येक नई अभिव्यक्ति के लिए दोनों को फिर से बनाया गया है। चूंकि हमारे मामले में बहुत सारे भाव हैं, इसलिए बड़ी संख्या में कॉल पर स्कैनर को फिर से बनाने में अतिरिक्त समय लग सकता है। सामान्य तौर पर, पार्सर स्कैनर का एक सेट हमारे लिए पर्याप्त है। पहला आधुनिकीकरण ठीक इसी पर छुआ।



दूसरे अपग्रेड में बफ़र हेल्पर क्लास शामिल थी, जिसे स्कैनर द्वारा आने वाले कैरेक्टर स्ट्रीम को पढ़ने के लिए बनाया जाता है। आउट ऑफ द बॉक्स कोको / आर में बफ़र और UTF8Buffer के एक दो कार्यान्वयन शामिल हैं। दोनों एक धारा के साथ काम करते हैं। हमें एक स्ट्रीम की आवश्यकता नहीं है: बस एक स्ट्रिंग के साथ काम करना ऐसा करने के लिए, StringBuffer का तीसरा कार्यान्वयन बनाएं, साथ ही साथ IBuffer इंटरफ़ेस पर प्रकाश डालें:

 public interface IBuffer { string GetString(int beg, int end); int Peek(); int Pos { get; set; } int Read(); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

StringBuffer का कार्यान्वयन सरल है:

 public class StringBuffer : IBuffer { int stringLen; int bufPos; string str; public StringBuffer(string str) { stringLen = str.Length; this.str = str; if (stringLen > 0) Pos = 0; else bufPos = 0; } public int Read() { if (bufPos < stringLen) return str[bufPos++]; else return StreamBuffer.EOF; } public int Peek() { int curPos = Pos; int ch = Read(); Pos = curPos; return ch; } public string GetString(int beg, int end) { return str.Substring(beg, end - beg); } public int Pos { get { return bufPos; } set { if (value < 0 || value > stringLen) throw new FatalError("buffer out of bounds access, position: " + value); bufPos = value; } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

व्याकरण डिजाइन

कोको / आर के लिए व्याकरण RBNF ( EBNF ) में वर्णित है । कोको / आर के लिए व्याकरण का विकास आरबीएनएफ के निर्माण के लिए कम हो गया है और इसके डिजाइन में विस्तार एटीजी के साथ एक फ़ाइल में कोको / आर व्याकरण के अनुसार है।



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



तो चलिए शुरू करते हैं। व्याकरण फ़ाइल में पहला भविष्य संकलक का नाम है:

 COMPILER FormulaParserGrammar
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

स्कैनर विनिर्देश का पालन करना चाहिए। स्कैनर केस-असंवेदनशील होगा, हम इसे IGNORECASE कीवर्ड का उपयोग करके इंगित करते हैं। अब हमें प्रतीकों पर निर्णय लेने की आवश्यकता है। हमें संख्याओं, अक्षरों, नियंत्रण वर्णों को अलग करना होगा। यह निम्नलिखित निकला:

 CHARACTERS digit = "0123456789". chars = "~!@#$%^&*()_-+={[]}|\\:;\"',./?<> ". eol = '\r'. blank = ' '. letter = ANY - digit - chars - eol - blank + '_'.
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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



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

 TOKENS ident = letter {letter | digit | '.'}. wideident = letter {letter | digit} ('?'|'\\') {letter | digit | '?'|'\\'}. positiveinumber = digit {digit}. fnumber = "." digit {digit} [("e" | "E") ["+" | "-"] digit {digit}] | digit {digit} ( "." digit {digit} [("e" | "E" ) ["+" | "-"] digit {digit} ] | ("e" | "E") ["+" | "-"] digit {digit} ). space = blank. quotedOpenBracket = "'[". quotedSymbol = "''" | "']" | "'@" | "'#". pathPart = ":\\". trueConstant = "TRUE". falseConstant = "FALSE".
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

• इसमें केवल अक्षर, संख्याएँ और चिह्न हो सकते हैं: _,।, \,;;
• TRUE या FALSE के बराबर नहीं हो सकता;
• पहला चरित्र केवल एक अक्षर, एक अंडरस्कोर, या बैकस्लैश हो सकता है;
• यदि स्ट्रिंग का पहला वर्ण बैकस्लैश है, तो दूसरा वर्ण नहीं हो सकता है, या इसमें से एक होना चाहिए: _,,, \,;;
• यह सीमा के नाम के समान नहीं होना चाहिए (उदाहरण के लिए, ए 10);
• यह एक पंक्ति पर शुरू नहीं होना चाहिए जिसे प्रारूप R1C1 में एक लिंक के रूप में माना जा सकता है। इस स्थिति की प्रकृति को समझाना मुश्किल है, मैं केवल कुछ ही पहचानकर्ताओं का उदाहरण दूंगा जो इसे संतुष्ट नहीं करते हैं: "R1_test", "R1test", "RC1test", "R", "C"। वहीं, RCtest काफी उपयुक्त है।

एक होटल टोकन में quotedOpenBracket, quotedSymbol और pathPart को अलग करना एक ट्रिक से ज्यादा कुछ नहीं है। यह तालिका लिंक में स्तंभ नामों में वर्णों को छोड़ने की अनुमति देता है, इसके बाद एक एपॉस्ट्रॉफ़ होता है। उदाहरण के लिए, "= 1 टेबल 1 [कॉलम '[1]]] की अभिव्यक्ति में, कॉलम का नाम अक्षर' ['के बाद शुरू होता है और अक्षर']" के लिए जारी रहता है। इस मामले में, इस तरह के पहले चरित्र के साथ-साथ इसे प्रेरित करने वाले पूर्ववर्ती के रूप में स्कैनर द्वारा उद्धृत किए गए उद्धरण (']) टर्मिनल के रूप में पढ़ा जाएगा और इसलिए, इस पर कॉलम नाम को पढ़ना बंद नहीं होगा।



अंत में, लाइन फीड्स और टैब को स्किप करने के लिए स्कैनर को बताएं।

IGNORE eol + '\ n' + 't'। अभिव्यक्तियों को स्वयं कई पंक्तियों में लिखा जा सकता है, लेकिन यह व्याकरण को प्रभावित नहीं करता है।



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



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



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



क्योंकि हमारा व्याकरण साधारण गणितीय अभिव्यक्तियों के लिए एक जटिल व्याकरण है, इसे उसी तरह से बनाया गया है जैसे कि संचालन की वरिष्ठता के आधार पर। पहला तार्किक भावों के बाद है, अंतिम श्रेणी ऑपरेटर है। यानी प्राथमिकता बढ़ाने के क्रम में।



RBNF के विज़ुअलाइज़ेशन के लिए मैं एक छोटे प्रोग्राम EBNF विज़ुअलाइज़र का उपयोग करता हूँ। यह है कि हमारे व्याकरण में पहला गैर-शब्द कैसे दिखेगा - एक तार्किक अभिव्यक्ति:







कोको / आर के लिए आगे व्याकरण। "(।" और ")" के बीच खींचे गए शब्दार्थ आवेषण में, मैं अभिव्यक्ति के लिए आवश्यक पार्सडहिंग जोड़ूंगा।

 LogicalClause<OperandDataType dataType, ParsedExpression expression> (. IParsedThing thing = null; .) = ConcatenateClause<dataType, expression> { ( '<' (.thing = ParsedThingLess.Instance; .) | '>' (.thing = ParsedThingGreater.Instance; .) | "<=" (.thing = ParsedThingLessEqual.Instance; .) | ">=" (.thing = ParsedThingGreaterEqual.Instance; .) | "<>" (.thing = ParsedThingNotEqual.Instance; .) | '=' (.thing = ParsedThingEqual.Instance; .) ) ConcatenateClause<dataType, expression> (. expression.Add(thing); .) } .
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस सिद्धांत के अनुसार बनाया जाएगा: ConcatenateClause, AddClause, MultipyClause, PowerClause, UnaryClause, PercentClause, RangeUnionClause, RangeIntersectionClause, CellRange.ause। CellRangeClause ऑपरेटरों का वर्णन करने वाले गैर-टर्मिनलों के साथ समाप्त होता है। इसके बाद पहला ऑपरेंड होता है - OperandCommonClause। यह कुछ इस तरह दिखेगा:







हालाँकि, दिए गए व्याकरण में अस्पष्टता है। यह इस तथ्य में निहित है कि शीटनेम और ऑपरैंडक्लाज एक ही टर्मिनल से शुरू हो सकते हैं - एक पहचानकर्ता के साथ। उदाहरण के लिए, अभिव्यक्ति "= पत्रक! A1" का अनुसरण हो सकता है, या शायद "= नाम"। यहां "शीट" और "नाम" पहचानकर्ता हैं। सौभाग्य से, कोको / आर आपको आने वाले स्ट्रीम को स्कैनर के साथ आगे कई टर्मिनलों को स्कैन करके संघर्ष को हल करने की अनुमति देता है। यानी हम खोज में '!' वर्ण की तलाश कर सकते हैं, यदि कोई पाया जाता है, तो हम शीटनाम को पार्स करते हैं, अन्यथा ऑपरेंड क्लॉज़। इस तरह व्याकरण दिखेगा:

 OperandCommonClause<OperandDataType dataType, ParsedExpression expression> = ( IF(IsSheetDefinition()) ( ( SheetNameQuoted<sheetDefinitionContext> | [ '[' FileDefinitionSimple ] [ SheetName<out sheetName> [ ':' SheetName<out sheetName> | '|' SingleQuotedIdent<out ddeTopic> ] ] ) '!' CellReferenceClause<dataType, expression> ) | OperandClause<dataType, expression> ) .
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

संघर्ष को हल करने के लिए, Parser वर्ग में परिभाषित IsSheetDefinition () विधि का उपयोग किया जाता है। कक्षा को आंशिक के रूप में चिह्नित करते हुए, एक अलग फ़ाइल में ऐसे तरीकों को लिखना सुविधाजनक है।



गैर-टर्मिनल शीटनाम एक अंक के साथ शुरू हो सकता है या केवल संख्याओं से युक्त हो सकता है। इस मामले में, शीट का नाम एपोस्ट्रोफ में संलग्न होना चाहिए। अन्यथा, Excel गुम एपॉस्ट्रॉफ़ जोड़ता है।

 SheetName<out string sheetName> (. int sheetNameStart = la.pos;.) = ( [positiveinumber | fnumber] [ident] ) (. sheetName = scanner.Buffer.GetString(sheetNameStart, la.pos); .) .
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

 SheetName<out string sheetName> (. int sheetNameStart = la.pos;.) = ( positiveinumber | fnumber [ IF(la.pos - t.pos == t.val.Length) ident ] | ident ) (. sheetName = scanner.Buffer.GetString(sheetNameStart, la.pos); .) .
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

OperandClause में, यदि आप एक शीट, बाहरी पुस्तक या DDE स्रोत का कोई लिंक नहीं है, तो आप OperandCommonClause से प्राप्त करेंगे। इस नॉनटर्मिनल से, हम ArrayClause, StringConstant (दोनों को उनके सामने शीट का लिंक नहीं दे सकते हैं), CellReferenceClause, या हम ब्रैकेट से मिलेंगे और पूरे पार्स ट्री की शुरुआत में जा सकते हैं - LogicalClause।

 OperandClause<OperandDataType dataType, ParsedExpression expression> = ( CellReferenceClause<dataType, expression> | ArrayClause<dataType, expression> | StringConstant<expression, dataType> ) | '(' CommonCellReference<dataType, expression> ')' (. expression.Add(ParsedThingParentheses.Instance);.) .
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

CellReferenceClause शायद सबसे बड़ा गैर-टर्मिनल है, इसमें लगभग सभी प्रकार के ऑपरेंड शामिल हैं:

 CellReferenceClause<OperandDataType dataType, ParsedExpression expression> = ( IF (IsTableDefinition()) TableReferenceExpressionClause<dataType, expression> | IF (IsFunctionDefinition()) FunctionClause<dataType, expression> | IF (IsDefinedNameDefinition()) DefinedNameClause<dataType, expression> | IF(IsRCCellPosition()) CellPositionRCClause<dataType, expression> | IF(IsA1CellPosition()) CellPositionA1Clause<dataType, expression> | CellError<dataType, expression> | TermNumber<expression> | BoolConstant<expression, dataType> | wideident (. expression.Add(new ParsedThingName(t.val);.) ) .
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अधिकांश गैर-टर्मिनलों में संघर्ष समाधान के तरीके बनाने होते हैं। अगला, हम सभी शेष गैर-टर्मिनलों के लिए व्याकरण का वर्णन करते हैं।

अपूर्ण भाव और "भविष्यवाणियां"

सूत्र में शामिल श्रेणियों को हाइलाइट करने के कार्य पर विचार करें।







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

 void RegisterCellRange(CellRange range, int sheetDefinitionIndex, int position, int length)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

पढ़ने के बाद, चाहे वह सफलतापूर्वक समाप्त हो गया या नहीं, हमारे पास लिंक का एक सेट है।



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

 '(' CommonCellReference<dataType, expression> (. if(la.val != ")") parserContext.RegisterSuggestion(new FunctionCloseBracketSuggestion(la.pos)); .) ')'
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

कम्प्यूटिंग प्रदर्शन अनुकूलन

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



अत्रस्मि गुण। यह विशेषता उन अभिव्यक्तियों में पहले तत्व के रूप में जोड़ी जाती है जिनमें अस्थिर कार्य होते हैं।



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

• ParsedThingMemFunc - इंगित करता है कि हर बार के अंदर की अभिव्यक्ति का मूल्यांकन किया जाना चाहिए और परिणाम को कैश नहीं किया जा सकता है। उदाहरण के लिए, संपूर्ण अभिव्यक्ति = संकेत ("A1"): B1 को मेम्फंक में लपेटा जाएगा, क्योंकि INDIRECT फ़ंक्शन एक अस्थिर फ़ंक्शन है और अगली गणना में एक अलग मान दे सकता है।
• ParsedThingMemArea। इसमें एक अभिव्यक्ति शामिल है जिसका मूल्य पहले से ही गणना किया गया है और बदल नहीं जाएगा। यह मान विशेषता के अंदर संग्रहीत किया जाएगा और अगली गणना के दौरान इसे स्टैक में जोड़ा जाएगा, और आंतरिक अभिव्यक्ति का मूल्यांकन बिल्कुल नहीं किया जाएगा।
• ParsedThingMemErr। इसमें एक अभिव्यक्ति शामिल है, जिसका मान गणना की गई है, वह नहीं बदलेगा और एक त्रुटि के बराबर है।
• ParsedThingMemNoMem। एक्सेल के अंदर एक अभिव्यक्ति की गणना करते समय, यह मेमोरी से बाहर चला गया। व्यवहार में, मैंने ऐसा कभी नहीं देखा।

AttrSum विशेषता SUM फ़ंक्शन को लिखने के लिए एक सरलीकृत रूप के रूप में उपयोग किया जाता है जब फ़ंक्शन में केवल एक तर्क दिया जाता है।



AttrIf विशेषता IF फ़ंक्शन की गणना का अनुकूलन करने के लिए एक या दो गोटो बयान के साथ संयोजन में उपयोग किया जाता है। मुझे आपको IF का सिंटैक्स याद दिलाता है: IF फ़ंक्शन (स्थिति, true_value, [false_value])। दो मानों में से, आप केवल एक की गणना कर सकते हैं और दूसरे की गणना पर समय बचा सकते हैं, यदि स्थिति की गणना करने के तुरंत बाद वांछित मूल्य पर जाएं। इस प्रकार, सरल अभिव्यक्ति = IF (स्थिति, "v_true", "v_false") एक्सेल विशेषताओं के साथ मोटा हो जाता है। यह निम्नलिखित की तरह कुछ बाहर निकलता है:







गणना इस तरह से होती है। हालत का मूल्य स्टैक पर धकेल दिया जाता है। पंक्ति में अगली IF विशेषता है। वह स्टैक के शीर्ष पर मूल्य को देखता है। अगर यह सच है, तो यह कुछ भी नहीं करता है। यदि गलत है, तो अभिव्यक्ति के मौजूदा काउंटर को अंदर दर्ज की गई ऑफसेट में जोड़ देता है, जिससे काउंटर "v_false" को इंगित करना शुरू कर देता है। अगला, या तो v_true या v_false की गणना की जाती है और परिणाम स्टैक पर धकेल दिया जाता है। अगला गोटो है, पहला या दूसरा। लेकिन वे दोनों अभिव्यक्ति के अंत (या अभिव्यक्ति में निम्नलिखित ऑपरेटरों के लिए, यदि कोई हो) का उल्लेख करते हैं।



AttrChoose बहुत ही समान तरीके से काम करता है। मैं आपको याद दिलाता हूं कि CHOOSE फ़ंक्शन उन तर्कों में से एक का चयन करता है जिनकी अनुक्रम संख्या पहले तर्क में निर्दिष्ट होती है।

इस प्रकार, केवल एक तर्क गणना के आगे के परिणाम को प्रभावित करता है, अन्य सभी को छोड़ दिया जा सकता है। AttrChoose मिक्स का एक सेट संग्रहीत करता है, जिनमें से प्रत्येक प्रत्येक बाद के तर्क की शुरुआत को इंगित करता है। तर्क के बाद परिचित AttrGoto का अनुसरण करता है, जो अभिव्यक्ति या CHOOSE फ़ंक्शन का अनुसरण करने वाले तत्व की ओर इशारा करता है।



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

• SpaceBeforeBaseExpression,
• CarriageReturnBeforeBaseExpression,
• SpaceBeforeOpenParentheses,
• CarriageReturnBeforeOpenParentheses,
• SpaceBeforeCloseParentheses,
• CarriageReturnBeforeCloseParentheses,
• SpaceBeforeExpression;

इन प्रकारों को देखते हुए, आप अनुमान लगा सकते हैं कि एक्सेल लाइन के अंत में और '=' चिह्न से पहले रिक्त स्थान को बचाने में सक्षम नहीं है। इसके अलावा, संरचित लिंक और सरणियों के भीतर रिक्त स्थान भी नहीं बचेंगे।

परीक्षण

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



जैसे-जैसे नियंत्रण विकसित होता गया, समर्थित प्रारूप और सुविधाएँ दोनों जुड़ती गईं। तो अब 20k xls फाइल और 15k csv फाइल का लगातार परीक्षण किया जा रहा है।और उन्हें न केवल पढ़ने-लिखने के लिए परीक्षण किया जाता है, बल्कि तीसरे पक्ष की उपयोगिताओं द्वारा भी जांच की जाती है, जो हमें बहुत मदद करते हैं।



एक्सेल में सूत्रों के काम के बारे में हमें बड़ी मात्रा में ज्ञान प्राप्त हुआ, जब हमने उसी 10k ओपनएक्सएमएल और 20k xls फ़ाइलों से सूत्रों की गणना का परीक्षण करने का कार्य शुरू किया। फ़ाइल खोली जाती है, डेटा मॉडल को लिखा जाता है। फिर, एक-एक करके, हम शीट पर उन कोशिकाओं को चिह्नित करना शुरू करते हैं, जो फ़ाइल से पढ़े गए मूल्य के साथ नए मान की गणना, गणना और तुलना नहीं करते हैं। इस प्रकार, हमने दो पक्षियों को एक पत्थर से मार दिया - हमने सूत्र पार्सर को डिबग किया और एक्सेल का उपयोग करके प्राप्त किए गए गणना परिणामों को जितना संभव हो उतना करीब लाया।



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



आपका ध्यान के लिए धन्यवाद!