ओबेरोन -2

From Vigyanwiki
Revision as of 19:41, 23 February 2023 by alpha>Poonam Singh
Oberon-2
Oberon programming language logo.svg
ParadigmsImperative, structured, modular, object-oriented
परिवारWirth Oberon
द्वारा डिज़ाइन किया गयाNiklaus Wirth
Hanspeter Mössenböck
DeveloperETH Zurich
पहली प्रस्तुति1991; 33 years ago (1991)
टाइपिंग अनुशासनStrong, hybrid (static and dynamic)
स्कोपLexical
प्लेटफॉर्मCeres (NS32032), IA-32, x86-64
ओएसWindows, Linux, Solaris, macOS
वेबसाइटwww.ethoberon.ethz.ch
Influenced by
Oberon, Modula-2, Object Oberon
Influenced
Oberon-07, Zonnon, Active Oberon, Component Pascal, Go, Nim

ओबेरॉन -2 मूल ओबेरॉन (प्रोग्रामिंग लैंग्वेज) प्रोग्रामिंग भाषा का एक विस्तार है जो सीमित प्रतिबिंब (कंप्यूटर विज्ञान) और ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग सुविधाओं को जोड़ता है, पॉइंटर बेस प्रकार के रूप में ऐरे डेटा संरचना को खोलता है, केवल-पढ़ने के लिए फ़ील्ड निर्यात करता है,और मॉड्यूल-2 से फॉर लूप को पुन: प्रस्तुत करता है।

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

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

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

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

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

भाषा घटक पास्कल[2] ओबेरॉन-2 का परिशोधन (एक सुपरसेट) है।

उदाहरण कोड

निम्नलिखित ओबेरॉन -2 कोड एक साधारण बाइनरी ट्री को लागू करता है:

<वाक्यविन्यास प्रकाश लैंग = सीपी शैली = फ़ॉन्ट-आकार: 10pt> मॉड्यूल पेड़;

प्रकार 

   ट्री * = पॉइंटर टू नोड;
   नोड* = रिकॉर्ड
       नाम-: चार की सरणी के लिए सूचक;
       बाएँ, दाएँ: पेड़
   अंत;

प्रक्रिया (टी: ट्री) डालें* (नाम: चार की सरणी); 

   वार पी, पिता: वृक्ष;

BEGIN p := t; 

   रिपीट फादर := p;
       IF नाम = p.name ^ फिर वापसी अंत;
       IF नाम <p.name^ THEN p := p.left ELSE p := p.right END
   जब तक पी = शून्य;
   नया पी); p.बाएँ:= शून्य; p.right := शून्य; नया (पी.नाम, एलईएन (नाम) +1); कॉपी (नाम, पी। नाम ^);
   IF नाम <Father.name^ THEN father.left := p ELSE father.right:= p END

अंत डालें;

प्रक्रिया (टी: पेड़) खोज* (नाम: चार की सरणी): पेड़; 

   वार पी: ट्री;

BEGIN p := t; 

   जबकि (पी # एनआईएल) और (नाम # पी.नाम ^) डीओ
       IF नाम <p.name^ THEN p := p.left ELSE p := p.right END
   अंत;
   रिटर्न पी

अंत खोज;

प्रक्रिया NewTree* (): ट्री; 

   वर टी: ट्री;

नया प्रारंभ करें (टी); नया (टी.नाम, 1); टी नाम [0] := 0X; t.बाएँ:= शून्य; टी.राइट := शून्य; वापसी टी न्यूट्री समाप्त करें;

अंत पेड़। </वाक्यविन्यास हाइलाइट>

ओबेरॉन -2 एक्सटेंशन ओबेरॉन के लिए[3]

टाइप-बाउंड प्रक्रियाएं

प्रक्रियाओं को एक रिकॉर्ड (या सूचक) प्रकार के लिए बाध्य किया जा सकता है। वे वस्तु-उन्मुख शब्दावली में उदाहरण के विधियों के बराबर हैं।

केवल-पढ़ने के लिए निर्यात

निर्यात किए गए चर और रिकॉर्ड फ़ील्ड का उपयोग केवल-पढ़ने के लिए उपयोग तक सीमित किया जा सकता है। यह - दृश्यता ध्वज के साथ दिखाया गया है।

खुली सरणी

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

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

रनटाइम प्रकार की जाँच

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

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

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

बाइंडिंग टाइप करें

<वाक्यविन्यास प्रकाश लैंग = घटकपास्कल> 

मॉड्यूल पक्षी;
    प्रकार
        पक्षी* = रिकॉर्ड
            ध्वनि*�: सरणी 10 चार;
        अंत;
अंत पक्षी।

मॉड्यूल बतख;
    आयात पक्षी;

    प्रकार
        बतख * = रिकॉर्ड (पक्षी। पक्षी) अंत;

    प्रक्रिया सेटसाउंड * (वार पक्षी: बतख);
    प्रारंभ
        चिड़िया। ध्वनि: = नीम हकीम!
    अंत सेटसाउंड;
अंत बतख।

मॉड्यूल कोयल;
    आयात पक्षी;

    प्रकार
        कोयल* = रिकॉर्ड (पक्षी। पक्षी) अंत;

    प्रक्रिया सेटसाउंड * (वार पक्षी: कोयल);
    प्रारंभ
        चिड़िया की आवाज�:= कोयल�!
    अंत सेटसाउंड;
अंत कोयल।

</वाक्यविन्यास हाइलाइट>

WITH बयान

<वाक्यविन्यास प्रकाश लैंग = घटकपास्कल> 

मॉड्यूल टेस्ट;
    आयात बाहर, पक्षी, कोयल, बत्तख;

    प्रकार
        समबर्ड* = रिकॉर्ड (पक्षी.पक्षी) END;

    वीएआर
        एसबी: समबर्ड;
        c : कोयल। कोयल;
        डी: बत्तख। बत्तख;

    प्रक्रिया सेटसाउंड * (वार पक्षी: पक्षी। पक्षी);
    प्रारंभ
        पक्षी के साथ: कोयल। कोयल DO
             चिड़िया की आवाज�:= कोयल=!
           | चिड़िया�: बत्तख। बत्तख डीओ
             चिड़िया। ध्वनि: = नीम हकीम!
        अन्य
             बर्ड.साउंड�:= कलरव!
        अंत
    अंत सेटसाउंड;

    प्रक्रिया MakeSound* (VAR b�: Birds.Bird);
    प्रारंभ
        आउट.लन;
        आउट.स्ट्रिंग (बी.साउंड);
        आउट.ल.न
    अंत बनाओ ध्वनि;

प्रारंभ
    सेटसाउंड (सी);
    सेटसाउंड (डी);
    सेटसाउंड (एसबी);

    मेकसाउंड (सी);
    मेकसाउंड (डी);
    मेकसाउंड (एसबी)
अंत परीक्षण।

</वाक्यविन्यास हाइलाइट>

POINTER

<वाक्यविन्यास प्रकाश लैंग = घटकपास्कल> 

मॉड्यूल सूचक पक्षी;
    बाहर आयात करें;

    प्रकार
        बर्डरेक* = रिकॉर्ड
            ध्वनि*�: सरणी 10 चार;
        अंत;
        DuckRec* = रिकॉर्ड (बर्डरैक) END;
        CuckooRec* = रिकॉर्ड (बर्डरैक) END;

        बर्ड = बर्डरेक के लिए सूचक;
        कोयल = कोयल के लिए सूचक;
        डक = पॉइंटर टू डक आरईसी;

   वीएआर
       पीबी: पक्षी;
       पीसी : कोयल;
       पीडी: बतख;

    प्रक्रिया सेट डक साउंड * (पक्षी: बतख);
    प्रारंभ
        चिड़िया। ध्वनि: = नीम हकीम!
    अंत सेट डक साउंड;

    प्रक्रिया सेटकोयलसाउंड* (पक्षी: कोयल);
    प्रारंभ
        चिड़िया की आवाज�:= कोयल�!
    END सेटCuckooSound;

    प्रक्रिया सेटसाउंड * (पक्षी: पक्षी);
    प्रारंभ
        पक्षी के साथ�: कोयल DO
             कुक्कूसाउंड (पक्षी) सेट करें
           | पक्षी�: बतख DO
             सेट डक साउंड (पक्षी)
        अन्य
             बर्ड.साउंड := कलरव!
        अंत
    अंत सेटसाउंड;

प्रारंभ
    नया (पीसी);
    नया (पीडी);

    सेट कुकूसाउंड (पीसी);
    सेट डक साउंड (पीडी);

    आउट.लन; आउट.स्ट्रिंग (पीसी ^ ध्वनि); आउट.लन;
    आउट.लन; आउट.स्ट्रिंग (पीडी ^ ध्वनि); आउट.लन;

    सेटसाउंड (पीसी);
    सेटसाउंड (पीडी);

    आउट.लन; आउट.स्ट्रिंग (पीसी ^ ध्वनि); आउट.लन;
    आउट.लन; आउट.स्ट्रिंग (पीडी ^ ध्वनि); आउट.लन;

(* ----------------------------------------------------- *)
(* प्रक्रिया के लिए गतिशील प्रकार पास करें *)

    पीबी: = पीडी;

    सेटडकसाउंड (पंजाब (बतख));
    आउट.लन; आउट.स्ट्रिंग (पीबी ^ ध्वनि); आउट.लन;

    पंजाब�:= पीसी;

    सेट कुकूसाउंड (पंजाब (कोयल));
    आउट.लन; आउट.स्ट्रिंग (पीबी ^ ध्वनि); आउट.लन;

(* ----------------------------------------------------- *)

    सेटसाउंड (पंजाब);
    आउट.लन; आउट.स्ट्रिंग (पीबी ^ ध्वनि); आउट.लन;

    पीबी: = पीडी;

    सेटसाउंड (पंजाब);
    आउट.लन; आउट.स्ट्रिंग (पीबी ^ ध्वनि); आउट.लन;

(* ----------------------------------------------------- *)

    नया (पंजाब);

    सेटसाउंड (पंजाब);
    आउट.लन; आउट.स्ट्रिंग (पीबी ^ ध्वनि); आउट.ल.न
अंत सूचक पक्षी।

</वाक्यविन्यास हाइलाइट>

IS संचालिका

का उपयोग कर एक तीसरा दृष्टिकोण संभव हैIS ऑपरेटर। यह एक रिलेशन ऑपरेटर है जिसकी समान प्राथमिकता बराबर (=), बड़ा (>), आदि किन्तु जो गतिशील प्रकार का परीक्षण करता है। दो अन्य दृष्टिकोणों के विपरीत, चूंकि, यह प्रोग्रामर को उस उपप्रकार तक पहुंचने की अनुमति नहीं देता है जिसका पता लगाया गया है।

सिंटेक्स

ALGOL → पास्कल (प्रोग्रामिंग भाषा) → मोडुला-2 → ओबेरॉन → घटक पास्कल भाषा परिवार का विकास सिंटैक्स (प्रोग्रामिंग भाषाओं) की जटिलता में कमी से चिह्नित है। संपूर्ण ओबेरॉन -2 भाषा का वर्णन किया गया है (मोसेनबॉक एंड विर्थ, मार्च 1995) विस्तारित बैकस-नौर रूप में केवल 33 व्याकरणिक प्रस्तुतियों का उपयोग करते हुए, जैसा कि नीचे दिखाया गया है।

<वाक्यविन्यास लैंग = ईबीएनएफ> मॉड्यूल = मॉड्यूल पहचान; [ImportList] DeclSeq [BEGIN StatementSeq] END पहचान। . आयात सूची = आयात [पहचान: =] पहचान {, [पहचान: =] पहचान}; . DeclSeq = { CONST {ConstDecl; } | प्रकार {टाइपडीसीएल; } | वार {VarDecl ; }} {ProcDecl; | आगेDecl ; }. ConstDecl = IdentDef = ConstExpr. TypeDecl = IdentDef = Type. VarDecl = पहचान सूची: प्रकार। ProcDecl = प्रक्रिया [रिसीवर] IdentDef [FormalPars]; DeclSeq [BEGIN StatementSeq] END पहचान। ForwardDecl = PROCEDURE ^ [रिसीवर] IdentDef [FormalPars]। FormalPars = ([FPSection { ; FPSection}] ) [ : योग्य]। FPSection = [VAR] पहचान {, पहचान} : प्रकार। रिसीवर = ([VAR] पहचान: पहचान)। प्रकार = योग्य 

             | ARRAY [ConstExpr { , ConstExpr}] प्रकार का
             | रिकॉर्ड [( योग्य ) ] फील्डलिस्ट { ; फील्डलिस्ट} अंत
             | टाइप करने के लिए सूचक
             | प्रक्रिया [औपचारिक पार]।

फील्डलिस्ट = [पहचान सूची: प्रकार]। स्टेटमेंटसेक = स्टेटमेंट {; कथन}। कथन = [Designator := Expr 

             | डिज़ाइनर [( [ExprList] ) ]
             | IF Expr THEN StatementSeq {ELSIF Expr THEN StatementSeq} [ELSE StatementSeq] END
             | केस एक्सप्रेशन ऑफ केस { | Case} [ELSE StatementSeq] END
             | जबकि Expr DO StatementSeq END
             | रिपीट स्टेटमेंटSeq Expr तक
             | पहचान के लिए:= Expr से Expr [BY ConstExpr] DO StatementSeq END
             | पाश StatementSeq अंत
             | विद गार्ड डीओ स्टेटमेंटसेक { | गार्ड DO StatementSeq} [ELSE StatementSeq] END
             | बाहर निकलना
             | रिटर्न [एक्सप्र]
     ]।

केस = [केस लेबल { , केस लेबल} : स्टेटमेंटसेक]। CaseLabels = ConstExpr [.. ConstExpr]। पहरेदार = योग्य : योग्य। कॉन्स्टएक्सपीआर = एक्सप्रेशन। Expr = SimpleExpr [रिलेशन SimpleExpr]। सिंपलएक्सप्र = [+ | - ] अवधि {AddOp अवधि}। टर्म = फैक्टर {MulOp फैक्टर}। कारक = डिज़ाइनर [([ExprList])] | संख्या | चरित्र | स्ट्रिंग | शून्य | सेट | (एक्सपीआर) | ~ कारक। सेट = { [तत्व {, तत्व}]}। तत्व = एक्सप्रेशन [.. एक्सप्र]। संबंध = = | # | < | <= | > | >= | में | है। एडऑप = + | - | या। मुलोप = * | / | डीआईवी | एमओडी | और। डिज़ाइनर = क्वालिडेंट {। पहचान | [एक्सप्रलिस्ट] | ^ | (योग्यता)}। एक्सप्रलिस्ट = एक्सप्र {, एक्सप्र}। IdentList = IdentDef {, IdentDef}। पात्रा = [पहचान । ] पहचान। पहचान डीफ = पहचान [* | - ]। </वाक्यविन्यास हाइलाइट>

कार्यान्वयन

ईटीएच द्वारा अनुरक्षित ओबेरॉन-2 कंपाइलर्स में खिड़कियाँ, लिनक्स, सोलारिस (ऑपरेटिंग सिस्टम), मैकओएस के संस्करण सम्मलित हैं।

ऑक्सफोर्ड ओबेरॉन-2 कंपाइलर देशी मशीन कोड के लिए संकलित करता है और विंडोज, लिनक्स और मैक ओएस एक्स पर एक जेआईटी का उपयोग कर सकता है। इसे बनाया गया है/ माइकल स्पाइवी द्वारा अनुरक्षित और कीको वर्चुअल मशीन का उपयोग करता है।Cite error: Closing </ref> missing for <ref> tag मोसेनबॉक और विर्थ संदर्भ में एक के आधार पर, मैनचेस्टर विश्वविद्यालय, यूके के स्टीफन जे बेवन द्वारा ओबेरॉन -2 लेक्स (सॉफ्टवेयर) स्कैनर और वाईएसीसी पार्सर है। यह संस्करण 1.4 पर है।

देशी ओबेरॉन नामक एक रिलीज़ है जिसमें एक ऑपरेटिंग सिस्टम सम्मलित है, और सीधे पीसी क्लास हार्डवेयर पर बूट हो सकता है।

ETHZ में कुछ मामूली .NET-संबंधित एक्सटेंशन के साथ ओबेरॉन का .NET फ्रेमवर्क|.NET कार्यान्वयन भी विकसित किया गया है।

प्रोग्रामर का खुला कार्यक्षेत्र (पाउ!)[4] एक बहुत ही सरल एकीकृत विकास वातावरण है, जो संपादक, लिंकर और ओबेरॉन -2 संकलक के साथ प्रदान किया जाता है। यह Microsoft Windows निष्पादनयोग्य के लिए संकलित है। पूर्ण स्रोत कोड प्रदान किया गया है; कंपाइलर ओबेरॉन -2 में लिखा गया है।

Java to Oberon Compiler (JOB) रूस के वोलोग्दा विश्वविद्यालय में लिखा गया था। यह जावा क्लास फाइल्स (बाईटकोड) के रूप में ऑब्जेक्ट कोड तैयार करता है। कुछ जॉब-विशिष्ट वर्ग प्रदान किए जाते हैं जो जावा संगत हैं, किन्तु जो अधिक ओबेरॉन-जैसे घटक पदानुक्रम का उपयोग करते हैं।

ऑप्टिमाइज़िंग ओबेरॉन-2 कंपाइलर कार्यक्रम बनाने के लिए जीएनयू संकलक संग्रह (GCC) टूलचेन का उपयोग करके C में संकलित करता है।

ओबेरॉन स्क्रिप्ट एक कंपाइलर है जो संपूर्ण ओबेरॉन भाषा का जावास्क्रिप्ट में अनुवाद करता है। कंपाइलर जावास्क्रिप्ट में लिखा गया है और इस प्रकार ओबेरॉन में लिखी गई स्क्रिप्ट को प्रोसेस करने के लिए वेब पेजों से बुलाया जा सकता है।

XDS Modula2/Oberon2 एक्सेलसियर एलएलसी, नोवोसिबिर्स्क, रूस द्वारा एक विकास प्रणाली है। इसमें इंटेल पेंटियम के लिए एक ऑप्टिमाइज़िंग कंपाइलर या क्रॉस-प्लेटफ़ॉर्म सॉफ़्टवेयर डेवलपमेंट के लिए वाया-सी ट्रांसलेटर सम्मलित है। विंडोज और लिनक्स के लिए उपलब्ध है। कंपाइलर ओबेरॉन -2 में लिखा गया है और खुद को कंपाइल करता है।

ओबेरॉन रिवाइवल ओबेरॉन 2 और कंपोनेंट पास्कल (ब्लैकबॉक्स घटक बिल्डर) को लिनक्स और विन32 में लाने की एक परियोजना है। ब्लैकबॉक्स का लिनक्स पोर्ट पहले अनुपलब्ध था और यह मूल रूप से केवल माइक्रोसॉफ़्ट विंडोज़ पर चलता था।

XOberon PowerPC के लिए एक रीयल-टाइम ऑपरेटिंग सिस्टम है, जिसे ओबेरॉन-2 में लिखा गया है।

पोर्टेबल ओबेरॉन-2 कंपाइलर (ओपी2) को ओबेरॉन सिस्टम को व्यावसायिक रूप से उपलब्ध प्लेटफॉर्म पर पोर्ट करने के लिए विकसित किया गया था।[5]

कीको बायटेकोड

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

यह भी देखें

संदर्भ

  1. ↑ "Related Reading". Dr. Dobb's.
  2. ↑ Pfister, Cuno (2001). "What's New in Component Pascal (changes from Oberon-2 to CP)" (PDF). Oberon microsystems. Archived from the original (PDF) on 2011-05-15. Retrieved 10 January 2007.
  3. ↑ Differences between Oberon and Oberon-2, Mössenböck and Wirth (1993)
  4. ↑ Collingbourne, H. (February 2000). "What Pascal's inventor did next". PC Plus. No. 160.
  5. ↑ Crelier, Régis (1994). Separate Compilation and Module Extension (Doctoral Thesis). ETH Zurich. doi:10.3929/ethz-a-000945227. hdl:20.500.11850/141604. Retrieved 18 November 2018.
  6. ↑ Cite error: Invalid <ref> tag; no text was provided for refs named keiko_spec
  7. ↑ Cite error: Invalid <ref> tag; no text was provided for refs named keiko machine


=== ओबेरॉन और ओबेरॉन -2 === का विकास

  • Oberon Language Genealogy Tree ETHZ में अनुरक्षित
  • दूसरा अंतर्राष्ट्रीय मोडुला-2 सम्मेलन, सितंबर 1991।

विस्तृत कागजात

किताबें

Wikibooks has a book on the topic of: Oberon

बाहरी संबंध

Retrieved from ‘https://www.vigyanwiki.in/index.php?title=ओबेरोन_-2&oldid=96875’