रेक्स: Difference between revisions

From Vigyanwiki
No edit summary
No edit summary
Line 1: Line 1:
{{Short description|Command/scripting/programming language}}
{{Short description|Command/scripting/programming language}}{{Infobox programming language
 
{{manual|date=September 2022}}
{{trivia|date=September 2022}}
{{Infobox programming language
| logo = [[File:Rexx-img-lg.png|frameless]]
| logo = [[File:Rexx-img-lg.png|frameless]]
| paradigm = [[multi-paradigm programming language|multiparadigm]]: [[procedural programming|procedural]], [[structured programming|structured]]
| paradigm = [[multi-paradigm programming language|multiparadigm]]: [[procedural programming|procedural]], [[structured programming|structured]]
Line 126: Line 122:


== सिंटेक्स ==
== सिंटेक्स ==
{{manual|section|date=December 2012}}




Line 132: Line 127:
रेक्स में लूप नियंत्रण संरचना <code>DO</code> से प्रारंभ होता है और <code>END</code> के साथ समाप्त होता है लेकिन कई किस्मों में आता है। नेटरेक्स लूपिंग के लिये <code>DO</code> के अतिरिक्त कीवर्ड <code>LOOP</code> का उपयोग करता है जबकि ooRexx लूप करते समय <code>LOOP</code> तथा <code>DO</code> को समतुल्य मानता है।
रेक्स में लूप नियंत्रण संरचना <code>DO</code> से प्रारंभ होता है और <code>END</code> के साथ समाप्त होता है लेकिन कई किस्मों में आता है। नेटरेक्स लूपिंग के लिये <code>DO</code> के अतिरिक्त कीवर्ड <code>LOOP</code> का उपयोग करता है जबकि ooRexx लूप करते समय <code>LOOP</code> तथा <code>DO</code> को समतुल्य मानता है।


==== सशर्त पाश ====
==== सशर्त लूप ====
रेक्स कई प्रकार के पारंपरिक संरचित-प्रोग्रामिंग लूप का समर्थन करता है, जबकि किसी स्थिति का परीक्षण करने से पहले (<code>do while</code>) या बाद में (<code>do until</code>) निर्देशों की सूची निष्पादित हो जाती है:
रेक्स कई प्रकार के पारंपरिक संरचित-प्रोग्रामिंग लूप का समर्थन करता है, जबकि किसी स्थिति का परीक्षण करने से पहले (<code>do while</code>) या बाद में (<code>do until</code>) निर्देशों की सूची निष्पादित हो जाती है:
  जबकि [हालत]
  do while [condition]                                                                                     [instructions]
[निर्देश]
  end
  समाप्त
  do until [condition]
 
  [instructions]
  [शर्त] तक करो
  end
  [निर्देश]
  समाप्त


==== दोहराए जाने वाले लूप्स ====
==== दोहराए जाने वाले लूप्स ====
अधिकांश भाषाओं की तरह, रेक्स एक इंडेक्स वेरिएबल को बढ़ाते समय लूप कर सकता है और एक सीमा तक पहुंचने पर रुक सकता है:
अधिकांश भाषाओं की तरह, रेक्स एक इंडेक्स वेरिएबल को बढ़ाते समय लूप कर सकता है और एक सीमा तक पहुंचने पर रुक सकता है:
  अनुक्रमणिका करें = प्रारंभ [सीमित करने के लिए] [वृद्धि द्वारा] [गिनती के लिए]
  do index = start [to limit] [by increment] [for count]                                                 [instructions]
[निर्देश]
  end
  समाप्त
वेतन वृद्धि को छोड़ा जा सकता है और 1 के लिए डिफॉल्ट किया जा सकता है। सीमा को भी छोड़ा जा सकता है, जिससे लूप हमेशा के लिए जारी रहता है।
वेतन वृद्धि को छोड़ा जा सकता है और 1 के लिए डिफॉल्ट किया जा सकता है। सीमा को भी छोड़ा जा सकता है, जिससे लूप हमेशा के लिए जारी रहता है।


रेक्स गिने हुए लूप की अनुमति देता है, जहां लूप की प्रारंभ में एक एक्सप्रेशन की गणना की जाती है और लूप के भीतर के निर्देशों को कई बार निष्पादित किया जाता है:
रेक्स गिने हुए लूप की अनुमति देता है, जहां लूप की प्रारंभ में एक एक्सप्रेशन की गणना की जाती है और लूप के भीतर के निर्देशों को कई बार निष्पादित किया जाता है:


<वाक्यविन्यास हाइलाइट लैंग = रेक्स शैली = पृष्ठभूमि-रंग: #ffffff; महत्वपूर्ण>
<syntax-highlight lang=rex style=background-color: #ffffff; important>
  अभिव्यक्ति करो
  do expression                                                                                [instructions]
[निर्देश]
  end
समाप्त
 
</वाक्यविन्यास हाइलाइट>
 
</syntax highlight>


कार्यक्रम समाप्त होने तक रेक्स भी लूप कर सकता है:
कार्यक्रम समाप्त होने तक रेक्स भी लूप कर सकता है:


<वाक्यविन्यास हाइलाइट लैंग = रेक्स शैली = पृष्ठभूमि-रंग: #ffffff; महत्वपूर्ण>
<syntax-highlight lang=rex style=background-color: #ffffff; important>
  हमेशा के लिए करो
  do forever                                                                                              [instructions]
[निर्देश]
  end
  समाप्त
</syntax highlight>
</वाक्यविन्यास हाइलाइट>


<code>leave</code> निर्देश के साथ एक प्रोग्राम वर्तमान लूप से बाहर निकल सकता है, जो <code>do forever</code> लूप से बाहर निकलने का सामान्य विधि है, या <code>iterate</code> निर्देश के साथ शॉर्ट-सर्किट कर सकता है।
<code>leave</code> निर्देश के साथ एक प्रोग्राम वर्तमान लूप से बाहर निकल सकता है, जो <code>do forever</code> लूप से बाहर निकलने का सामान्य विधि है, या <code>iterate</code> निर्देश के साथ शॉर्ट-सर्किट कर सकता है।
Line 170: Line 162:
PL/I की तरह, रेक्स सशर्त और दोहराए जाने वाले दोनों तत्वों को एक ही लूप में संयोजित करने की अनुमति देता है:<ref name="TRL">{{cite book |title=द रेक्स लैंग्वेज - ए प्रैक्टिकल एप्रोच टू प्रोग्रामिंग|author=M. F. Cowlishaw |author-link=Mike Cowlishaw |isbn=0-13-780651-5 |publisher=[[Prentice Hall]] |edition=2nd |year=1990}}</ref>
PL/I की तरह, रेक्स सशर्त और दोहराए जाने वाले दोनों तत्वों को एक ही लूप में संयोजित करने की अनुमति देता है:<ref name="TRL">{{cite book |title=द रेक्स लैंग्वेज - ए प्रैक्टिकल एप्रोच टू प्रोग्रामिंग|author=M. F. Cowlishaw |author-link=Mike Cowlishaw |isbn=0-13-780651-5 |publisher=[[Prentice Hall]] |edition=2nd |year=1990}}</ref>


<वाक्यविन्यास हाइलाइट लैंग = रेक्स शैली = पृष्ठभूमि-रंग: #ffffff; महत्वपूर्ण>
<syntax-highlight lang=rex style=background-color: #ffffff; important>
  अनुक्रमणिका करें = प्रारंभ [सीमित करने के लिए] [वृद्धि द्वारा] [गिनती के लिए] [जबकि स्थिति]
  do index = start [to limit] [by increment] [for count] [while condition]                       [instructions]
[निर्देश]
  end
  समाप्त
</syntax highlight>
</वाक्यविन्यास हाइलाइट>


<वाक्यविन्यास हाइलाइट लैंग = रेक्स शैली = पृष्ठभूमि-रंग: #ffffff; महत्वपूर्ण>
<syntax-highlight lang=rex style=background-color: #ffffff; important>
  अभिव्यक्ति करो [शर्त तक]
  do expression [until condition]                                                                 [instructions]
[निर्देश]
  end
  समाप्त
</syntax highlight>
</वाक्यविन्यास हाइलाइट>


=== सशर्त ===
=== सशर्त ===


<code>IF</code>के साथ परीक्षण की स्थिति :
<code>IF</code>के साथ परीक्षण की स्थिति:


<वाक्यविन्यास हाइलाइट लैंग = रेक्स शैली = पृष्ठभूमि-रंग: #ffffff; महत्वपूर्ण>
<syntax-highlight lang=rex style=background-color: #ffffff; important>
  यदि [शर्त] तो
  if [condition] then                                                                                            do
करना
  [instructions]
  [निर्देश]
  end
  समाप्त
  else
  वरना
  do
  करना
  [instructions]
  [निर्देश]
  end
  समाप्त
</syntax highlight> <code>ELSE</code> ई> खंड वैकल्पिक है।
</वाक्यविन्यास हाइलाइट> <code>ELSE</code> ई> खंड वैकल्पिक है।


एकल निर्देशों के लिए, <code>DO</code> तथा <code>END</code> छोड़ा भी जा सकता है:
एकल निर्देशों के लिए, <code>DO</code> तथा <code>END</code> छोड़ा भी जा सकता है:


<वाक्यविन्यास हाइलाइट लैंग = रेक्स शैली = पृष्ठभूमि-रंग: #ffffff; महत्वपूर्ण>
<syntax-highlight lang=rex style=background-color: #ffffff; important>
  यदि [शर्त] तो
  if [condition] then                                                                                      [instruction]
[निर्देश]
  else
वरना
  [instruction]
[निर्देश]
</syntax highlight>
</वाक्यविन्यास हाइलाइट>


इंडेंटेशन वैकल्पिक है, लेकिन यह पठनीयता में सुधार करने में सहायता करता है।
इंडेंटेशन वैकल्पिक है, लेकिन यह पठनीयता में सुधार करने में सहायता करता है।
Line 212: Line 200:
<code>SELECT</code> रेक्स का [[स्विच स्टेटमेंट]] है, जैसे PL/I से प्राप्त कई अन्य निर्माण। अन्य गतिशील भाषाओं में CASE निर्माण के कुछ कार्यान्वयनों की तरह, Rexx का <code>WHEN</code> क्लॉज़ पूरी शर्तों को निर्दिष्ट करता है, जिनका एक दूसरे से संबंधित होने की आवश्यकता नहीं है। उसमें, वे C या Java <code>switch</code> स्टेटमेंट की तुलना में <code>IF-THEN-ELSEIF-THEN-...-ELSE</code> कोड के कैस्केड सेट की तरह अधिक हैं।
<code>SELECT</code> रेक्स का [[स्विच स्टेटमेंट]] है, जैसे PL/I से प्राप्त कई अन्य निर्माण। अन्य गतिशील भाषाओं में CASE निर्माण के कुछ कार्यान्वयनों की तरह, Rexx का <code>WHEN</code> क्लॉज़ पूरी शर्तों को निर्दिष्ट करता है, जिनका एक दूसरे से संबंधित होने की आवश्यकता नहीं है। उसमें, वे C या Java <code>switch</code> स्टेटमेंट की तुलना में <code>IF-THEN-ELSEIF-THEN-...-ELSE</code> कोड के कैस्केड सेट की तरह अधिक हैं।


<वाक्यविन्यास हाइलाइट लैंग = रेक्स शैली = पृष्ठभूमि-रंग: #ffffff; महत्वपूर्ण>
<syntax-highlight lang=rex style=background-color: #ffffff; important>
  चुनते हैं
  select                                                                                          when[condition] then
जब [हालत] तब
  [instruction] or NOP
[निर्देश] या एनओपी
  when [condition] then
जब [हालत] तब
  do
करना
  [instructions] or NOP
[निर्देश] या एनओपी
  end
समाप्त
  otherwise
अन्यथा
  [instructions] or NOP
[निर्देश] या एनओपी
  end
समाप्त
 
</वाक्यविन्यास हाइलाइट> <code>NOP</code> e> निर्देश कोई ऑपरेशन नहीं करता है, और इसका उपयोग तब किया जाता है जब प्रोग्रामर कुछ भी नहीं करना चाहता है जहां एक या अधिक निर्देशों की आवश्यकता होती है।
</syntax highlight> <code>NOP</code> e> निर्देश कोई ऑपरेशन नहीं करता है, और इसका उपयोग तब किया जाता है जब प्रोग्रामर कुछ भी नहीं करना चाहता है जहां एक या अधिक निर्देशों की आवश्यकता होती है।


अन्यथा खंड वैकल्पिक है। यदि छोड़ दिया जाता है और कोई WHEN शर्तें पूरी नहीं होती हैं, तो SYNTAX की स्थिति बढ़ जाती है।
अन्यथा खंड वैकल्पिक है। यदि छोड़ दिया जाता है और कोई WHEN शर्तें पूरी नहीं होती हैं, तो SYNTAX की स्थिति बढ़ जाती है।
Line 231: Line 219:
रेक्स में वेरिएबल्स टाइपलेस हैं, और प्रारंभ में अपर केस में उनके नाम के रूप में मूल्यांकन किया जाता है। इस प्रकार कार्यक्रम में इसके उपयोग के साथ एक चर का प्रकार भिन्न हो सकता है:
रेक्स में वेरिएबल्स टाइपलेस हैं, और प्रारंभ में अपर केस में उनके नाम के रूप में मूल्यांकन किया जाता है। इस प्रकार कार्यक्रम में इसके उपयोग के साथ एक चर का प्रकार भिन्न हो सकता है:


<वाक्यविन्यास लैंग = रेक्स>
<syntax lang=rex>
  नमस्ते कहो /* => नमस्कार */
  say hello /* => HELLO */                                                                                 hello = 25
नमस्ते = 25
  say hello /* => 25 */
नमस्ते कहो /* => 25 */
  hello = "say 5 + 3"
हैलो = 5 + 3 कहो
  say hello /* => say 5 + 3 */
हैलो कहें /* => कहें 5 + 3 */
  interpret hello /* => 8 */
व्याख्या हैलो /* => 8 */
  drop hello
ड्रॉप हैलो
  say hello /* => HELLO */  
नमस्ते कहो /* => नमस्कार */
</syntax highlight>
</वाक्यविन्यास हाइलाइट>


=== यौगिक चर ===
=== यौगिक चर ===


कई अन्य प्रोग्रामिंग भाषाओं के विपरीत, पारंपरिक रेक्स के पास संख्यात्मक सूचकांक द्वारा संबोधित चर के सरणियों के लिए कोई प्रत्यक्ष समर्थन नहीं है। इसके अतिरिक्त यह यौगिक चर प्रदान करता है।<ref>{{Cite web|url=http://www.uic.edu/depts/accc/software/regina/rexxrule.html#p02h24|title=Rexx के लिए अंगूठे के छह नियम}}</ref> एक मिश्रित चर में एक तना होता है जिसके बाद एक पूंछ होती है। ए । (डॉट) का उपयोग तने को पूंछ से जोड़ने के लिए किया जाता है। यदि उपयोग की जाने वाली पूंछ संख्यात्मक हैं, तो सरणी के समान प्रभाव उत्पन्न करना आसान है।
कई अन्य प्रोग्रामिंग भाषाओं के विपरीत, पारंपरिक रेक्स के पास संख्यात्मक सूचकांक द्वारा संबोधित चर के सरणियों के लिए कोई प्रत्यक्ष समर्थन नहीं है। इसके अतिरिक्त यह यौगिक चर प्रदान करता है।<ref>{{Cite web|url=http://www.uic.edu/depts/accc/software/regina/rexxrule.html#p02h24|title=Rexx के लिए अंगूठे के छह नियम}}</ref> एक मिश्रित चर में एक तना होता है जिसके बाद एक पूंछ होती है। ए । (डॉट) का उपयोग stem को पूंछ से जोड़ने के लिए किया जाता है। यदि उपयोग की जाने वाली पूंछ संख्यात्मक हैं, तो सरणी के समान प्रभाव उत्पन्न करना आसान है।


<वाक्यविन्यास हाइलाइट लैंग = रेक्स शैली = पृष्ठभूमि-रंग: #ffffff; महत्वपूर्ण>
<syntax-highlight lang=rex style=background-color: #ffffff; important>
  क्या मैं = 1 से 10
  do i = 1 to 10                                                                                         stem.i = 10 - i
स्टेम.आई = 10 - आई
  end
  समाप्त
</syntax highlight>
</वाक्यविन्यास हाइलाइट>


बाद में निम्न मान वाले निम्न चर <code>stem.1 = 9, stem.2 = 8, stem.3 = 7</code>... उपस्थित हैं:
बाद में निम्न मान वाले निम्न चर <code>stem.1 = 9, stem.2 = 8, stem.3 = 7</code>... उपस्थित हैं:
Line 256: Line 242:
सरणियों के विपरीत, स्टेम चर के सूचकांक के लिए पूर्णांक मान होना आवश्यक नहीं है। उदाहरण के लिए, निम्न कोड मान्य है:
सरणियों के विपरीत, स्टेम चर के सूचकांक के लिए पूर्णांक मान होना आवश्यक नहीं है। उदाहरण के लिए, निम्न कोड मान्य है:


<वाक्यविन्यास लैंग = रेक्स>
<syntax lang=rex>
  मैं = 'सोमवार'
  i = 'Monday'                                                                                           stem.i = 2  
स्टेम.आई = 2
</syntax highlight>
</वाक्यविन्यास हाइलाइट>


रेक्स में स्टेम के लिए डिफ़ॉल्ट मान सेट करना भी संभव है।
रेक्स में स्टेम के लिए डिफ़ॉल्ट मान सेट करना भी संभव है।


<वाक्यविन्यास लैंग = रेक्स>
<syntax lang=rex>
  तना। = 'अज्ञात'
  stem. = 'Unknown'                                                                                       stem.1 = 'USA'
स्टेम.1 = 'यूएसए'
  stem.44 = 'UK'
स्टेम.44 = 'यूके'
  stem.33 = 'France'
स्टेम.33 = 'फ्रांस'
</syntax highlight>
</वाक्यविन्यास हाइलाइट>


इन कार्यों के बाद कार्यकाल <code>stem.3</code> उत्पादन करेगा <code>'Unknown'</code>.
इन कार्यों के बाद कार्यकाल <code>stem.3</code> उत्पादन करेगा <code>'Unknown'</code>.


DROP स्टेटमेंट से पूरे तने को भी मिटाया जा सकता है।
DROP स्टेटमेंट से पूरे stem को भी मिटाया जा सकता है।


<वाक्यविन्यास लैंग = रेक्स>
<syntax lang=rex>
  ड्रॉप तना।
  drop stem.
</वाक्यविन्यास हाइलाइट>
</syntax highlight>


यह पहले से सेट किए गए किसी भी डिफ़ॉल्ट मान को हटाने का प्रभाव भी रखता है।
यह पहले से सेट किए गए किसी भी डिफ़ॉल्ट मान को हटाने का प्रभाव भी रखता है।


परिपाटी के अनुसार (और भाषा के हिस्से के रूप में नहीं) यौगिक <code>stem.0</code> का उपयोग अधिकांश एक स्टेम में कितने आइटम हैं इसका ट्रैक रखने के लिए प्रयोग किया जाता है, उदाहरण के लिए सूची में एक शब्द जोड़ने की प्रक्रिया को इस तरह कोडित किया जा सकता है:
परिपाटी के अनुसार (और भाषा के हिस्से के रूप में नहीं) यौगिक <code>stem.0</code> का उपयोग अधिकांश एक स्टेम में किstem आइटम हैं इसका ट्रैक रखने के लिए प्रयोग किया जाता है, उदाहरण के लिए सूची में एक शब्द जोड़ने की प्रक्रिया को इस तरह कोडित किया जा सकता है:


<वाक्यविन्यास लैंग = रेक्स>
<syntax lang=rex>
  add_word: प्रक्रिया शब्दकोश को उजागर करती है।
  add_word: procedure expose dictionary.                                                                  parse arg w
पार्स आर्ग डब्ल्यू
  n = dictionary.0 + 1
  एन = शब्दकोश.0 + 1
  dictionary.n = w
  डिक्शनरी.एन = डब्ल्यू
  dictionary.0 = n
  शब्दकोश.0 = एन
  return
  वापसी
</syntax highlight>
</वाक्यविन्यास हाइलाइट>


मिश्रित चर के पुच्छ में अनेक तत्वों का होना भी संभव है। उदाहरण के लिए:
मिश्रित चर के पुच्छ में अनेक तत्वों का होना भी संभव है। उदाहरण के लिए:


<वाक्यविन्यास लैंग = रेक्स>
<syntax lang=rex>
  एम = 'जुलाई'
  m = 'July'                                                                                                 d = 15
डी = 15
  y = 2005
  वाई = 2005
  day.y.m.d = 'Friday'
  day.y.m.d = 'शुक्रवार'
</syntax highlight>
</वाक्यविन्यास हाइलाइट>


बहु-आयामी सरणी के प्रभाव को प्रदान करने के लिए एकाधिक संख्यात्मक पूंछ तत्वों का उपयोग किया जा सकता है।
बहु-आयामी सरणी के प्रभाव को प्रदान करने के लिए एकाधिक संख्यात्मक पूंछ तत्वों का उपयोग किया जा सकता है।
Line 304: Line 286:
रेक्स यौगिक चर के समान सुविधाएँ कई अन्य भाषाओं में पाई जाती हैं (AWK प्रोग्रामिंग भाषा में साहचर्य सरणियों सहित, पर्ल में [[हैश टेबल]] और जावा (प्रोग्रामिंग भाषा) में हैशटेबल्स)। इनमें से अधिकतर भाषाएं इस तरह के निर्माण के सभी चाबियों (या रेक्स शर्तों में पूंछ) पर पुनरावृति करने के लिए एक निर्देश प्रदान करती हैं, लेकिन पारंपरिक रेक्स में इसकी कमी है। इसके अतिरिक्त पूंछ मूल्यों की सहायक सूचियों को उपयुक्त रखना आवश्यक है। उदाहरण के लिए, किसी प्रोग्राम में शब्दों की गिनती करने के लिए किसी शब्द की प्रत्येक घटना को रिकॉर्ड करने के लिए निम्नलिखित प्रक्रिया का उपयोग किया जा सकता है।
रेक्स यौगिक चर के समान सुविधाएँ कई अन्य भाषाओं में पाई जाती हैं (AWK प्रोग्रामिंग भाषा में साहचर्य सरणियों सहित, पर्ल में [[हैश टेबल]] और जावा (प्रोग्रामिंग भाषा) में हैशटेबल्स)। इनमें से अधिकतर भाषाएं इस तरह के निर्माण के सभी चाबियों (या रेक्स शर्तों में पूंछ) पर पुनरावृति करने के लिए एक निर्देश प्रदान करती हैं, लेकिन पारंपरिक रेक्स में इसकी कमी है। इसके अतिरिक्त पूंछ मूल्यों की सहायक सूचियों को उपयुक्त रखना आवश्यक है। उदाहरण के लिए, किसी प्रोग्राम में शब्दों की गिनती करने के लिए किसी शब्द की प्रत्येक घटना को रिकॉर्ड करने के लिए निम्नलिखित प्रक्रिया का उपयोग किया जा सकता है।


<वाक्यविन्यास हाइलाइट लैंग = रेक्स शैली = पृष्ठभूमि-रंग: #ffffff; महत्वपूर्ण>
<syntax-highlight lang=rex style=background-color: #ffffff; important>
add_word: प्रक्रिया एक्सपोज़ गिनती। शब्द सूची
  add_word: procedure expose count. word_list
पार्स आर्ग डब्ल्यू।
  parse arg w .
काउंट.डब्ल्यू = काउंट.डब्ल्यू + 1 /* काउंट मान लें। 0 */ पर सेट किया गया है
  count.w = count.w + 1 /* assume count. has been set to 0 */
यदि गिनती.w = 1 तो word_list = word_list w
  if count.w = 1 then word_list = word_list w
  वापसी
  return
</वाक्यविन्यास हाइलाइट>
</syntax highlight>


और फिर बाद में:
और फिर बाद में:


<वाक्यविन्यास हाइलाइट लैंग = रेक्स शैली = पृष्ठभूमि-रंग: #ffffff; महत्वपूर्ण>
<syntax-highlight lang=rex style=background-color: #ffffff; important>
  क्या मैं = 1 शब्दों के लिए (word_list)
  do i = 1 to words(word_list)
डब्ल्यू = शब्द (शब्द_सूची, मैं)
  w = word(word_list,i)
डब्ल्यू काउंट डब्ल्यू कहें
  say w count.w
  समाप्त
  end
</वाक्यविन्यास हाइलाइट>
</syntax highlight>


कुछ स्पष्टता की कीमत पर इन तकनीकों को एक ही तने में संयोजित करना संभव है:
कुछ स्पष्टता की मूल्य पर इन तकनीकों को एक ही stem में संयोजित करना संभव है:


<वाक्यविन्यास हाइलाइट लैंग = रेक्स शैली = पृष्ठभूमि-रंग: #ffffff; महत्वपूर्ण>
<syntax-highlight lang=rex style=background-color: #ffffff; important>
  add_word: प्रक्रिया शब्दकोश को उजागर करती है।
  add_word: procedure expose dictionary.
पार्स आर्ग डब्ल्यू।
  parse arg w .
डिक्शनरी.डब्ल्यू = डिक्शनरी.डब्ल्यू + 1
  dictionary.w = dictionary.w + 1
यदि Dictionary.w = 1 /* डिक्शनरी मान लें। = 0 */
  if dictionary.w = 1 /* assume dictionary. = 0 */
फिर करो
  then do
एन = शब्दकोश.0 + 1
  n = dictionary.0+1
डिक्शनरी.एन = डब्ल्यू
  dictionary.n = w
शब्दकोश.0 = एन
  dictionary.0 = n
समाप्त
  end
  वापसी
  return
</वाक्यविन्यास हाइलाइट>
</syntax highlight>


और बाद में:
और बाद में:


<वाक्यविन्यास हाइलाइट लैंग = रेक्स शैली = पृष्ठभूमि-रंग: #ffffff; महत्वपूर्ण>
<syntax-highlight lang=rex style=background-color: #ffffff; important>
  do i = 1 to dictionary.0
  do i = 1 to dictionary.0
डब्ल्यू = डिक्शनरी.आई
  w = dictionary.i
कहो मैं w dictionary.w
  say i w dictionary.w
  समाप्त
  end
</वाक्यविन्यास हाइलाइट>
</syntax highlight>


रेक्स यहां कोई सुरक्षा जाल प्रदान नहीं करता है, इसलिए यदि कोई एक शब्द <code>dictionary.0</code> से कम होता है  यह तकनीक रहस्यपूर्ण रूप से विफल हो जाएगी।
रेक्स यहां कोई सुरक्षा जाल प्रदान नहीं करता है, इसलिए यदि कोई एक शब्द <code>dictionary.0</code> से कम होता है  यह तकनीक रहस्यपूर्ण रूप से विफल हो जाएगी।
Line 349: Line 331:
IBM के ऑब्जेक्ट रेक्स सहित रेक्स के हाल के कार्यान्वयन और oorexx जैसे ओपन सोर्स कार्यान्वयन में स्टेम के मान पर पुनरावृत्ति को सरल बनाने के लिए एक नई भाषा का निर्माण सम्मिलित है, या किसी अन्य संग्रह वस्तु जैसे कि सरणी, तालिका या सूची पर।
IBM के ऑब्जेक्ट रेक्स सहित रेक्स के हाल के कार्यान्वयन और oorexx जैसे ओपन सोर्स कार्यान्वयन में स्टेम के मान पर पुनरावृत्ति को सरल बनाने के लिए एक नई भाषा का निर्माण सम्मिलित है, या किसी अन्य संग्रह वस्तु जैसे कि सरणी, तालिका या सूची पर।


<वाक्यविन्यास हाइलाइट लैंग = ooरेक्स शैली = पृष्ठभूमि-रंग: #ffffff; महत्वपूर्ण>
<syntax-highlight lang=rex style=background-color: #ffffff; important>
  क्या मैं तने के ऊपर हूं।
  do i over stem.
  कहो मैं '-->' स्टेम.आई
  say i '-->' stem.i
  समाप्त
  end
</वाक्यविन्यास हाइलाइट>
</syntax highlight>


=== कीवर्ड निर्देश ===
=== कीवर्ड निर्देश ===


==== पार्स ==== <code>PARSE</code> ई> निर्देश विशेष रूप से शक्तिशाली है; यह कुछ उपयोगी स्ट्रिंग-हैंडलिंग फ़ंक्शंस को जोड़ती है। इसका सिंटैक्स है:
<nowiki>==== पार्स ====</nowiki>
 
<code>PARSE</code> E> निर्देश विशेष रूप से शक्तिशाली है; यह कुछ उपयोगी स्ट्रिंग-हैंडलिंग फ़ंक्शंस को जोड़ती है। इसका सिंटैक्स है:


<वाक्यविन्यास लैंग = रेक्स>
<syntax lang=rex>
  पार्स [ऊपरी] मूल [टेम्पलेट]
  parse [upper] origin [template]
</वाक्यविन्यास हाइलाइट>
</syntax highlight>


जहां मूल स्रोत निर्दिष्ट करता है:
जहां मूल स्रोत निर्दिष्ट करता है:
Line 385: Line 369:
टेम्पलेट के रूप में चरों की सूची का उपयोग करना
टेम्पलेट के रूप में चरों की सूची का उपयोग करना


<वाक्यविन्यास हाइलाइट लैंग = रेक्स शैली = पृष्ठभूमि-रंग: #ffffff; महत्वपूर्ण>
<syntax-highlight lang=rex style=background-color: #ffffff; important>
  myVar = जॉन स्मिथ
  myVar = "John Smith"
  पार्स var myVar firstName lastName
  parse var myVar firstName lastName
  पहला नाम है: पहला नाम
  say "First name is:" firstName
  कहें अंतिम नाम है: lastName
  say "Last name is:" lastName
</वाक्यविन्यास हाइलाइट>
</syntax highlight>


निम्नलिखित प्रदर्शित करता है:
निम्नलिखित प्रदर्शित करता है:


<पूर्व>
<ex>
  पहला नाम है: जॉन
  First name is: John
  अंतिम नाम है: स्मिथ
  Last name is: Smith
</पूर्व>
</ex>


टेम्पलेट के रूप में सीमांकक का उपयोग करना:
टेम्पलेट के रूप में सीमांकक का उपयोग करना:


<वाक्यविन्यास लैंग = रेक्स>
<syntax lang=rex>
  myVar = स्मिथ, जॉन
  myVar = "Smith, John"
  पार्स var myVar LastName , FirstName
  parse var myVar LastName "," FirstName
  पहला नाम है: पहला नाम
  say "First name is:" firstName
  कहें अंतिम नाम है: lastName
  say "Last name is:" lastName  
</वाक्यविन्यास हाइलाइट>
</syntax highlight>


निम्नलिखित भी प्रदर्शित करता है:
निम्नलिखित भी प्रदर्शित करता है:


<पूर्व>
<ex>
पहला नाम है: जॉन
  First name is: John
अंतिम नाम है: स्मिथ
  Last name is: Smith
</पूर्व>
</ex>


स्तंभ संख्या सीमांकक का उपयोग करना:
स्तंभ संख्या सीमांकक का उपयोग करना:


<वाक्यविन्यास लैंग = रेक्स>
<syntax lang=rex>
  मायवर = (202) 123-1234
  myVar = "(202) 123-1234"
  पार्स var MyVar 2 एरियाकोड 5 7 सबनंबर
  parse var MyVar 2 AreaCode 5 7 SubNumber
  कहते हैं एरिया कोड है: एरियाकोड
  say "Area code is:" AreaCode
  कहें सब्सक्राइबर नंबर है: सबनंबर
  say "Subscriber number is:" SubNumber
</वाक्यविन्यास हाइलाइट>
</syntax highlight>


निम्नलिखित प्रदर्शित करता है:
निम्नलिखित प्रदर्शित करता है:


<पूर्व>
<ex>
  क्षेत्र कोड है: 202
  Area code is: 202
  सब्सक्राइबर संख्या है: 123-1234
  Subscriber number is: 123-1234
</पूर्व>
</ex>


एक टेम्पलेट चर, शाब्दिक सीमांकक और स्तंभ संख्या सीमांकक के संयोजन का उपयोग कर सकता है।
एक टेम्पलेट चर, शाब्दिक सीमांकक और स्तंभ संख्या सीमांकक के संयोजन का उपयोग कर सकता है।
Line 439: Line 423:
INTERPRET के अन्य उपयोग रेक्स's (दशमलव) मनमाने ढंग से सटीक अंकगणित (फ़ज़ी तुलनाओं सहित), प्रोग्रामेटिक टेम्प्लेट, स्टेम्ड एरेज़ और विरल सरणियों के साथ PARSE स्टेटमेंट का उपयोग हैं।{{how|date=January 2021}}
INTERPRET के अन्य उपयोग रेक्स's (दशमलव) मनमाने ढंग से सटीक अंकगणित (फ़ज़ी तुलनाओं सहित), प्रोग्रामेटिक टेम्प्लेट, स्टेम्ड एरेज़ और विरल सरणियों के साथ PARSE स्टेटमेंट का उपयोग हैं।{{how|date=January 2021}}


<वाक्यविन्यास लैंग = रेक्स>
<syntax lang=rex>
  /* वर्ग(4) के साथ व्याख्या प्रदर्शित करें => 16 */
  /* demonstrate INTERPRET with square(4) => 16 */
  एक्स = 'वर्ग'
  X = 'square'
  व्याख्या 'कहो' एक्स || '(4); बाहर निकलना'
  interpret 'say' X || '(4) ; exit'
  स्क्वायर: वापसी तर्क (1) ** 2
  SQUARE: return arg(1)**2
</वाक्यविन्यास हाइलाइट>
</syntax highlight>


यह 16 प्रदर्शित करता है और बाहर निकलता है। क्योंकि रेक्स में चर सामग्री स्ट्रिंग्स हैं, जिसमें एक्सपोनेंट और यहां तक ​​​​कि पूरे प्रोग्राम के साथ परिमेय संख्याएं सम्मिलित हैं, रेक्स स्ट्रिंग्स को मूल्यांकन किए गए भावों के रूप में व्याख्या करने की प्रस्तुत करता है।
यह 16 प्रदर्शित करता है और बाहर निकलता है। क्योंकि रेक्स में चर सामग्री स्ट्रिंग्स हैं, जिसमें एक्सपोनेंट और यहां तक ​​​​कि पूरे प्रोग्राम के साथ परिमेय संख्याएं सम्मिलित हैं, रेक्स स्ट्रिंग्स को मूल्यांकन किए गए भावों के रूप में व्याख्या करने की प्रस्तुत करता है।
Line 454: Line 438:
बाद के संस्करण (गैर-पारंपरिक) <code>CALL variable</code> निर्माणों का समर्थन करते हैं। साथ में बिल्ट-इन फ़ंक्शन <code>VALUE</code>, CALL के कई स्थितियों के स्थान पर उपयोग किया जा सकता है <code>INTERPRET</code>. यह एक पारंपरिक प्रोग्राम है:
बाद के संस्करण (गैर-पारंपरिक) <code>CALL variable</code> निर्माणों का समर्थन करते हैं। साथ में बिल्ट-इन फ़ंक्शन <code>VALUE</code>, CALL के कई स्थितियों के स्थान पर उपयोग किया जा सकता है <code>INTERPRET</code>. यह एक पारंपरिक प्रोग्राम है:


<वाक्यविन्यास हाइलाइट लैंग = रेक्स शैली = पृष्ठभूमि-रंग: #ffffff; महत्वपूर्ण>
<syntax-highlight lang=rex style=background-color: #ffffff; important>
  / * इनपुट निकास या इसी तरह से समाप्त * /
  /* terminated by input "exit" or similar */
  हमेशा के लिए करो; लाइनिन की व्याख्या करें (); समाप्त
  do forever ; interpret linein() ; end
</वाक्यविन्यास हाइलाइट>
</syntax highlight>


थोड़ा और परिष्कृत रेक्स कैलकुलेटर:
थोड़ा और परिष्कृत रेक्स कैलकुलेटर:


<वाक्यविन्यास हाइलाइट लैंग = रेक्स शैली = पृष्ठभूमि-रंग: #ffffff; महत्वपूर्ण>
<syntax-highlight lang=rex style=background-color: #ffffff; important>
एक्स = 'छोड़ने के लिए अलविदा इनपुट'
  X = 'input BYE to quit'
X = 'BYE' तक करें; व्याख्या 'कहो' एक्स; एक्स खींचो; समाप्त
 
</वाक्यविन्यास हाइलाइट>
  do until X = 'BYE' ; interpret 'say' X ; pull X ; end
</syntax highlight>


<code>PULL</code> के लिए आशुलिपि है <code>parse upper pull</code>. वैसे ही, <code>ARG</code> के लिए आशुलिपि है <code>parse upper arg</code>.
<code>PULL</code> के लिए आशुलिपि है <code>parse upper pull</code>. वैसे ही, <code>ARG</code> के लिए आशुलिपि है <code>parse upper arg</code>.
Line 472: Line 457:
==== संख्यात्मक ====
==== संख्यात्मक ====


<वाक्यविन्यास लैंग = रेक्स>
<syntax lang=rex>
  अंक कहें () फ़ज़ () फॉर्म () /* => 9 0 वैज्ञानिक */
  say digits() fuzz() form() /* => 9 0 SCIENTIFIC */
कहें 999999999+1 /* => 1.000000000E+9 */
  say 999999999+1 /* => 1.000000000E+9 */
संख्यात्मक अंक 10 /* केवल उपलब्ध स्मृति द्वारा सीमित */
  numeric digits 10 /* only limited by available memory */
कहें 999999999+1 /* => 1000000000 */
  say 999999999+1 /* => 1000000000 */
 
कहें 0.9999999999=1 /* => 0 (गलत) */
  say 0.9999999999=1 /* => 0 (false) */
संख्यात्मक फ़ज़ 3
  numeric fuzz 3
कहें 0.99999999=1 /* => 1 (सच) */
  say 0.99999999=1 /* => 1 (true) */
कहते हैं 0.99999999==1 /* => 0 (गलत) */
  say 0.99999999==1 /* => 0 (false) */
 
कहें 100*123456789 /* => 1.23456789E+10 */
  say 100*123456789 /* => 1.23456789E+10 */
संख्यात्मक रूप इंजीनियरिंग
  numeric form engineering
कहें 100*123456789 /* => 12.34567890E+9 */
  say 100*123456789 /* => 12.34567890E+9 */
 
कहें 53 // 7 /* => 4 (शेष विभाजन)*/
  say 53 // 7   /* => 4   (rest of division)*/
  </वाक्यविन्यास हाइलाइट>
{| class="wikitable"
|}
   
{|class="wikitable"
{|class="wikitable"
! &nbsp;
! &nbsp;
Line 535: Line 522:
उपयोगकर्ता द्वारा समाप्त किए जाने तक निम्न प्रोग्राम चलेगा:
उपयोगकर्ता द्वारा समाप्त किए जाने तक निम्न प्रोग्राम चलेगा:


<वाक्यविन्यास हाइलाइट लैंग = रेक्स शैली = पृष्ठभूमि-रंग: #ffffff; महत्वपूर्ण>
<syntax-highlight lang=rex style=background-color: #ffffff; important>
  रुकने का संकेत;
  signal on halt;
ए = 1 करो
  do a = 1
ए कहो
say a
100000 /* देरी से करें */
do 100000 /* a delay */
 
end
समाप्त
  end
समाप्त
  halt:
पड़ाव:
  say "The program was stopped by the user"
कार्यक्रम उपयोगकर्ता द्वारा बंद कर दिया गया था
  exit
  बाहर निकलना
</syntax highlight>
</वाक्यविन्यास हाइलाइट>


A <syntaxhighlight lang= REXX inline>signal on novalue</syntaxhighlight> कथन अपरिभाषित चरों के उपयोग को रोकता है, जो अन्यथा उनके मूल्य के रूप में अपना (अपर केस) नाम प्राप्त करेंगे। <code>NOVALUE</code> स्थिति की स्थिति के अतिरिक्त, एक चर की स्थिति को परिभाषित चर के लिए अंतर्निहित फ़ंक्शन <code>SYMBOL</code> रिटर्निंग VAR के साथ हमेशा जांचा जा सकता है।  
A <syntaxhighlight lang= REXX inline>signal on novalue</syntaxhighlight> कथन अपरिभाषित चरों के उपयोग को रोकता है, जो अन्यथा उनके मूल्य के रूप में अपना (अपर केस) नाम प्राप्त करेंगे। <code>NOVALUE</code> स्थिति की स्थिति के अतिरिक्त, एक चर की स्थिति को परिभाषित चर के लिए अंतर्निहित फ़ंक्शन <code>SYMBOL</code> रिटर्निंग VAR के साथ हमेशा जांचा जा सकता है।  
Line 573: Line 559:
रेक्स संस्करण 4 के साथ प्रारंभ होने वाली स्थितियों को नाम मिल सकते हैं, और एक <code>CALL ON</code> निर्माण भी है। यदि बाहरी कार्य आवश्यक रूप से उपस्थित नहीं हैं तो यह आसान है:
रेक्स संस्करण 4 के साथ प्रारंभ होने वाली स्थितियों को नाम मिल सकते हैं, और एक <code>CALL ON</code> निर्माण भी है। यदि बाहरी कार्य आवश्यक रूप से उपस्थित नहीं हैं तो यह आसान है:


<वाक्यविन्यास लैंग = रेक्स>
<syntax lang=rex>
ChangeCodePage: कार्यविधि /* SIGNAL सेटिंग सुरक्षित करें */
  ChangeCodePage: procedure /* protect SIGNAL settings */
सिंटैक्स नाम ChangeCodePage.Trap पर संकेत
  signal on syntax name ChangeCodePage.Trap
वापसी SysQueryProcessCodePage ()
  return SysQueryProcessCodePage()
  ChangeCodePage.Trap: OS/2 पर 1004 /* विंडोज-1252 लौटाएं */
  ChangeCodePage.Trap: return 1004 /* windows-1252 on OS/2 */
</वाक्यविन्यास हाइलाइट>
</syntax highlight>


== यह भी देखें ==
== यह भी देखें ==

Revision as of 15:42, 10 January 2023

रेक्स
File:Rexx-img-lg.png
Paradigmmultiparadigm: procedural, structured
द्वारा डिज़ाइन किया गयाMike Cowlishaw
DeveloperMike Cowlishaw, IBM
पहली प्रस्तुति1979; 45 years ago (1979)
Stable release
ANSI X3.274 / 1996; 28 years ago (1996)
टाइपिंग अनुशासनDynamic
फ़ाइल नाम एक्सटेंशनएस.cmd, .bat, .exec, .rexx, .rex, EXEC
Major implementations
VM/SP R3, TSO/E V2, SAAREXX, ARexx, BREXX, Regina,[1] Personal REXX, REXX/imc
Dialects
NetRexx, Object REXX, now ooREXX, KEXX
Influenced by
PL/I, ALGOL, EXEC, EXEC 2
Influenced
NetRexx, Object REXX

रेक्स (पुनर्गठित विस्तारित निष्पादक) एक प्रोग्रामिंग भाषा है जिसे व्याख्या (कंप्यूटिंग) या संकलित किया जा सकता है। यह आईबीएम में माइक काउलिशॉ द्वारा विकसित किया गया था।[2][3] यह एक संरचित, उच्च स्तरीय प्रोग्रामिंग भाषा है जिसे सीखने और पढ़ने में आसानी के लिए डिज़ाइन किया गया है। कंप्यूटिंग प्लेटफॉर्म की एक विस्तृत श्रृंखला के लिए मालिकाना और खुला स्रोत सॉफ्टवेयर रेक्स दुभाषिया (कंप्यूटिंग) उपस्थित है; आईबीएम मेनफ़्रेम संगणक के लिए संकलनकर्ता उपस्थित हैं।[4]

रेक्स एक पूर्ण भाषा है जिसका उपयोग स्क्रिप्टिंग भाषा, मैक्रो (संगणक विज्ञान) भाषा और अनुप्रयोग विकास भाषा के रूप में किया जा सकता है। इसका उपयोग अधिकांश डेटा और पाठ को संसाधित करने और रिपोर्ट तैयार करने के लिए किया जाता है; पर्ल के साथ इन समानताओं का अर्थ है कि रेक्स कॉमन गेटवे इंटरफ़ेस (सीजीआई) प्रोग्रामिंग में अच्छा काम करता है और यह वास्तविक में इस उद्देश्य के लिए उपयोग किया जाता है। कुछ ऑपरेटिंग सिस्टम में रेक्स प्राथमिक स्क्रिप्टिंग भाषा है, उदा। OS/2, MVS, VM (ऑपरेटिंग सिस्टम), AmigaOS, और SPF/PC, XEDIT, THE और ZOC (सॉफ़्टवेयर) टर्मिनल एमुलेटर जैसे कुछ अन्य सॉफ़्टवेयर में आंतरिक मैक्रो भाषा के रूप में भी उपयोग किया जाता है। इसके अतिरिक्त, रेक्स भाषा का उपयोग किसी भी प्रोग्राम में स्क्रिप्टिंग और मैक्रोज़ के लिए किया जा सकता है जो विंडोज स्क्रिप्टिंग होस्ट ActiveX भाषा का अंकन भाषाओं (जैसे VBScript और JScript) का उपयोग करता है यदि रेक्स इंजनों में से एक स्थापित है।

रेक्स को VM/SP रिलीज 3 ऑन अप, TSO/E संस्करण 2 ऑन अप, OS/2 (1.3 और बाद में, जहां इसे आधिकारिक रूप से प्रोसीजर्स भाषा/2 नाम दिया गया है), AmigaOS संस्करण 2 ऑन अप, PC DOS (7.0 या 2000) ArcaOS और विंडोज NT 4.0 (संसाधन किट: रेजिना) के साथ आपूर्ति की जाती है।[5] CMS के लिए रेक्स स्क्रिप्ट फ़ाइल प्रकार EXEC को EXEC और EXEC2 के साथ साझा करती है, और स्क्रिप्ट की पहली पंक्ति उपयोग किए जाने वाले दुभाषिया को निर्दिष्ट करती है। MVS के लिए रेक्स स्क्रिप्ट्स हो सकती हैं[lower-alpha 1] निम्न स्तर के क्वालीफायर EXEC द्वारा पहचाना जा सकता है या हो सकता है[lower-alpha 2] संदर्भ और पहली पंक्ति से पहचाना जाना चाहिए। OS/2 के लिए रेक्स स्क्रिप्ट फ़ाइल नाम एक्सटेंशन .cmd को अन्य स्क्रिप्टिंग भाषाओं के साथ साझा करती है, और स्क्रिप्ट की पहली पंक्ति उपयोग किए जाने वाले दुभाषिया को निर्दिष्ट करती है। रेक्स-जागरूक अनुप्रयोगों के लिए रेक्स मैक्रोज़ एप्लिकेशन द्वारा निर्धारित एक्सटेंशन का उपयोग करते हैं। 1980 के दशक के उत्तरार्ध में, रेक्स आईबीएम सिस्टम एप्लीकेशन आर्किटेक्चर के लिए सामान्य स्क्रिप्टिंग भाषा बन गई, जहाँ इसका नाम परिवर्तितकर SAA प्रोसीजर भाषा रेक्स कर दिया गया है।

एक रेक्स स्क्रिप्ट या कमांड को कभी-कभी EXEC, EXEC 2[6] और CP/CMS पर रेक्स स्क्रिप्ट और z/VM के माध्यम से VM/370 के लिए उपयोग किए जाने वाले CMS फ़ाइल प्रकार के लिए एक नोड के रूप में संदर्भित किया जाता है।[7]

सुविधाएँ

रेक्स में निम्नलिखित अभिलक्षण और विशेषताएं हैं:

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

रेक्स में न्यूनतम विराम चिह्न और स्वरूपण आवश्यकताओं के साथ सिर्फ तेईस, सामान्यतः स्व-स्पष्ट, निर्देश (जैसे call, parse, तथा select) हैं। यह अनिवार्य रूप से केवल एक डेटा-प्रकार, वर्ण स्ट्रिंग के साथ एक लगभग स्वतंत्र रूप वाली भाषा है; इस दर्शन का अर्थ है कि सभी डेटा दृश्यमान (प्रतीकात्मक) हैं और डिबगिंग और ट्रेसिंग सरल हैं।

रेक्स का सिंटैक्स PL/I के समान दिखता है, लेकिन इसमें कम संकेत हैं; इससे (कार्यक्रम द्वारा) पार्स करना कठिन हो जाता है, लेकिन उन स्थितियों को छोड़कर उपयोग करना आसान हो जाता है, जहां पीएल/आई की आदतें आश्चर्य का कारण बन सकती हैं। रेक्स डिजाइन लक्ष्यों में से एक कम से कम विस्मय का सिद्धांत था।[8]


इतिहास

1990 से पहले

रेक्स को 20 मार्च 1979 और 1982 के मध्य आईबीएम के माइक कोविलिशॉ द्वारा 'स्वयं-समय' परियोजना के रूप में असेंबली भाषा में डिजाइन और कार्यान्वित किया गया था, मूल रूप से EXEC और EXEC 2 भाषाओं को बदलने के लिए एक स्क्रिप्टिंग प्रोग्रामिंग भाषा के रूप में।[2] इसे किसी भी सिस्टम के लिए मैक्रो (संगणक साइंस) या स्क्रिप्टिंग भाषा के रूप में डिजाइन किया गया था। जैसे, रेक्स को Tcl और Python (प्रोग्रामिंग भाषा) का अग्रदूत माना जाता है। रेक्स का उद्देश्य इसके निर्माता द्वारा पायथन (प्रोग्रामिंग भाषा) का एक सरलीकृत और सीखने में आसान संस्करण होना भी था। चूँकि, PL/I से कुछ अस्वीकृति अज्ञानता में हो सकते हैं।

इसे पहली बार 1981 में ह्यूस्टन, टेक्सास में शेयर 56 सम्मेलन में सार्वजनिक रूप से वर्णित किया गया था।[9] जहां ग्राहकों की प्रतिक्रिया, एसएलएसी राष्ट्रीय त्वरक प्रयोगशाला के टेड जॉनस्टन द्वारा समर्थित, इसे 1982 में आईबीएम उत्पाद के रूप में भेज दिया गया।

इन वर्षों में आईबीएम ने अपने लगभग सभी ऑपरेटिंग सिस्टम (वीएम/सीएमएस, एमवीएस टीएसओ/ई, आईबीएम आई, वीएसई/ईएसए, आईबीएम एआईएक्स, पीसी डॉस, और OS/2) में रेक्स को भी सम्मिलित किया गया है। और नोवेल नेटवेयर, माइक्रोसॉफ़्ट विंडोज़, जावा (प्रोग्रामिंग भाषा) और लिनक्स के लिए संस्करण उपलब्ध कराया है।

पहला गैर-आईबीएम संस्करण 1984/5 में चार्ल्स डेनी द्वारा पीसी डॉस के लिए लिखा गया था[3] और मैन्सफील्ड सॉफ्टवेयर ग्रुप (1986 में केविन जे. केर्नी द्वारा स्थापित) द्वारा विपणन किया गया।[2] 1987 में लुंडिन और वुड्रूफ़ द्वारा सीएमएस के लिए लिखा गया पहला संकलक संस्करण सामने आया।[10] अटारी, अमिगाओएस, यूनिक्स (कई संस्करण), सोलारिस (ऑपरेटिंग सिस्टम), डिजिटल उपकरण निगम, माइक्रोसॉफ्ट विंडोज, विंडोज सीई, जेब में रखने लायक संगणक, डॉस, पाम ओएस, क्यूएनएक्स, ओएस/2, लिनक्स, BeOS के लिए, EPOC32/सिम्बियन, AtheOS, OpenVMS,[11]: p.305  एप्पल मैकिनटोश, और Mac OS X अन्य संस्करण भी विकसित किए गए हैं।[12]

रेक्स का अमिगा संस्करण, जिसे ARxx कहा जाता है, को AmigaOS 2 के साथ सम्मिलित किया गया था और यह स्क्रिप्टिंग के साथ-साथ एप्लिकेशन नियंत्रण के लिए लोकप्रिय था। कई Amiga अनुप्रयोगों में एक अरेक्स पोर्ट बनाया गया है जो रेक्स से एप्लिकेशन को नियंत्रित करने की अनुमति देता है। कई चल रहे अनुप्रयोगों को नियंत्रित करने के लिए एक एकल रेक्स स्क्रिप्ट विभिन्न रेक्स पोर्ट्स के बीच भी स्विच कर सकती है।

1990 से वर्तमान

1990 में, SLAC की कैथी डैगर ने पहली स्वतंत्र रेक्स संगोष्ठी का आयोजन किया, जिसके कारण रेक्स भाषा एसोसिएशन का गठन हुआ। संगोष्ठी प्रतिवर्ष आयोजित की जाती हैं।

रेक्स के कई फ्रीवेयर संस्करण उपलब्ध हैं। 1992 में, दो सबसे व्यापक रूप से उपयोग किए जाने वाले ओपन-सोर्स पोर्ट सामने आए:: यूनिक्स के लिए इयान कोलियर का REXX/imc और विंडोज और यूनिक्स के लिए एंडर्स क्रिस्टेंसन का रेजिना[1](बाद में मार्क हेस्लिंग द्वारा अपनाया गया)। बिरेक्स WinCE और पॉकेट पीसी प्लेटफॉर्म के लिए अच्छी तरह से जाना जाता है, और इसे VM/370 और MVS में बैक-पोर्ट किया गया है।

OS/2 में Watcom VX-रेक्स का दृश्य विकास प्रणाली है। हॉकवेयर की एक अन्य बोली विज़प्रो रेक्स थी।

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

  • Netरेक्स: जावा स्रोत कोड के माध्यम से जावा (प्रोग्रामिंग भाषा) बाइट कोड को संकलित करता है; इसमें कोई भी आरक्षित कीवर्ड नहीं है, और जावा ऑब्जेक्ट मॉडल का उपयोग करता है, और इसलिए सामान्यतः 'पारंपरिक' रेक्स के साथ ऊपर-संगत नहीं होता है।
  • ऑब्जेक्ट रेक्स: रेक्स का एक वस्तु के उन्मुख सामान्यतः ऊपर की ओर-संगत संस्करण।

1996 में अमेरिकन राष्ट्रीय मानक संस्थान (एएनएसआई) ने रेक्स के लिए एक मानक: ANSI X3.274–1996 सूचना प्रौद्योगिकी - प्रोग्रामिंग भाषा रेक्स प्रकाशित किया।[13] 1985 से रेक्स पर दो दर्जन से अधिक पुस्तकें प्रकाशित हो चुकी हैं।

रेक्स ने 20 मार्च 2004 को अपनी 25वीं वर्षगांठ मनाई, जिसे मई 2004 में जर्मनी के बॉबलिंगेन में रेक्स भाषा एसोसिएशन के 15वें अंतर्राष्ट्रीय रेक्स संगोष्ठी में मनाया गया।

12 अक्टूबर 2004 को, आईबीएम ने सामान्य सार्वजनिक लाइसेंस के अनुसार अपने ऑब्जेक्ट रेक्स कार्यान्वयन के स्रोतों को जारी करने की अपनी योजना की घोषणा की। ऑब्जेक्ट रेक्स के हाल के रिलीज़ में रेक्स भाषा के इस संस्करण को लागू करने वाला ActiveX विंडोज विंडोज स्क्रिप्टिंग होस्टWSH) स्क्रिप्टिंग इंजन सम्मिलित है।

22 फरवरी, 2005 को ओपन ऑब्जेक्ट रेक्स (ooRexx) की पहली सार्वजनिक रिलीज की घोषणा की गई। इस उत्पाद में एक WSH स्क्रिप्टिंग इंजन है जो विंडोज ऑपरेटिंग सिस्टम और रेक्स के साथ एप्लिकेशन को उसी तरह से प्रोग्रामिंग करने की अनुमति देता है जिसमें विसुअल बेसिक और जेस्क्रिप्ट को डिफ़ॉल्ट WSH इंस्टॉलेशन और पर्ल, Tcl, Python (प्रोग्रामिंग भाषा) थर्ड-पार्टी स्क्रिप्टिंग इंजन द्वारा लागू किया जाता है।

As of January 2017 तक रेक्स को TIOBE इंडेक्स में शीर्ष 100 में सम्मिलित 50 भाषाओं में से एक के रूप में सूचीबद्ध किया गया था जो शीर्ष 50 से संबंधित नहीं थी।[14]

2019 में, 30वीं रेक्स भाषा एसोसिएशन सिम्पोजियम ने रेक्स की 40वीं वर्षगांठ मनाई। संगोष्ठी हर्सले, इंग्लैंड में आयोजित की गई थी, जहां रेक्स को पहली बार डिजाइन और कार्यान्वित किया गया था।[15]


टूलकिट

Rexx/Tk, ग्राफिक्स के लिए एक टूलकिट है जिसका उपयोग रेक्स प्रोग्राम्स में Tcl/Tk के रूप में व्यापक रूप से उपलब्ध है।

विंडोज के लिए एक रेक्स IDE, RxxxEd विकसित किया गया है।[11] नेटवर्क संचार के साथ-साथ रेजिना रेक्स के अन्य ऐड-ऑन और कार्यान्वयन के लिए RxSock विकसित किया गया है, और विंडोज कमांड लाइन के लिए एक रेक्स दुभाषिया विंडोज के विभिन्न संस्करणों के लिए अधिकांश संसाधन किटों में आपूर्ति की जाती है और उन सभी के साथ-साथ डॉस के अनुसार काम करता है।

वर्तनी और पूंजीकरण

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


सिंटेक्स

लूपिंग

रेक्स में लूप नियंत्रण संरचना DO से प्रारंभ होता है और END के साथ समाप्त होता है लेकिन कई किस्मों में आता है। नेटरेक्स लूपिंग के लिये DO के अतिरिक्त कीवर्ड LOOP का उपयोग करता है जबकि ooRexx लूप करते समय LOOP तथा DO को समतुल्य मानता है।

सशर्त लूप

रेक्स कई प्रकार के पारंपरिक संरचित-प्रोग्रामिंग लूप का समर्थन करता है, जबकि किसी स्थिति का परीक्षण करने से पहले (do while) या बाद में (do until) निर्देशों की सूची निष्पादित हो जाती है: 

do while [condition]                                                                                      [instructions]
end
do until [condition]
[instructions]
end

दोहराए जाने वाले लूप्स

अधिकांश भाषाओं की तरह, रेक्स एक इंडेक्स वेरिएबल को बढ़ाते समय लूप कर सकता है और एक सीमा तक पहुंचने पर रुक सकता है: 

do index = start [to limit] [by increment] [for count]                                                 [instructions]
end

वेतन वृद्धि को छोड़ा जा सकता है और 1 के लिए डिफॉल्ट किया जा सकता है। सीमा को भी छोड़ा जा सकता है, जिससे लूप हमेशा के लिए जारी रहता है।

रेक्स गिने हुए लूप की अनुमति देता है, जहां लूप की प्रारंभ में एक एक्सप्रेशन की गणना की जाती है और लूप के भीतर के निर्देशों को कई बार निष्पादित किया जाता है:

<syntax-highlight lang=rex style=background-color: #ffffff; important> 

do expression                                                                                 [instructions]
 end


</syntax highlight>

कार्यक्रम समाप्त होने तक रेक्स भी लूप कर सकता है:

<syntax-highlight lang=rex style=background-color: #ffffff; important> 

do forever                                                                                              [instructions]
end

</syntax highlight>

leave निर्देश के साथ एक प्रोग्राम वर्तमान लूप से बाहर निकल सकता है, जो do forever लूप से बाहर निकलने का सामान्य विधि है, या iterate निर्देश के साथ शॉर्ट-सर्किट कर सकता है।

संयुक्त लूप्स

PL/I की तरह, रेक्स सशर्त और दोहराए जाने वाले दोनों तत्वों को एक ही लूप में संयोजित करने की अनुमति देता है:[16]

<syntax-highlight lang=rex style=background-color: #ffffff; important> 

do index = start [to limit] [by increment] [for count] [while condition]                        [instructions]
end

</syntax highlight>

<syntax-highlight lang=rex style=background-color: #ffffff; important> 

do expression [until condition]                                                                  [instructions]
end

</syntax highlight>

सशर्त

IFके साथ परीक्षण की स्थिति:

<syntax-highlight lang=rex style=background-color: #ffffff; important> 

if [condition] then                                                                                             do
[instructions]
end
else
do
[instructions]
end

</syntax highlight> ELSE ई> खंड वैकल्पिक है।

एकल निर्देशों के लिए, DO तथा END छोड़ा भी जा सकता है:

<syntax-highlight lang=rex style=background-color: #ffffff; important> 

if [condition] then                                                                                       [instruction]
 else
 [instruction]

</syntax highlight>

इंडेंटेशन वैकल्पिक है, लेकिन यह पठनीयता में सुधार करने में सहायता करता है।

कई स्थितियों के लिए परीक्षण

SELECT रेक्स का स्विच स्टेटमेंट है, जैसे PL/I से प्राप्त कई अन्य निर्माण। अन्य गतिशील भाषाओं में CASE निर्माण के कुछ कार्यान्वयनों की तरह, Rexx का WHEN क्लॉज़ पूरी शर्तों को निर्दिष्ट करता है, जिनका एक दूसरे से संबंधित होने की आवश्यकता नहीं है। उसमें, वे C या Java switch स्टेटमेंट की तुलना में IF-THEN-ELSEIF-THEN-...-ELSE कोड के कैस्केड सेट की तरह अधिक हैं।

<syntax-highlight lang=rex style=background-color: #ffffff; important> 

select                                                                                           when[condition] then
 [instruction] or NOP
 when [condition] then
 do
 [instructions] or NOP
 end
 otherwise
 [instructions] or NOP
 end

</syntax highlight> NOP e> निर्देश कोई ऑपरेशन नहीं करता है, और इसका उपयोग तब किया जाता है जब प्रोग्रामर कुछ भी नहीं करना चाहता है जहां एक या अधिक निर्देशों की आवश्यकता होती है।

अन्यथा खंड वैकल्पिक है। यदि छोड़ दिया जाता है और कोई WHEN शर्तें पूरी नहीं होती हैं, तो SYNTAX की स्थिति बढ़ जाती है।

सरल चर

रेक्स में वेरिएबल्स टाइपलेस हैं, और प्रारंभ में अपर केस में उनके नाम के रूप में मूल्यांकन किया जाता है। इस प्रकार कार्यक्रम में इसके उपयोग के साथ एक चर का प्रकार भिन्न हो सकता है:

<syntax lang=rex> 

say hello /* => HELLO */                                                                                  hello = 25
 say hello /* => 25 */
 hello = "say 5 + 3"
 say hello /* => say 5 + 3 */
 interpret hello /* => 8 */
 drop hello
 say hello /* => HELLO */

</syntax highlight>

यौगिक चर

कई अन्य प्रोग्रामिंग भाषाओं के विपरीत, पारंपरिक रेक्स के पास संख्यात्मक सूचकांक द्वारा संबोधित चर के सरणियों के लिए कोई प्रत्यक्ष समर्थन नहीं है। इसके अतिरिक्त यह यौगिक चर प्रदान करता है।[17] एक मिश्रित चर में एक तना होता है जिसके बाद एक पूंछ होती है। ए । (डॉट) का उपयोग stem को पूंछ से जोड़ने के लिए किया जाता है। यदि उपयोग की जाने वाली पूंछ संख्यात्मक हैं, तो सरणी के समान प्रभाव उत्पन्न करना आसान है।

<syntax-highlight lang=rex style=background-color: #ffffff; important> 

do i = 1 to 10                                                                                         stem.i = 10 - i
end

</syntax highlight>

बाद में निम्न मान वाले निम्न चर stem.1 = 9, stem.2 = 8, stem.3 = 7... उपस्थित हैं:

सरणियों के विपरीत, स्टेम चर के सूचकांक के लिए पूर्णांक मान होना आवश्यक नहीं है। उदाहरण के लिए, निम्न कोड मान्य है:

<syntax lang=rex> 

i = 'Monday'                                                                                            stem.i = 2

</syntax highlight>

रेक्स में स्टेम के लिए डिफ़ॉल्ट मान सेट करना भी संभव है।

<syntax lang=rex> 

stem. = 'Unknown'                                                                                       stem.1 = 'USA'
 stem.44 = 'UK'
 stem.33 = 'France'

</syntax highlight>

इन कार्यों के बाद कार्यकाल stem.3 उत्पादन करेगा 'Unknown'.

DROP स्टेटमेंट से पूरे stem को भी मिटाया जा सकता है।

<syntax lang=rex> 

drop stem.

</syntax highlight>

यह पहले से सेट किए गए किसी भी डिफ़ॉल्ट मान को हटाने का प्रभाव भी रखता है।

परिपाटी के अनुसार (और भाषा के हिस्से के रूप में नहीं) यौगिक stem.0 का उपयोग अधिकांश एक स्टेम में किstem आइटम हैं इसका ट्रैक रखने के लिए प्रयोग किया जाता है, उदाहरण के लिए सूची में एक शब्द जोड़ने की प्रक्रिया को इस तरह कोडित किया जा सकता है:

<syntax lang=rex> 

add_word: procedure expose dictionary.                                                                   parse arg w
n = dictionary.0 + 1
dictionary.n = w
dictionary.0 = n
return

</syntax highlight>

मिश्रित चर के पुच्छ में अनेक तत्वों का होना भी संभव है। उदाहरण के लिए:

<syntax lang=rex> 

m = 'July'                                                                                                  d = 15
y = 2005
day.y.m.d = 'Friday'

</syntax highlight>

बहु-आयामी सरणी के प्रभाव को प्रदान करने के लिए एकाधिक संख्यात्मक पूंछ तत्वों का उपयोग किया जा सकता है।

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

<syntax-highlight lang=rex style=background-color: #ffffff; important> 

 add_word: procedure expose count. word_list
 parse arg w .
 count.w = count.w + 1 /* assume count. has been set to 0 */
 if count.w = 1 then word_list = word_list w
return

</syntax highlight>

और फिर बाद में:

<syntax-highlight lang=rex style=background-color: #ffffff; important> 

do i = 1 to words(word_list)
 w = word(word_list,i)
 say w count.w
end

</syntax highlight>

कुछ स्पष्टता की मूल्य पर इन तकनीकों को एक ही stem में संयोजित करना संभव है:

<syntax-highlight lang=rex style=background-color: #ffffff; important> 

add_word: procedure expose dictionary.
 parse arg w .
 dictionary.w = dictionary.w + 1
 if dictionary.w = 1 /* assume dictionary. = 0 */
 then do
 n = dictionary.0+1
 dictionary.n = w
 dictionary.0 = n
 end
return

</syntax highlight>

और बाद में:

<syntax-highlight lang=rex style=background-color: #ffffff; important> 

do i = 1 to dictionary.0
 w = dictionary.i
 say i w dictionary.w
end

</syntax highlight>

रेक्स यहां कोई सुरक्षा जाल प्रदान नहीं करता है, इसलिए यदि कोई एक शब्द dictionary.0 से कम होता है यह तकनीक रहस्यपूर्ण रूप से विफल हो जाएगी।

IBM के ऑब्जेक्ट रेक्स सहित रेक्स के हाल के कार्यान्वयन और oorexx जैसे ओपन सोर्स कार्यान्वयन में स्टेम के मान पर पुनरावृत्ति को सरल बनाने के लिए एक नई भाषा का निर्माण सम्मिलित है, या किसी अन्य संग्रह वस्तु जैसे कि सरणी, तालिका या सूची पर।

<syntax-highlight lang=rex style=background-color: #ffffff; important> 

do i over stem.
say i '-->' stem.i
end

</syntax highlight>

कीवर्ड निर्देश

==== पार्स ====

PARSE E> निर्देश विशेष रूप से शक्तिशाली है; यह कुछ उपयोगी स्ट्रिंग-हैंडलिंग फ़ंक्शंस को जोड़ती है। इसका सिंटैक्स है:

<syntax lang=rex> 

parse [upper] origin [template]

</syntax highlight>

जहां मूल स्रोत निर्दिष्ट करता है:

  • arg (तर्क, कमांड लाइन के शीर्ष स्तर की पूंछ पर)
  • linein (मानक इनपुट, जैसे कीबोर्ड)
  • pull (रेक्स डेटा कतार या मानक इनपुट)
  • source (कार्यक्रम को कैसे क्रियान्वित किया गया, इसकी जानकारी)
  • value (एक अभिव्यक्ति) with: कीवर्ड with यह इंगित करना आवश्यक है कि अभिव्यक्ति कहाँ समाप्त होती है
  • var (एक परिवर्तनीय)
  • version (संस्करण/रिलीज़ नंबर)

और टेम्पलेट हो सकता है:

  • चर की सूची
  • स्तंभ संख्या सीमांकक
  • शाब्दिक सीमांकक

upper वैकल्पिक है; यदि निर्दिष्ट किया गया है, तो पार्स करने से पहले डेटा अपर केस में परिवर्तित हो जाएगा।

उदाहरण:

टेम्पलेट के रूप में चरों की सूची का उपयोग करना

<syntax-highlight lang=rex style=background-color: #ffffff; important> 

myVar = "John Smith"
parse var myVar firstName lastName
say "First name is:" firstName
say "Last name is:" lastName

</syntax highlight>

निम्नलिखित प्रदर्शित करता है:

<ex> 

First name is: John
Last name is: Smith

</ex>

टेम्पलेट के रूप में सीमांकक का उपयोग करना:

<syntax lang=rex> 

myVar = "Smith, John"
parse var myVar LastName "," FirstName
say "First name is:" firstName
say "Last name is:" lastName

</syntax highlight>

निम्नलिखित भी प्रदर्शित करता है:

<ex> 

 First name is: John
 Last name is: Smith

</ex>

स्तंभ संख्या सीमांकक का उपयोग करना:

<syntax lang=rex> 

myVar = "(202) 123-1234"
parse var MyVar 2 AreaCode 5 7 SubNumber
say "Area code is:" AreaCode
say "Subscriber number is:" SubNumber

</syntax highlight>

निम्नलिखित प्रदर्शित करता है:

<ex> 

Area code is: 202
Subscriber number is: 123-1234

</ex>

एक टेम्पलेट चर, शाब्दिक सीमांकक और स्तंभ संख्या सीमांकक के संयोजन का उपयोग कर सकता है।

व्याख्या

INTERPRET निर्देश अपने तर्क का मूल्यांकन करता है और इसके मान को रेक्स कथन के रूप में मानता है। कभी-कभी INTERPRET किसी कार्य को करने का सबसे स्पष्ट विधि है, लेकिन इसका उपयोग अधिकांश वहाँ किया जाता है जहाँ स्पष्ट कोड का उपयोग करना संभव होता है, जैसे, value().

INTERPRET के अन्य उपयोग रेक्स's (दशमलव) मनमाने ढंग से सटीक अंकगणित (फ़ज़ी तुलनाओं सहित), प्रोग्रामेटिक टेम्प्लेट, स्टेम्ड एरेज़ और विरल सरणियों के साथ PARSE स्टेटमेंट का उपयोग हैं।[how?]

<syntax lang=rex> 

/* demonstrate INTERPRET with square(4) => 16 */
X = 'square'
interpret 'say' X || '(4) ; exit'
SQUARE: return arg(1)**2

</syntax highlight>

यह 16 प्रदर्शित करता है और बाहर निकलता है। क्योंकि रेक्स में चर सामग्री स्ट्रिंग्स हैं, जिसमें एक्सपोनेंट और यहां तक ​​​​कि पूरे प्रोग्राम के साथ परिमेय संख्याएं सम्मिलित हैं, रेक्स स्ट्रिंग्स को मूल्यांकन किए गए भावों के रूप में व्याख्या करने की प्रस्तुत करता है।

इस सुविधा का उपयोग फ़ंक्शन मापदंडों के रूप में कार्यों को पारित करने के लिए किया जा सकता है, जैसे कि इंटीग्रल की गणना करने के लिए SIN या COS को एक प्रक्रिया में पास करना।

रेक्स ABS, DIGITS, MAX, MIN, SIGN, RANDOM जैसे केवल बुनियादी गणित कार्यों और बिट संचालन के साथ हेक्स प्लस बाइनरी रूपांतरणों का एक पूरा सेट प्रदान करता है। एसआईएन जैसे अधिक जटिल कार्यों को खरोंच से लागू किया गया था या तीसरे पक्ष के बाहरी पुस्तकालय (कंप्यूटिंग) से प्राप्त किया गया था। कुछ बाहरी पुस्तकालय, विशेष रूप से पारंपरिक भाषाओं में लागू किए गए, विस्तारित परिशुद्धता का समर्थन नहीं करते थे।

बाद के संस्करण (गैर-पारंपरिक) CALL variable निर्माणों का समर्थन करते हैं। साथ में बिल्ट-इन फ़ंक्शन VALUE, CALL के कई स्थितियों के स्थान पर उपयोग किया जा सकता है INTERPRET. यह एक पारंपरिक प्रोग्राम है:

<syntax-highlight lang=rex style=background-color: #ffffff; important> 

/* terminated by input "exit" or similar */
do forever ; interpret linein() ; end

</syntax highlight>

थोड़ा और परिष्कृत रेक्स कैलकुलेटर:

<syntax-highlight lang=rex style=background-color: #ffffff; important> 

 X = 'input BYE to quit'

 do until X = 'BYE' ; interpret 'say' X ; pull X ; end

</syntax highlight>

PULL के लिए आशुलिपि है parse upper pull. वैसे ही, ARG के लिए आशुलिपि है parse upper arg.

INTERPRET निर्देश की शक्ति के अन्य उपयोग थे। वेलोर (सॉफ्टवेयर) पैकेज वस्तु उन्मुख कार्यकर्म वातावरण को लागू करने के लिए रेक्स की व्याख्यात्मक क्षमता पर निर्भर था। टाइम मशीन नामक एक अप्रकाशित वेस्टिंगहाउस इलेक्ट्रिक (1886) उत्पाद में एक अन्य उपयोग पाया गया जो एक घातक त्रुटि के बाद पूरी तरह से ठीक होने में सक्षम था।

संख्यात्मक

<syntax lang=rex> 

say digits() fuzz() form() /* => 9 0 SCIENTIFIC */
 say 999999999+1 /* => 1.000000000E+9 */
 numeric digits 10 /* only limited by available memory */
 say 999999999+1 /* => 1000000000 */

 say 0.9999999999=1 /* => 0 (false) */
 numeric fuzz 3
 say 0.99999999=1 /* => 1 (true) */
 say 0.99999999==1 /* => 0 (false) */

 say 100*123456789 /* => 1.23456789E+10 */
 numeric form engineering
 say 100*123456789 /* => 12.34567890E+9 */

 say 53 // 7   /* => 4   (rest of division)*/
  √2 की गणना करता है e की गणना करता है
कोड 
 numeric digits 50
 n=2
 r=1
 do forever /* Newton's method */
 rr=(n/r+r)/2
 if r=rr then leave
 r=rr
 end
 say "sqrt" n ' = ' r

 numeric digits 50
 e=2.5
 f=0.5
 do n=3
 f=f/n
 ee=e+f
 if e=ee then leave
 e=ee
 end
 say "e =" e
आउटपुट sqrt 2 = 1.414213562373095048801688724209698078569671875377 e = 2.7182818284590452353602874713526624977572470936998


संकेत

सिग्नल निर्देश नियंत्रण के प्रवाह में असामान्य परिवर्तन के लिए अभिप्रेत है (अगला खंड देखें)। चूँकि, इसका दुरुपयोग किया जा सकता है और अन्य भाषाओं में पाए जाने वाले GOTO स्टेटमेंट की तरह व्यवहार किया जा सकता है (चूँकि यह प्रभुत्व से समतुल्य नहीं है, क्योंकि यह लूप और अन्य निर्माणों को समाप्त करता है)। यह पढ़ने में जटिल कोड उत्पन्न कर सकता है।

त्रुटि से निपटने और अपवाद

रेक्स में SIGNAL निर्देश का उपयोग करके त्रुटियों और अन्य अपवादों को रोकना और उनसे निपटना संभव है। सात सिस्टम कंडीशन हैं: एरर, फेल्योर, हॉल्ट, नोवैल्यू, नोट्रेडी, लॉस्टडिजिट्स और सिंटेक्स। स्रोत कोड में वांछित के रूप में प्रत्येक की हैंडलिंग को चालू और बंद किया जा सकता है।

उपयोगकर्ता द्वारा समाप्त किए जाने तक निम्न प्रोग्राम चलेगा:

<syntax-highlight lang=rex style=background-color: #ffffff; important> 

signal on halt;
 do a = 1
	 say a
	 do 100000 /* a delay */
	 end
 end
 halt:
 say "The program was stopped by the user"
exit

</syntax highlight>

A signal on novalue कथन अपरिभाषित चरों के उपयोग को रोकता है, जो अन्यथा उनके मूल्य के रूप में अपना (अपर केस) नाम प्राप्त करेंगे। NOVALUE स्थिति की स्थिति के अतिरिक्त, एक चर की स्थिति को परिभाषित चर के लिए अंतर्निहित फ़ंक्शन SYMBOL रिटर्निंग VAR के साथ हमेशा जांचा जा सकता है।

VALUE e> फ़ंक्शन का उपयोग NOVALUE स्थिति को ट्रिगर किए बिना चर का मान प्राप्त करने के लिए किया जा सकता है, लेकिन इसका मुख्य उद्देश्य POSIX getenv और putenv के समान env (शेल) चर को पढ़ना और सेट करना है।

शर्तें

ERROR
सिस्टम कमांड से सकारात्मक आरसी
FAILURE
सिस्टम कमांड के लिए नेगेटिव आरसी (जैसे कमांड उपस्थित नहीं है)
HALT
असामान्य समाप्ति
NOVALUE
एक अनसेट चर का संदर्भ दिया गया था
NOTREADY
इनपुट या आउटपुट त्रुटि (उदाहरण फ़ाइल के अंत से परे पढ़ने के प्रयास)
SYNTAX
अमान्य प्रोग्राम सिंटैक्स, या कुछ अन्य त्रुटि स्थिति
LOSTDIGITS
महत्वपूर्ण अंक खो गए हैं (एएनएसआई रेक्स, टीआरएल दूसरे संस्करण में नहीं)

जब किसी स्थिति को SIGNAL ON द्वारा नियंत्रित किया जाता है, तो स्थिति को समझने के लिए SIGL तथा RC सिस्टम चर का विश्लेषण किया जा सकता है। आरसी में रेक्स त्रुटि कोड होता है और एसआईजीएल में वह पंक्ति संख्या होती है जहां त्रुटि उत्पन्न हुई थी।

रेक्स संस्करण 4 के साथ प्रारंभ होने वाली स्थितियों को नाम मिल सकते हैं, और एक CALL ON निर्माण भी है। यदि बाहरी कार्य आवश्यक रूप से उपस्थित नहीं हैं तो यह आसान है:

<syntax lang=rex> 

 ChangeCodePage: procedure /* protect SIGNAL settings */
 signal on syntax name ChangeCodePage.Trap
 return SysQueryProcessCodePage()
ChangeCodePage.Trap: return 1004 /* windows-1252 on OS/2 */

</syntax highlight>

यह भी देखें

टिप्पणियाँ

  1. ↑ The TSO EXEC command with an unqualified dataset name and neither the CLIST nor EXEC option examines the low level qualifier or EXEC.
  2. ↑ If the first line of a script fetched from SYSPROC is a comment containing REXX then it is treated as REXX rather than CLIST. A script fetched from SYSEXEC must be REXX.


संदर्भ

  1. ↑ 1.0 1.1 Mark Hessling (October 25, 2012). "Regina Rexx Interpreter". SourceForge project regina-rexx. Retrieved 2014-02-10.
  2. ↑ 2.0 2.1 2.2 M. F. Cowlishaw. "IBM REXX संक्षिप्त इतिहास". IBM. Retrieved 2006-08-15.
  3. ↑ 3.0 3.1 Melinda Varian. "REXX संगोष्ठी, मई 1995".
  4. ↑ "सभी दस्तावेज़ों की सूची (फ़िल्टर=rexx)". IBM library server. 2005. Retrieved 2014-02-10.
  5. ↑ "क्या ArcaOS में REXX सपोर्ट शामिल है?". Retrieved 2020-09-03.
  6. ↑ EXEC 2 संदर्भ (PDF) (Second ed.). International Business Machines Corporation. April 1982. p. 92. SC24-5219-1.
  7. ↑ IBM वर्चुअल मशीन सुविधा /370: EXEC उपयोगकर्ता गाइड (PDF) (Second ed.). International Business Machines Corporation. April 1975. GC20-1812-1.
  8. ↑ 8.0 8.1 M. F. Cowlishaw (1984). "REXX भाषा का डिज़ाइन" (PDF). IBM Systems Journal (PDF). IBM Research. 23 (4): 333. doi:10.1147/sj.234.0326. Retrieved 2014-01-23. क्या नई विशेषता से जुड़ा कोई उच्च आश्चर्यजनक कारक हो सकता है? यदि कोई सुविधा उपयोगकर्ता द्वारा गलती से गलत तरीके से लागू की जाती है और उसके कारण अप्रत्याशित परिणाम दिखाई देता है, तो उस सुविधा में एक उच्च विस्मयकारी कारक होता है और इसलिए अवांछनीय है। यदि एक आवश्यक विशेषता में एक उच्च विस्मयकारी कारक है, तो सुविधा को फिर से डिज़ाइन करना आवश्यक हो सकता है।
  9. ↑ M. F. Cowlishaw (1981-02-18). "REX - एक कमांड प्रोग्रामिंग लैंग्वेज". SHARE. Retrieved 2006-08-15.
  10. ↑ Lundin, Leigh; Woodruff, Mark (1987-04-23). "T/REXX, CMS के लिए एक REXX कंपाइलर". U.S. Copyright Office. Washington, DC: Independent Intelligence Incorporated (TXu000295377).
  11. ↑ 11.0 11.1 Howard Fosdick (2005). Rexx प्रोग्रामर का संदर्भ. Wiley Publishing. p. 390. ISBN 0-7645-7996-7.
  12. ↑ "रेक्स कार्यान्वयन". RexxLA. Archived from the original on 2006-09-24. Retrieved 2006-08-15.
  13. ↑ While ANSI INCITS 274-1996/AMD1-2000 (R2001) and ANSI INCITS 274-1996 (R2007) are chargeable, a free draft can be downloaded: "American National Standard for Information Systems – Programming Language REXX" (PDF). X3J18-199X.
  14. ↑ "अगली 50 प्रोग्रामिंग भाषाएँ". TIOBE index. tiobe.com. 2017. Archived from the original on 2017-01-19. Retrieved 2017-01-10.
  15. ↑ "RexxLA - संगोष्ठी अनुसूची".
  16. ↑ M. F. Cowlishaw (1990). द रेक्स लैंग्वेज - ए प्रैक्टिकल एप्रोच टू प्रोग्रामिंग (2nd ed.). Prentice Hall. ISBN 0-13-780651-5.
  17. ↑ "Rexx के लिए अंगूठे के छह नियम".


अग्रिम पठन

  • Callaway, Merrill. The ARexx Cookbook: A Tutorial Guide to the ARexx Language on the Commodore Amiga Personal Computer. Whitestone, 1992. ISBN 978-0963277305.
  • Callaway, Merrill. The Rexx Cookbook: A Tutorial Guide to the Rexx Language in OS/2 & Warp on the IBM Personal Computer. Whitestone, 1995. ISBN 0-9632773-4-0.
  • Cowlishaw, Michael. The Rexx Language: A Practical Approach to Programming. Prentice Hall, 1990. ISBN 0-13-780651-5.
  • Cowlishaw, Michael. The NetRexx Language. Prentice Hall, 1997. ISBN 0-13-806332-X.
  • Daney, Charles. Programming in REXX. McGraw-Hill, TX, 1990. ISBN 0-07-015305-1.
  • Ender, Tom. Object-Oriented Programming With Rexx. John Wiley & Sons, 1997. ISBN 0-471-11844-3.
  • Fosdick, Howard. Rexx Programmer's Reference. Wiley/Wrox, 2005. ISBN 0-7645-7996-7.
  • Gargiulo, Gabriel. REXX with OS/2, TSO, & CMS Features. MVS Training, 1999 (third edition 2004). ISBN 1-892559-03-X.
  • Goldberg, Gabriel and Smith, Philip H. The Rexx Handbook . McGraw-Hill, TX, 1992. ISBN 0-07-023682-8.
  • Goran, Richard K. REXX Reference Summary Handbook. CFS Nevada, Inc.,1997. ISBN 0-9639854-3-4.
  • IBM Redbooks. Implementing Rexx Support in Sdsf. Vervante, 2007. ISBN 0-7384-8914-X.
  • Kiesel, Peter C. Rexx: Advanced Techniques for Programmers. McGraw-Hill, TX, 1992. ISBN 0-07-034600-3.
  • Marco, Lou ISPF/REXX Development for Experienced Programmers. CBM Books, 1995. ISBN 1-878956-50-7
  • O'Hara, Robert P. and Gomberg, David Roos. Modern Programming Using Rexx. Prentice Hall, 1988. ISBN 0-13-597329-5.
  • Rudd, Anthony S. 'Practical Usage of TSO REXX'. CreateSpace, 2012. ISBN 978-1475097559.
  • Schindler, William. Down to Earth Rexx. Perfect Niche Software, 2000. ISBN 0-9677590-0-5.


बाहरी संबंध

Wikimedia Commons has media related to REXX (programming language).
Retrieved from ‘https://www.vigyanwiki.in/index.php?title=रेक्स&oldid=104660’