ओबेरोन -2: Difference between revisions

From Vigyanwiki
No edit summary
No edit summary
 
(7 intermediate revisions by 3 users not shown)
Line 1: Line 1:
{{multiple issues|
{{Primary sources|date=April 2011}}
{{More footnotes needed|date=April 2011}}
}}
{{Infobox programming language
{{Infobox programming language
| name = Oberon-2
| name = Oberon-2
Line 28: Line 23:
| influenced = [[Oberon (programming language)#Oberon-07|Oberon-07]], [[Zonnon]], [[Active Oberon]], [[Component Pascal]], [[Go (programming language)|Go]], [[Nim (programming language)|Nim]]
| influenced = [[Oberon (programming language)#Oberon-07|Oberon-07]], [[Zonnon]], [[Active Oberon]], [[Component Pascal]], [[Go (programming language)|Go]], [[Nim (programming language)|Nim]]
}}
}}
ओबेरॉन -2 मूल ओबेरॉन (प्रोग्रामिंग लैंग्वेज) [[प्रोग्रामिंग भाषा]] का एक विस्तार है जो सीमित [[प्रतिबिंब (कंप्यूटर विज्ञान)]] और [[ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग]] सुविधाओं को जोड़ता है, पॉइंटर बेस प्रकार के रूप में ऐरे डेटा संरचना को खोलता है, केवल-पढ़ने के लिए फ़ील्ड निर्यात करता है,और  [[मॉड्यूल-2]] से फॉर लूप को पुन: प्रस्तुत करता है।
ओबेरॉन -2 मूल ओबेरॉन (प्रोग्रामिंग लैंग्वेज) [[प्रोग्रामिंग भाषा]] का ऐसा विस्तार है जो सीमित [[प्रतिबिंब (कंप्यूटर विज्ञान)]] और [[ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग]] सुविधाओं को जोड़ता है, पॉइंटर बेस प्रकार के रूप में ऐरे डेटा संरचना को खोलता है, केवल-पढ़ने के लिए फ़ील्ड निर्यात करता है,और  [[मॉड्यूल-2]] से फॉर लूप को पुन: प्रस्तुत करता है।


इसे 1991 में ETH ज्यूरिख में [[Niklaus Wirth]] और Hanspeter Mössenbock द्वारा विकसित किया गया था, जो अब ऑस्ट्रिया के [[लिंज़ विश्वविद्यालय]] के Institut für Systemsoftware (SSW) में हैं। ओबेरॉन -2 ओबेरॉन का सुपरसेट है,इसके साथ पूरी तरह से संगत है,और [[ऑब्जेक्ट ओबेरॉन]] का एक नया स्वरूप था।
इसे 1991 में ईटीएच (ETH) ज्यूरिख में [[Niklaus Wirth|निक्लौस विर्थ]] और हैन्सपीटर मौसेनबाॅक द्वारा विकसित किया गया था, जो अब ऑस्ट्रिया के [[लिंज़ विश्वविद्यालय]] के इंस्टीट्यूट फाॅर सिस्टम साॅफ्टवेयर (SSW) में हैं। ओबेरॉन -2 ओबेरॉन का सुपरसेट है, इसके साथ पूर्ण रूप से संयोजित है,और [[ऑब्जेक्ट ओबेरॉन]] का नवीन स्वरूप था।


ओबेरॉन -2 को ओबेरॉन से इंटरफेस या [[मिश्रण|mixin]] के बिना सीमित प्रतिबिंब और एकल [[वंशानुक्रम (वस्तु-उन्मुख प्रोग्रामिंग)]] से ("टाइप एक्सटेंशन") विरासत में मिला है, किन्तु कुशल आभासी विधियों  (कंप्यूटर प्रोग्रामिंग) को ("टाइप बाउंड प्रोसीजर") से जोड़ा गया है। [[सी ++]] - शैली आभासी विधियों  के टेबल का उपयोग करके [[रनटाइम (कार्यक्रम जीवनचक्र चरण)]] पर विधि कॉल्स को हल किया गया था।
ओबेरॉन -2 को ओबेरॉन से इंटरफेस या [[मिश्रण|mixin]] के बिना सीमित प्रतिबिंब और एकल [[वंशानुक्रम (वस्तु-उन्मुख प्रोग्रामिंग)]] से ("टाइप एक्सटेंशन") विरासत में मिला है, किन्तु कुशल आभासी विधियों  (कंप्यूटर प्रोग्रामिंग) को ("टाइप बाउंड प्रोसीजर") से जोड़ा गया है। [[सी ++]] - शैली आभासी विधियों  के टेबल का उपयोग करके [[रनटाइम (कार्यक्रम जीवनचक्र चरण)]] पर विधिवत कॉल करके हल किया गया था।


स्मॉलटाक जैसी पूरी तरह से वस्तु-उन्मुख भाषाओं की तुलना में, ओबेरॉन -2 में, मौलिक [[डेटा प्रकार]] और कक्षाएं ऑब्जेक्ट (कंप्यूटर विज्ञान) में नहीं होते हैं,कई ऑपरेशन विधि नहीं होते हैं,और ना कोई संदेश पासिंग होते है (इसे प्रतिबिंब द्वारा और संदेश विस्तार के माध्यम से कुछ हद तक अनुकरण किया जा सकता है) , जैसा कि ETH ओबेरॉन में प्रदर्शित किया गया है,और [[बहुरूपता (कंप्यूटर विज्ञान)]] एक सामान्य वर्ग के उप-वर्गों तक सीमित होते है ([[पायथन (प्रोग्रामिंग भाषा)]] में कोई [[बतख टाइपिंग]] नहीं होती है),<ref>{{Cite web |url=http://www.drdobbs.com/templates-and-duck-typing/184401971 |title=Related Reading |website=Dr. Dobb's}}</ref> और [[जावा (प्रोग्रामिंग भाषा)]] के रूप में इंटरफेस को परिभाषित करना संभव नहीं होता है)।ओबेरॉन -2 वस्तु या वर्ग स्तर पर एनकैप्सुलेशन (कंप्यूटर प्रोग्रामिंग) का समर्थन नहीं करता है, किन्तु इस उद्देश्य के लिए मॉड्यूल का उपयोग किया जा सकता है।
स्मॉलटाक जैसी पूरी तरह से वस्तु-उन्मुख भाषाओं की तुलना में, ओबेरॉन -2 में, मौलिक [[डेटा प्रकार]] और कक्षाएं ऑब्जेक्ट (कंप्यूटर विज्ञान) में नहीं होते हैं,कई ऑपरेशन विधि नहीं होते हैं,और ना कोई संदेश पासिंग होते है (इसे प्रतिबिंब द्वारा और संदेश विस्तार के माध्यम से कुछ हद तक अनुकरण किया जा सकता है) , जैसा कि ईटीएच ओबेरॉन में प्रदर्शित किया गया है,और [[बहुरूपता (कंप्यूटर विज्ञान)]] एक सामान्य वर्ग के उप-वर्गों तक सीमित होते है ([[पायथन (प्रोग्रामिंग भाषा)]] में कोई [[बतख टाइपिंग]] नहीं होती है),<ref>{{Cite web |url=http://www.drdobbs.com/templates-and-duck-typing/184401971 |title=Related Reading |website=Dr. Dobb's}}</ref> और [[जावा (प्रोग्रामिंग भाषा)]] के रूप में इंटरफेस को परिभाषित करना संभव नहीं होता है)।ओबेरॉन -2 वस्तु या वर्ग स्तर पर एनकैप्सुलेशन (कंप्यूटर प्रोग्रामिंग) का समर्थन नहीं करता है, किन्तु इस उद्देश्य के लिए मॉड्यूल का उपयोग किया जा सकता है।


ओबेरॉन -2 में प्रतिबिंब [[metaobject]] का उपयोग नहीं करता है, किन्तु केवल टाइप डिस्क्रिप्टर [[संकलक]] से निष्पादन योग्य बायनेरिज़ में पढ़ता है,और मॉड्यूल में उजागर होता है जो प्रकार और प्रक्रियाओं को परिभाषित करता है। यदि इन संरचनाओं का प्रारूप भाषा स्तर पर उजागर किया जाता है (उदाहरण के लिए ईटीएच ओबेरॉन के स्थितियों में), पुस्तकालय (कंप्यूटिंग) स्तर पर प्रतिबिंब लागू किया जा सकता है। इस प्रकार भाषा कोड को बदले बिना इसे लगभग पूरी तरह से पुस्तकालय स्तर पर लागू किया जा सकता है।मुख्य रूप से, ETH ओबेरॉन भाषा-स्तर और पुस्तकालय-स्तर की प्रतिबिंब क्षमताओं का बड़े पैमाने पर उपयोग करता है।
ओबेरॉन -2 में प्रतिबिंब [[metaobject|मेटाओब्जेक्ट]] का उपयोग नहीं करता है, किन्तु केवल टाइप डिस्क्रिप्टर [[संकलक]] से निष्पादन योग्य बायनेरिज़ में पढ़ता है,और मॉड्यूल में उजागर होता है जो प्रकार और प्रक्रियाओं को परिभाषित करता है। यदि इन संरचनाओं का प्रारूप भाषा स्तर पर उजागर किया जाता है (उदाहरण के लिए ईटीएच ओबेरॉन के स्थितियों में), पुस्तकालय (कंप्यूटिंग) स्तर पर प्रतिबिंब लागू किया जा सकता है। इस प्रकार भाषा कोड को बदले बिना इसे लगभग पूरी तरह से पुस्तकालय स्तर पर लागू किया जा सकता है। यह मुख्य रूप से, ईटीएच ओबेरॉन भाषा-स्तर और पुस्तकालय-स्तर की प्रतिबिंब क्षमताओं का बड़े पैमाने पर उपयोग करता है।


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


भाषा [[घटक पास्कल]]<ref>{{Cite web |last=Pfister |first=Cuno |date=2001 |url=http://www.oberon.ch/pdf/CP-New.pdf |title=What's New in Component Pascal (changes from Oberon-2 to CP) |website=Oberon microsystems |access-date=10 January 2007 |url-status=dead |archive-url=https://web.archive.org/web/20110515111149/http://www.oberon.ch/pdf/CP-New.pdf |archive-date=2011-05-15}}</ref> ओबेरॉन-2 का परिशोधन (एक सुपरसेट) है।
भाषा [[घटक पास्कल]]<ref>{{Cite web |last=Pfister |first=Cuno |date=2001 |url=http://www.oberon.ch/pdf/CP-New.pdf |title=What's New in Component Pascal (changes from Oberon-2 to CP) |website=Oberon microsystems |access-date=10 January 2007 |url-status=dead |archive-url=https://web.archive.org/web/20110515111149/http://www.oberon.ch/pdf/CP-New.pdf |archive-date=2011-05-15}}</ref> ओबेरॉन-2 का परिशोधन (सुपरसेट) है।


== उदाहरण कोड ==
== उदाहरण कोड ==
निम्नलिखित ओबेरॉन -2 कोड एक साधारण बाइनरी ट्री को लागू करता है:
निम्नलिखित ओबेरॉन -2 कोड एक साधारण बाइनरी ट्री को लागू करता है:
 
MODULE Trees;
<वाक्यविन्यास प्रकाश लैंग = सीपी शैली = फ़ॉन्ट-आकार: 10pt>
मॉड्यूल पेड़;
TYPE
 
    Tree* = POINTER TO Node;
प्रकार
    Node* = RECORD
    ट्री * = पॉइंटर टू नोड;
        name-: POINTER TO ARRAY OF CHAR;
    नोड* = रिकॉर्ड
        left, right: Tree
        नाम-: चार की सरणी के लिए सूचक;
    END;
        बाएँ, दाएँ: पेड़
    अंत;
PROCEDURE (t: Tree) Insert* (name: ARRAY OF CHAR);
 
    VAR p, father: Tree;
प्रक्रिया (टी: ट्री) डालें* (नाम: चार की सरणी);
BEGIN p := t;
    वार पी, पिता: वृक्ष;
    REPEAT father := p;
BEGIN p := t;
        IF name = p.name^ THEN RETURN END;
    रिपीट फादर := p;
        IF name < p.name^ THEN p := p.left ELSE p := p.right END
        IF नाम = p.name ^ फिर वापसी अंत;
    UNTIL p = NIL;
        IF नाम <p.name^ THEN p := p.left ELSE p := p.right END
    NEW(p); p.left := NIL; p.right := NIL; NEW(p.name, LEN(name)+1); COPY(name, p.name^);
    जब तक पी = शून्य;
    IF name < father.name^ THEN father.left := p ELSE father.right := p END
    नया पी); p.बाएँ:= शून्य; p.right := शून्य; नया (पी.नाम, एलईएन (नाम) +1); कॉपी (नाम, पी। नाम ^);
END Insert;
    IF नाम <Father.name^ THEN father.left := p ELSE father.right:= p END
अंत डालें;
PROCEDURE (t: Tree) Search* (name: ARRAY OF CHAR): Tree;
 
    VAR p: Tree;
प्रक्रिया (टी: पेड़) खोज* (नाम: चार की सरणी): पेड़;
BEGIN p := t;
    वार पी: ट्री;
    WHILE (p # NIL) & (name # p.name^) DO
BEGIN p := t;
        IF name < p.name^ THEN p := p.left ELSE p := p.right END
    जबकि (पी # एनआईएल) और (नाम # पी.नाम ^) डीओ
    END;
        IF नाम <p.name^ THEN p := p.left ELSE p := p.right END
    RETURN p
    अंत;
END Search;
    रिटर्न पी
अंत खोज;
PROCEDURE NewTree* (): Tree;
 
    VAR t: Tree;
प्रक्रिया NewTree* (): ट्री;
BEGIN NEW(t); NEW(t.name, 1); t.name[0] := 0X; t.left := NIL; t.right := NIL; RETURN t
    वर टी: ट्री;
END NewTree;
नया प्रारंभ करें (टी); नया (टी.नाम, 1); टी नाम [0] := 0X; t.बाएँ:= शून्य; टी.राइट := शून्य; वापसी टी
न्यूट्री समाप्त करें;
END Trees.
 
अंत पेड़।
</वाक्यविन्यास हाइलाइट>


== ओबेरॉन -2 एक्सटेंशन ओबेरॉन के लिए<ref>[http://members.home.nl/jmr272/Oberon/Oberon2.Differences.pdf Differences between Oberon and Oberon-2, Mössenböck and Wirth (1993)]</ref> ==
== ओबेरॉन -2 एक्सटेंशन ओबेरॉन के लिए<ref>[http://members.home.nl/jmr272/Oberon/Oberon2.Differences.pdf Differences between Oberon and Oberon-2, Mössenböck and Wirth (1993)]</ref> ==
Line 98: Line 90:


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


ध्यान दें कि ओबेरॉन-2 में प्रयुक्त विथ स्टेटमेंट का फॉर्म पास्कल और मोडुला-2 विथ स्टेटमेंट से संबंधित नहीं है। रिकॉर्ड फ़ील्ड तक पहुंच को संक्षिप्त करने की यह विधि ओबेरॉन या ओबेरॉन -2 में लागू नहीं किया गया है।
ध्यान दें कि ओबेरॉन-2 में प्रयुक्त विथ स्टेटमेंट का फॉर्म पास्कल और मोडुला-2 विथ स्टेटमेंट से संबंधित नहीं है। रिकॉर्ड फ़ील्ड तक पहुंच को संक्षिप्त करने की यह विधि ओबेरॉन या ओबेरॉन -2 में लागू नहीं किया गया है।


==== बाइंडिंग टाइप करें ====
==== बाइंडिंग टाइप करें ====
<वाक्यविन्यास प्रकाश लैंग = घटकपास्कल>
  MODULE Birds;
मॉड्यूल पक्षी;
      TYPE
    प्रकार
          Bird* = RECORD
        पक्षी* = रिकॉर्ड
              sound* : ARRAY 10 OF CHAR;
            ध्वनि*�: सरणी 10 चार;
          END;
        अंत;
  END Birds.
अंत पक्षी।
 
  MODULE Ducks;
मॉड्यूल बतख;
      IMPORT Birds;
    आयात पक्षी;
 
      TYPE
    प्रकार
          Duck* = RECORD (Birds.Bird) END;
        बतख * = रिकॉर्ड (पक्षी। पक्षी) अंत;
 
      PROCEDURE SetSound* (VAR bird : Duck);
    प्रक्रिया सेटसाउंड * (वार पक्षी: बतख);
      BEGIN
    प्रारंभ
          bird.sound := "Quack!"
        चिड़िया। ध्वनि: = नीम हकीम!
      END SetSound;
    अंत सेटसाउंड;
  END Ducks.
अंत बतख।
 
  MODULE Cuckoos;
मॉड्यूल कोयल;
      IMPORT Birds;
    आयात पक्षी;
 
      TYPE
    प्रकार
          Cuckoo* = RECORD (Birds.Bird) END;
        कोयल* = रिकॉर्ड (पक्षी। पक्षी) अंत;
 
      PROCEDURE SetSound* (VAR bird : Cuckoo);
    प्रक्रिया सेटसाउंड * (वार पक्षी: कोयल);
      BEGIN
    प्रारंभ
          bird.sound := "Cuckoo!"
        चिड़िया की आवाज�:= कोयल�!
      END SetSound;
    अंत सेटसाउंड;
  END Cuckoos.
  अंत कोयल।
</वाक्यविन्यास हाइलाइट>
 
==== <code>WITH</code> कथन ====
==== <code>WITH</code> कथन ====
<वाक्यविन्यास प्रकाश लैंग = घटकपास्कल>
मॉड्यूल टेस्ट;
    आयात बाहर, पक्षी, कोयल, बत्तख;
    प्रकार
        समबर्ड* = रिकॉर्ड (पक्षी.पक्षी) END;
    वीएआर
        एसबी: समबर्ड;
        c : कोयल। कोयल;
        डी: बत्तख। बत्तख;
    प्रक्रिया सेटसाउंड * (वार पक्षी: पक्षी। पक्षी);
    प्रारंभ
        पक्षी के साथ: कोयल। कोयल DO
              चिड़िया की आवाज�:= कोयल=!
            | चिड़िया�: बत्तख। बत्तख डीओ
              चिड़िया। ध्वनि: = नीम हकीम!
        अन्य
              बर्ड.साउंड�:= कलरव!
        अंत
    अंत सेटसाउंड;
    प्रक्रिया MakeSound* (VAR b�: Birds.Bird);
    प्रारंभ
        आउट.लन;
        आउट.स्ट्रिंग (बी.साउंड);
        आउट.ल.न
    अंत बनाओ ध्वनि;
प्रारंभ
    सेटसाउंड (सी);
    सेटसाउंड (डी);
    सेटसाउंड (एसबी);
    मेकसाउंड (सी);
    मेकसाउंड (डी);
    मेकसाउंड (एसबी)
अंत परीक्षण।
</वाक्यविन्यास हाइलाइट>


MODULE Test;
      IMPORT Out, Birds, Cuckoos, Ducks;
 
      TYPE
          SomeBird* = RECORD (Birds.Bird) END;
 
      VAR
          sb : SomeBird;
          c  : Cuckoos.Cuckoo;
          d  : Ducks.Duck;
 
      PROCEDURE SetSound* (VAR bird : Birds.Bird);
      BEGIN
          WITH bird : Cuckoos.Cuckoo DO
              bird.sound := "Cuckoo!"
            | bird : Ducks.Duck DO
              bird.sound := "Quack!"
          ELSE
              bird.sound := "Tweet!"
          END
      END SetSound;
 
      PROCEDURE MakeSound* (VAR b : Birds.Bird);
      BEGIN
          Out.Ln;
          Out.String(b.sound);
          Out.Ln
      END MakeSound;
 
  BEGIN
      SetSound(c);
      SetSound(d);
      SetSound(sb);
 
      MakeSound(c);
      MakeSound(d);
      MakeSound(sb)
  END Test.
==== <code>POINTER</code> ====
==== <code>POINTER</code> ====
<वाक्यविन्यास प्रकाश लैंग = घटकपास्कल>
 
  मॉड्यूल सूचक पक्षी;
  MODULE PointerBirds;
    बाहर आयात करें;
      IMPORT Out;
 
    प्रकार
      TYPE
        बर्डरेक* = रिकॉर्ड
          BirdRec*   = RECORD
            ध्वनि*�: सरणी 10 चार;
              sound* : ARRAY 10 OF CHAR;
        अंत;
          END;
        DuckRec* = रिकॉर्ड (बर्डरैक) END;
          DuckRec*   = RECORD (BirdRec) END;
        CuckooRec* = रिकॉर्ड (बर्डरैक) END;
          CuckooRec* = RECORD (BirdRec) END;
 
        बर्ड = बर्डरेक के लिए सूचक;
          Bird  = POINTER TO BirdRec;
        कोयल = कोयल के लिए सूचक;
          Cuckoo = POINTER TO CuckooRec;
        डक = पॉइंटर टू डक आरईसी;
          Duck  = POINTER TO DuckRec;
 
    वीएआर
    VAR
        पीबी: पक्षी;
        pb : Bird;
        पीसी : कोयल;
        pc : Cuckoo;
        पीडी: बतख;
        pd : Duck;
 
    प्रक्रिया सेट डक साउंड * (पक्षी: बतख);
      PROCEDURE SetDuckSound* (bird : Duck);
    प्रारंभ
      BEGIN
        चिड़िया। ध्वनि: = नीम हकीम!
          bird.sound := "Quack!"
    अंत सेट डक साउंड;
      END SetDuckSound;
 
    प्रक्रिया सेटकोयलसाउंड* (पक्षी: कोयल);
      PROCEDURE SetCuckooSound* (bird : Cuckoo);
    प्रारंभ
      BEGIN
        चिड़िया की आवाज�:= कोयल�!
          bird.sound := "Cuckoo!"
    END सेटCuckooSound;
      END SetCuckooSound;
 
</