किसी व्याख्या की गई भाषा में चर को संग्रहीत करने के लिए डेटा संरचना

Question

मैं अपने बड़े एप्लिकेशन में एम्बेड करने के उद्देश्य से अपनी स्वयं की प्रयोगात्मक स्क्रिप्टिंग भाषा तैयार कर रहा हूं।

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

a = 1 
b = 2 

someFunction() 
    print(a) --> This should read the global variable and print `1` 
    a = 3  --> Now `a` should become a local variable of this function 
       and the global `a` remain unchanged 
    x = 4  --> `x` should always be local of this function 
end 

मैं चर उनके level एस के "इलाके" कहते हैं तो नेस्टेड ब्लॉकों में चर एक उच्च स्तर की है। उपरोक्त कोड में, a और b स्तर 1 चर हैं। कुछ फ़ंक्शन के स्थानीय चर के स्तर 2 होंगे। फ़ंक्शन की पहली पंक्ति को वैश्विक चर a (स्तर 1) पढ़ना चाहिए, लेकिन दूसरी पंक्ति को एक चर फिर से बनाना चाहिए जिसे a कहा जाता है लेकिन स्तर 2 के साथ उस बिंदु से वैश्विक a छायांकन करता है। तीसरी पंक्ति को स्तर 2 के साथ परिवर्तनीय x बनाना चाहिए। इन सभी को स्मृति में कैसे संग्रहीत और ट्रैक करना है?

variables 
{ 
    level=1 //global variables 
    { 
     a => 1, 
     b => 2 
    }, 
    level=2 //function variables 
    { 
     a => 3, 
     x => 4 
    } 
} 

लेकिन उस चर लुक-अप वास्तव में धीमी गति से कर देगा के बाद से एक खोज करने के लिए है: स्तर की सरणी में variable=>value का भंडारण नक्शे:

क्या मैं अब तक की कोशिश की:

विधि 1 किसी दिए गए चर के लिए सभी स्तर।

विधि 2: एक मानचित्र की कुंजी के रूप में (चर, स्तर) जोड़े भंडारण:

variables 
{ 
    (a, 1) => 1, //global 
    (b, 1) => 2, //global 
    (a, 2) => 3, //function 
    (x, 2) => 3 //function 
} 

यह पहले की तरह से हम सभी संभव के साथ जोड़ी (चर, स्तर) की कोशिश करने के लिए है एक ही समस्या है किसी दिए गए चर के लिए स्तर।

इष्टतम स्मृति उपयोग और सबसे तेज़ पहुंच समय के लिए मुझे किस विधि का उपयोग करना चाहिए?

अतिरिक्त नोट्स:

मैं कैसे चर ढेर और अन्य "असली" भाषाओं पर ढेर पर प्रबंधित कर रहे हैं के बारे में पता है, लेकिन मैं यह मुश्किल एक व्याख्या की भाषा पर यह करने के लिए लगता है। "यह नहीं होना चाहिए कि लुआ और पायथन ऐसा कैसे करते हैं," मैं हमेशा सोचता हूं। यदि मैं गलत हूं तो मुझे सही करों। मैं चर और नक्शे में आंतरिक सी ++ संरचनाओं को बदलने की कोशिश कर रहा हूं।

और आखिरकार, मैं एक चर का प्रतिनिधित्व करता हूं। क्या आपको लगता है कि यह बड़ा है और अधिक मेमोरी-कुशल प्रतिनिधित्व हो सकते हैं? (मैं भी "स्तर" एक सदस्य के रूप में यहाँ डाल करने की कोशिश की है, लेकिन यह बहुत अन्य रूप में एक ही समस्या थी।)

struct Member 
{ 
    uchar type; //0=num, 1=str, 2=function, 3=array, etc 
    uchar flags; //0x80 = read-only, 0x40 = write-only, etc 
    union { 
     long double value_num; 
     char* value_str; 
     int value_func; 
     //etc 
    }; 
}; 

Answer 1

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

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

Answer 2

यह ध्यान देने योग्य है कि यदि किसी फ़ंक्शन के अंदर, आपके पास कॉलर फ़ंक्शन से किसी भी चर के लिए उपयोग नहीं है, तो यह देखने के लिए आवश्यक स्तरों की संख्या कम करता है। उदाहरण के लिए:

variable a; 

function one() { 
    variable b; 
    // in this function, we can see the global a, local b 
    two(); 
} 

function two() { 
    // in this function, we can see the global a, local c 
    // we cannot see the local b of our caller 
    variable c; 
    while (true) { 
     variable d; 
     // here we can see local d, local c, global a 
    } 
} 

विचार चर की दृश्यता, वैश्विक क्षेत्र में किया जा रहा "विशेष" के साथ सीमा जा रहा है कि समारोह सीमाओं।

कहा जा रहा है, तो आप वैश्विक चर की specialness को दूर करने के लिए, लेकिन कोड निर्दिष्ट करने के लिए वे चाहते हैं कि गैर स्थानीय चर के लिए उपयोग

variable a; 

function one() { 
    global a; // or upvar #0 a; 
    variable b; 
    // in this function, we can see the global a, local b 
    two(); 
} 

function two() { 
    // in this function, we can see the local c 
    // and the local b of our caller 
    // (since we specifically say we want access to "b" one level up) 
    upvar 1 b; 
    variable c; 
} 

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