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

From Vigyanwiki
No edit summary
No edit summary
 
(12 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 मूल ओबेरॉन (प्रोग्रामिंग लैंग्वेज) [[प्रोग्रामिंग भाषा]] का एक विस्तार है जो सीमित [[प्रतिबिंब (कंप्यूटर विज्ञान)]] और [[ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग]] सुविधाओं को जोड़ता है, पॉइंटर बेस प्रकार के रूप में ऐरे डेटा संरचना को खोलता है, केवल-पढ़ने के लिए फ़ील्ड निर्यात करता है, और पुन: प्रस्तुत करता है। <code>FOR</code> [[मॉड्यूल-2]] -2 से लूप।
ओबेरॉन -2 मूल ओबेरॉन (प्रोग्रामिंग लैंग्वेज) [[प्रोग्रामिंग भाषा]] का ऐसा विस्तार है जो सीमित [[प्रतिबिंब (कंप्यूटर विज्ञान)]] और [[ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग]] सुविधाओं को जोड़ता है, पॉइंटर बेस प्रकार के रूप में ऐरे डेटा संरचना को खोलता है, केवल-पढ़ने के लिए फ़ील्ड निर्यात करता है,और [[मॉड्यूल-2]] से फॉर लूप को पुन: प्रस्तुत करता है।


इसे 1991 में ETH ज्यूरिख में [[Niklaus Wirth]] और :de: Hanspeter Mössenbock | 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 92: Line 84:


=== खुली सरणी ===
=== खुली सरणी ===
सरणी में जिसे पहले केवल औपचारिक पैरामीटर प्रकार के रूप में घोषित किया जा सकता था, अब सूचक आधार प्रकार के रूप में घोषित किया जा सकता है।
सरणी में जिसे पहले केवल औपचारिक पैरामीटर प्रकार के रूप में घोषित किया जा सकता था,उन्हें अब सूचक आधार प्रकार के रूप में घोषित किया जा सकता है।


=== कथन के लिए === <code>FOR</code> ई> पास्कल और मोडुला-2 का बयान ओबेरॉन में लागू नहीं किया गया था। इसे ओबेरॉन-2 में फिर से सम्मलित किया गया है।
=== '''कथन के लिए''' ===
ओबेरॉन में पास्कल और मोडुला-2 का फॉर स्टेटमेंट में लागू नहीं किया गया था। इसे ओबेरॉन-2 में फिर से सम्मलित किया गया है।


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


पहला, सबसे पारंपरिक, दृष्टिकोण प्रकार बाध्यकारी प्रणाली पर भरोसा करना है। दूसरा विधिउपयोग करना है<code>WITH</code> बयान, जो एक चर के गतिशील उपप्रकार को सीधे जांचने की अनुमति देता है। दोनों ही स्थितियों में, एक बार उपप्रकार की पहचान हो जाने के बाद, प्रोग्रामर उपप्रकार के लिए उपयुक्त किसी भी प्रकार की बाध्य प्रक्रियाओं या चर का उपयोग कर सकता है। इन दृष्टिकोणों के उदाहरण नीचे दिखाए गए हैं।
ध्यान दें कि ओबेरॉन-2 में प्रयुक्त विथ स्टेटमेंट का फॉर्म पास्कल और मोडुला-2 विथ स्टेटमेंट से संबंधित नहीं है। रिकॉर्ड फ़ील्ड तक पहुंच को संक्षिप्त करने की यह विधि ओबेरॉन या ओबेरॉन -2 में लागू नहीं किया गया है।


ध्यान दें कि का रूप <code>WITH</code> ओबेरॉन-2 में प्रयुक्त बयान पास्कल और मोडुला-2 के साथ बयान से संबंधित नहीं है। रिकॉर्ड फ़ील्ड तक पहुंच को संक्षिप्त करने का यह विधिओबेरॉन या ओबेरॉन -2 में लागू नहीं किया गया है।
==== बाइंडिंग टाइप करें ====
  MODULE Birds;
      TYPE
          Bird* = RECORD
              sound* : ARRAY 10 OF CHAR;
          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> कथन ====


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