Rexx - Kurzanleitung

Rexx (Restructured Extended Executor)ist als Skriptsprache konzipiert. Ziel ist es, die Skripterstellung so einfach, schnell, zuverlässig und fehlerfrei wie möglich zu gestalten. Viele Programmiersprachen sind auf Kompatibilität mit älteren Sprachen ausgelegt und für bestimmte Zielgruppen oder Plattformen geschrieben. Rexx ignoriert fremde Ziele. Es wurde vom ersten Tag an so konzipiert, dass es leistungsstark und dennoch einfach zu bedienen ist.

Rexx wurde entwickelt und erste Implementierung in Assembler - Sprache als ‚Eigenzeit‘ Projekt zwischen 20 ^th März 1979 und Mitte 1982 von Mike Cowlishaw von IBM, die ursprünglich als Skript Programmiersprache um die Sprachen zu ersetzenEXEC and EXEC 2. Es wurde entworfen, um ein zu seinmacro or scripting languagefür jedes System. Als solches gilt Rexx als Vorläufer von Tcl und Python. Rexx sollte von seinem Entwickler auch eine vereinfachte und leichter zu erlernende Version der PL / I-Programmiersprache sein.

Eigenschaften von Rexx

Rexx als Programmiersprache verfügt über folgende Hauptmerkmale:

Einfache Syntax
Die Möglichkeit, Befehle an mehrere Umgebungen weiterzuleiten
Die Fähigkeit, Funktionen, Prozeduren und Befehle zu unterstützen, die einer bestimmten aufrufenden Umgebung zugeordnet sind.
Ein integrierter Stack mit der Möglichkeit, mit dem Host-Stack zusammenzuarbeiten, falls vorhanden.
Kleiner Befehlssatz mit nur zwei Dutzend Anweisungen
Freiform-Syntax
Token ohne Berücksichtigung der Groß- und Kleinschreibung, einschließlich Variablennamen
Zeichenkettenbasis
Dynamische Datentypisierung, keine Deklarationen
Keine reservierten Schlüsselwörter, außer im lokalen Kontext
Keine Include-Datei-Funktionen
Beliebige numerische Genauigkeit
Dezimalarithmetik, Gleitkomma
Eine reichhaltige Auswahl an integrierten Funktionen, insbesondere Zeichenfolgen- und Textverarbeitung
Automatische Speicherverwaltung
Absturzsicherung
Inhaltsadressierbare Datenstrukturen
Assoziative Arrays
Einfacher Zugriff auf Systembefehle und -einrichtungen
Einfache Fehlerbehandlung sowie integrierter Tracing- und Debugger
Nur wenige künstliche Einschränkungen
Vereinfachte E / A-Funktionen

Die offizielle Website für Rexx ist www.oorexx.org

Bevor Sie mit der Arbeit an Rexx beginnen können, müssen Sie sicherstellen, dass auf Ihrem System eine voll funktionsfähige Version von Rexx ausgeführt wird. In diesem Kapitel wird die Installation von Rexx und die nachfolgende Konfiguration auf einem Windows-Computer erläutert, um mit Rexx zu beginnen.

Stellen Sie sicher, dass die folgenden Systemanforderungen erfüllt sind, bevor Sie mit der Installation fortfahren.

System Anforderungen

Erinnerung	2 GB RAM (empfohlen)
Festplattenplatz	Keine Mindestanforderung. Am besten genug Speicherplatz, um die Programme zu speichern, die mit Rexx erstellt werden.
Betriebssystemversion	Rexx kann unter Windows, Ubuntu / Debian und Mac OS X installiert werden.

Rexx herunterladen

Um Rexx herunterzuladen, sollten Sie die folgende URL verwenden: https://www.oorexx.org/download.html

Diese Seite bietet eine Vielzahl von Downloads für verschiedene Versionen von Rexx, wie im folgenden Screenshot gezeigt.

Klicken Sie in der Tabelle mit dem Header von Release 4.2.0 auf die 'ooRexx-Installationsdateien'.

Danach werden Sie auf die folgende Seite weitergeleitet.

Klick auf das ooRexx-4.2.0.windows.x86_64.exe um die 64-bitVersion der Software. Wir werden die Installation der Software im folgenden Kapitel diskutieren.

In den folgenden Schritten wird ausführlich erläutert, wie Rexx auf einem Windows-System installiert werden kann.

Step 1- Starten Sie das im vorherigen Abschnitt heruntergeladene Installationsprogramm. Klicken Sie nach dem Start des Installationsprogramms auf die Schaltfläche Ausführen.

Step 2 - Klicken Sie im folgenden Bildschirm auf die Schaltfläche Weiter, um mit der Installation fortzufahren.

Step 3 - Klicken Sie auf die I Agree Taste, um fortzufahren.

Step 4 - Akzeptiere die default components und klicken Sie dann auf die Schaltfläche Weiter.

Step 5 - Wählen Sie den Installationsort und klicken Sie auf die Schaltfläche Weiter.

Step 6 - Akzeptieren Sie die Standardprozesse, die installiert werden, und klicken Sie auf die Schaltfläche Weiter.

Step 7 - Wählen Sie die Standarddateizuordnungen und klicken Sie auf die Schaltfläche Weiter.

Step 8 - Aktivieren Sie die Kontrollkästchen zum Senden von Rexx-Elementen an die ausführbaren Dateien und klicken Sie dann auf die Schaltfläche Weiter (siehe folgenden Screenshot).

Step 9- Wählen Sie im nächsten Bildschirm den Editor für die Arbeit mit Rexx-Dateien. Behalten Sie den Notizblock als Standardoption bei. Akzeptieren Sie auch die Standarderweiterung für jede Rexx-Datei.

Step 10 - Übernehmen Sie die Standardeinstellungen auf dem folgenden Bildschirm und klicken Sie auf die Schaltfläche Weiter, um mit der Installation fortzufahren.

Step 11 - Klicken Sie abschließend auf die Schaltfläche Installieren, um mit der Installation fortzufahren.

Step 12 - Nach Abschluss der Installation müssen Sie auf die Schaltfläche Weiter klicken, um fortzufahren.

Step 13 - Klicken Sie auf die Schaltfläche Fertig stellen, um die Installation abzuschließen.

In diesem Kapitel wird erläutert, wie Plug-Ins installiert werden popular IDE’s (Integrated Development Environment). Rexx als Programmiersprache ist auch in gängigen IDEs wie verfügbarEclipse. Schauen wir uns an, wie wir die erforderlichen Plugins in diesen IDEs erhalten können, damit Sie mehr Auswahlmöglichkeiten bei der Arbeit mit Rexx haben.

Installation in Eclipse

Um Rexx problemlos in Eclipse zu installieren, müssen Sie die folgenden Schritte ausführen.

Step 1 - Öffnen Sie Eclipse und klicken Sie auf den Menüpunkt. Help → Eclipse Marketplace wie im folgenden Screenshot gezeigt.

Step 2 - Geben Sie im nächsten Dialogfeld Rexx in die Suchkriterien ein und klicken Sie auf die Schaltfläche Suchen.

Klicken Sie anschließend auf die Schaltfläche Installieren.

Step 3 - Klicken Sie auf die Schaltfläche Bestätigen, um mit der Installation der Funktionen fortzufahren.

Step 4- Eclipse lädt dann die erforderlichen Dateien herunter, um mit der Installation zu beginnen. Sobald dies erledigt ist, fordert Eclipse Sie auf, die Lizenzvereinbarungen zu akzeptieren. Klicken Sie auf Akzeptieren der Lizenzvereinbarungen und dann auf die Schaltfläche Fertig stellen (siehe folgenden Screenshot).

Eclipse beginnt dann mit der Installation der Software im Hintergrund.

Step 5- Sie erhalten wahrscheinlich eine Sicherheitswarnung (wie im folgenden Screenshot gezeigt). Klicken Sie auf die Schaltfläche OK, um fortzufahren.

Step 6- Sie werden aufgefordert, Eclipse neu zu starten, sobald die Updates installiert sind. Klicken Sie auf Ja, um Eclipse neu zu starten.

Um die grundlegende Syntax von Rexx zu verstehen, schauen wir uns zunächst ein einfaches Hello World-Programm an.

Beispiel

/* Main program */ 
say "Hello World"

Man kann sehen, wie einfach das Hallo-Welt-Programm ist. Es ist eine einfache Skriptzeile, mit der das Hello World-Programm ausgeführt wird.

Die folgenden Dinge müssen über das obige Programm beachtet werden -

Das say command wird verwendet, um einen Wert an die Konsole auszugeben.
Das /* */ wird für Kommentare in Rexx verwendet.

Die Ausgabe des obigen Programms ist -

Hello World

Allgemeine Form einer Erklärung

Sehen wir uns in Rexx eine allgemeine Form eines Programms an. Schauen Sie sich das folgende Beispiel an.

/* Main program */ 
say add(5,6) 
exit 
add: 
parse arg a,b 
return a + b

Die Ausgabe des obigen Programms ist -

Lassen Sie uns durchgehen, was wir aus dem obigen Programm verstanden haben -

Hinzufügen ist eine Funktion zum Hinzufügen von 2 Zahlen.
Im Hauptprogramm werden die Werte 5 und 6 als Parameter für die Add-Funktion verwendet.
Das Schlüsselwort exit wird zum Beenden des Hauptprogramms verwendet. Dies wird verwendet, um das Hauptprogramm von der Add-Funktion zu unterscheiden.
Die Add-Funktion wird durch das Symbol ':' unterschieden.
Die parse-Anweisung wird verwendet, um die eingehenden Argumente zu analysieren.
Schließlich wird die return-Anweisung verwendet, um die Summe der numerischen Werte zurückzugeben.

Unterprogramme und Funktionen

In Rexx ist der Code normalerweise in Unterprogramme und Funktionen unterteilt. Unterprogramme und Funktionen werden verwendet, um den Code in verschiedene logische Einheiten zu unterscheiden. Der Hauptunterschied zwischen Unterprogrammen und Funktionen besteht darin, dass Funktionen einen Wert zurückgeben, während Unterprogramme dies nicht tun.

Nachfolgend finden Sie ein Beispiel für einen wesentlichen Unterschied zwischen einem Unterprogramm und einer Funktion für eine Additionsimplementierung.

Funktionsimplementierung

/* Main program */ 
say add(5,6) 
exit 
add: 
parse arg a,b 
return a + b

Implementierung des Unterprogramms

/* Main program */ 
add(5,6) 
exit 
add: 
parse arg a,b 
say a + b

Die Ausgabe beider Programme ist der Wert 11.

Befehle ausführen

Rexx kann als Steuerungssprache für eine Vielzahl befehlsbasierter Systeme verwendet werden. Rexx führt Befehle in diesen Systemen folgendermaßen aus. Wenn Rexx auf eine Programmzeile stößt, die weder eine Anweisung noch eine Zuweisung ist, behandelt es diese Zeile als Zeichenfolgenausdruck, der ausgewertet und dann an die Umgebung übergeben werden soll.

Ein Beispiel ist wie folgt:

Beispiel

/* Main program */ 
parse arg command 
command "file1" 
command "file2" 
command "file3" 
exit

Jede der drei ähnlichen Zeilen in diesem Programm ist ein Zeichenfolgenausdruck, der den Namen einer Datei (in den Zeichenfolgenkonstanten enthalten) zum Namen eines Befehls (als Parameter angegeben) hinzufügt. Die resultierende Zeichenfolge wird an die Umgebung übergeben, um als Befehl ausgeführt zu werden. Wenn der Befehl beendet ist, wird die Variable "rc" auf den Exit-Code des Befehls gesetzt.

Die Ausgabe des obigen Programms ist wie folgt:

sh: file1: command not found
     3 *-* command "file1" 
       >>>   " file1"
       +++   "RC(127)"
sh: file2: command not found
     4 *-* command "file2" 
       >>>   " file2"
       +++   "RC(127)"
sh: file3: command not found
     5 *-* command "file3" 
       >>>   " file3"
       +++   "RC(127)"

Schlüsselwörter in Rexx

Die freie Syntax von REXX impliziert, dass einige Symbole für die Verwendung durch den Sprachprozessor in bestimmten Kontexten reserviert sind.

Innerhalb bestimmter Anweisungen können einige Symbole reserviert sein, um die Teile der Anweisung zu trennen. Diese Symbole werden als Schlüsselwörter bezeichnet. Beispiele für REXX-Schlüsselwörter sind dieWHILE in a DO instruction, und die THEN (die in diesem Fall als Klauselabschluss fungiert) nach einem IF or WHEN clause.

Abgesehen von diesen Fällen werden nur einfache Symbole, die das erste Token in einer Klausel sind und denen kein "=" oder ":" folgt, überprüft, um festzustellen, ob es sich um Anweisungsschlüsselwörter handelt. Sie können die Symbole an anderer Stelle in Klauseln frei verwenden, ohne dass sie als Schlüsselwörter angesehen werden.

Kommentare in Rexx

Kommentare werden verwendet, um Ihren Code zu dokumentieren. Einzeilige Kommentare werden mit / * * / an einer beliebigen Position in der Zeile identifiziert.

Ein Beispiel ist wie folgt:

/* Main program */
/* Call the add function */
add(5,6)

/* Exit the main program */
exit add:

/* Parse the arguments passed to the add function */ parse arg a,b
/* Display the added numeric values */
say a + b

Kommentare können auch zwischen eine Codezeile geschrieben werden, wie im folgenden Programm gezeigt -

/* Main program */ 
/* Call the add function */ 
add(5,6) 

/* Exit the main program */ 
exit 
add: 
parse    /* Parse the arguments passed to the add function */ 
arg a,b 

/* Display the added numeric values */ 
say a + b

Die Ausgabe des obigen Programms ist -

Sie können auch mehrere Zeilen in einem Kommentar haben, wie im folgenden Programm gezeigt -

/* Main program 
The below program is used to add numbers 
Call the add function */ 
add(5,6) 
exit 
add: 
parse arg a,b 
say a + b

Die Ausgabe des obigen Programms ist -

In jeder Programmiersprache müssen Sie verschiedene Variablen verwenden, um verschiedene Arten von Informationen zu speichern. Variablen sind nichts anderes als reservierte Speicherplätze zum Speichern von Werten. Dies bedeutet, dass Sie beim Erstellen einer Variablen Speicherplatz im Speicher reservieren, um den dieser Variablen zugeordneten Wert zu speichern.

Möglicherweise möchten Sie Informationen verschiedener Datentypen wie Zeichenfolge, Zeichen, Breites Zeichen, Ganzzahl, Gleitkomma, Boolescher Wert usw. speichern. Basierend auf dem Datentyp einer Variablen weist das Betriebssystem Speicher zu und entscheidet, was im reservierten Bereich gespeichert werden kann Erinnerung.

Integrierte Datentypen

Rexx bietet eine Vielzahl integrierter Datentypen. Es folgt eine Liste der Datentypen, die in Rexx definiert sind.

Integer- Eine numerische Zeichenfolge, die keinen Dezimalpunkt oder Exponentenbezeichner enthält. Das erste Zeichen kann seina plus (+) or minus (-) sign. Die dargestellte Nummer muss zwischen -2147483648 und 2147483647 einschließlich liegen.
Big Integer- Eine Zahlenfolge, die keinen Dezimalpunkt oder Exponentenbezeichner enthält. Das erste Zeichen kann ein Pluszeichen (+) oder ein Minuszeichen (-) sein. Die dargestellte Nummer muss zwischen -9223372036854775808 und 2147483648 einschließlich oder zwischen 2147483648 und 9223372036854775807 liegen.
Decimal - Es wird aus einem der folgenden Formate sein -
- Eine numerische Zeichenfolge, die einen Dezimalpunkt, aber keine Exponenten-ID enthält. Dasp repräsentiert die Präzision und sstellt die Skala der Dezimalzahl dar, die die Zeichenfolge darstellt. Das erste Zeichen kann ein Pluszeichen (+) oder ein Minuszeichen (-) sein.
- Eine Folge von Zahlen, die does not contain a decimal pointoder eine Exponenten-ID. Das erste Zeichen kann ein Pluszeichen (+) oder ein Minuszeichen (-) sein. Die dargestellte Zahl ist kleiner als -9223372036854775808 oder größer als 9223372036854775807.
Float- Eine Zeichenfolge, die eine Zahl in wissenschaftlicher Notation darstellt. Die Zeichenfolge besteht aus einer Reihe von Zahlen, gefolgt von einer Exponenten-ID (einem E oder e, gefolgt von einem optionalen Plus- (+) oder Minuszeichen (-) und einer Reihe von Zahlen). Die Zeichenfolge kann mit einem Pluszeichen (+) oder Minuszeichen (-) beginnen.
String - Eine normale Zeichenfolge.

Im Folgenden finden Sie einige Beispiele, wie jeder Datentyp verwendet werden kann. Wieder wird jeder Datentyp in den folgenden Kapiteln ausführlich besprochen. Dies dient nur dazu, Sie mit einer kurzen Beschreibung der oben genannten Datentypen auf den neuesten Stand zu bringen.

Ganze Zahl

Ein Beispiel für die Verwendung des Nummerndatentyps ist im folgenden Programm dargestellt. Dieses Programm zeigt das Hinzufügen von 2 Ganzzahlen.

Example

/* Main program 
The below program is used to add numbers 
Call the add function */ 
add(5,6)  

exit 
add:  

parse arg a,b 
say a + b

Die Ausgabe des obigen Programms ist -

Big Integer

Das folgende Programm zeigt die Fähigkeit von Rexx, große ganze Zahlen zu verarbeiten. Dieses Programm zeigt, wie Sie 2 große Ganzzahlen hinzufügen.

Example

/* Main program 
The below program is used to add numbers 
Call the add function */ 
add(500000000000,6000000000000000000000)  

exit 
add:  

parse arg a,b 
say a + b

Die Ausgabe des obigen Programms ist -

6.00000000E+21

Dezimal

Das folgende Programm zeigt die Fähigkeit von Rexx, Dezimalzahlen zu verarbeiten. Dieses Programm zeigt, wie 2 Dezimalzahlen hinzugefügt werden.

Example

/* Main program 
The below program is used to add numbers 
Call the add function */ 
add(5.5,6.6)  

exit 
add:  

parse arg a,b 
say a + b

Die Ausgabe des obigen Programms ist -

12.1

Schweben

Das folgende Beispiel zeigt Fälle, wie eine Zahl als Float fungieren kann.

Example

/* Main program 
The below program is used to add numbers 
Call the add function */ 
add(12E2,14E4)  

exit 
add:  

parse arg a,b 
say a + b

Die Ausgabe des obigen Programms ist -

String

Ein Beispiel für die Verwendung des Tupel-Datentyps ist im folgenden Programm dargestellt.

Hier definieren wir a Tuple PDas hat 3 Begriffe. Dastuple_size ist eine in Rexx definierte integrierte Funktion, mit der die Größe des Tupels bestimmt werden kann.

Example

/* Main program */ 
display("hello")  

exit 
display:  

parse arg a 
say a

Die Ausgabe des obigen Programms ist -

hello

In Rexx sind alle Variablen an die Anweisung '=' gebunden. Variablennamen werden manchmal als Symbole bezeichnet. Sie können aus Buchstaben, Ziffern und Zeichen wie '. ! ? _'. Ein von Ihnen erstellter Variablenname darf nicht mit einer Ziffer oder einem Punkt beginnen. Ein einfacher Variablenname enthält keinen Punkt. Ein Variablenname, der einen Punkt enthält, wird als zusammengesetzte Variable bezeichnet und repräsentiert ein Array oder eine Tabelle.

Im Folgenden sind die grundlegenden Variablentypen in Rexx aufgeführt, die auch im vorherigen Kapitel erläutert wurden:

Integers- Dies wird verwendet, um eine Ganzzahl oder einen Gleitkommawert darzustellen. Ein Beispiel hierfür ist 10.
Big integers - Dies ist ein großer ganzzahliger Wert.
Decimal - Ein Dezimalwert ist eine numerische Zeichenfolge, die einen Dezimalpunkt, aber keine Exponenten-ID enthält.
Float - Ein Gleitkommawert ist eine Zeichenfolge, die eine Zahl in der wissenschaftlichen Notation darstellt.
String - Eine Reihe von Zeichen definiert eine Zeichenfolge in Rexx.

Verschiedene Arten von variablen Funktionen

In diesem Abschnitt werden die verschiedenen Funktionen erläutert, die eine Variable ausführen kann.

Variable Deklarationen

Die allgemeine Syntax zum Definieren einer Variablen wird wie folgt dargestellt:

var-name = var-value

var-name - Dies ist der Name der Variablen.
var-value - Dies ist der an die Variable gebundene Wert.

Das folgende Programm ist ein Beispiel für die Variablendeklaration -

Example

/* Main program */ 
X = 40 
Y = 50 
Result = X + Y 
say Result

Im obigen Beispiel haben wir 2 Variablen, eine davon ist X welches an den Wert gebunden ist 40 und der nächste ist Y welches an den Wert von gebunden ist 50. Eine andere Variable namens Result ist an das Hinzufügen von gebundenX and Y.

Die Ausgabe des obigen Programms wird wie folgt sein:

Variablen benennen

Variablennamen werden manchmal als Symbole bezeichnet. Sie können aus Buchstaben, Ziffern und Zeichen wie 'bestehen. ! ? _ '. Ein von Ihnen erstellter Variablenname darf nicht mit einer Ziffer oder einem Punkt beginnen.

Wenn einer Variablen noch kein Wert zugewiesen wurde, wird sie als nicht initialisiert bezeichnet. Der Wert einer nicht initialisierten Variablen ist der Name der Variablen selbst in Großbuchstaben.

Ein Beispiel für eine nicht zugewiesene Variable lautet wie folgt:

Example

/* Main program */ 
unassignedvalue 
say unassignedvalue

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe:

UNASSIGNEDVALUE
sh: UNASSIGNEDVALUE: command not found
     2 *-* unassignedvalue 
       >>>   "UNASSIGNEDVALUE"
       +++   "RC(127)"

Variablen können mehrmals Werte zugewiesen werden. Das folgende Programm zeigt, wie dem Wert von X ein Wert mehrfach zugewiesen werden kann.

Example

/* Main program */ 
X = 40 
X = 50 
say X

Die Ausgabe des obigen Programms wird wie folgt sein:

Variablen drucken

Die Werte von Variablen werden mit dem gedruckt sayBefehl. Im Folgenden finden Sie ein Beispiel für das Drucken einer Vielzahl von Variablen.

Example

/* Main program */ 
X = 40 

/* Display an Integer */ 
say X 
Y = 50.5 

/* Display a Float */ 
say Y 
Z = "hello" 

/* Display a string */ 
say Z

Die Ausgabe des obigen Programms wird wie folgt sein:

40 
50.5 
hello

Ein Operator ist ein Symbol, das den Compiler anweist, bestimmte mathematische oder logische Manipulationen durchzuführen.

Rexx verfügt über verschiedene Arten von Operatoren, die ebenfalls wie folgt ausführlich erläutert werden:

Rechenzeichen
Vergleichsoperatoren
Logische Operatoren
Bitweise Operatoren

Rechenzeichen

Die Rexx-Sprache unterstützt die normalen arithmetischen Operatoren wie jede andere Sprache. Im Folgenden sind die in Rexx verfügbaren arithmetischen Operatoren aufgeführt.

Beispiel zeigen

Operator	Beschreibung	Beispiel
+	Addition von zwei Operanden	1 + 2 ergibt 3
- -	Subtrahiert den zweiten Operanden vom ersten	1 - 2 ergibt -1
∗	Multiplikation beider Operanden	2 ∗ 2 ergibt 4
/.	Division des Zählers durch Nenner	2/2 ergibt 1
// //	Rest der Division der ersten Zahl durch die zweite	3 // 2 ergibt 1
%.	Die div-Komponente führt die Division durch und gibt die ganzzahlige Komponente zurück.	3% 2 ergeben 1

Vergleichsoperatoren

Vergleichsoperatoren ermöglichen den Vergleich von Objekten. Im Folgenden sind die in Rexx verfügbaren Vergleichsoperatoren aufgeführt. In Rexx wird der wahre Wert mit 1 und der falsche Wert mit 0 bezeichnet.

Beispiel zeigen

Operator	Beschreibung	Beispiel
==	Testet die Gleichheit zwischen zwei Objekten	2 = 2 ergibt 1
<	Überprüft, ob das linke Objekt kleiner als der rechte Operand ist.	2 <3 ergibt 1
= <	Überprüft, ob das linke Objekt kleiner oder gleich dem rechten Operanden ist.	2 = <3 ergibt 1
>	Überprüft, ob das linke Objekt größer als der rechte Operand ist.	3> 2 ergibt 1
> =	Überprüft, ob das linke Objekt größer oder gleich dem rechten Operanden ist.	3> 2 ergibt 1

Logische Operatoren

Logische Operatoren werden verwendet, um boolesche Ausdrücke auszuwerten. Im Folgenden sind die in Rexx verfügbaren logischen Operatoren aufgeführt.

Beispiel zeigen

Operator	Beschreibung	Beispiel
&	Dies ist der logische Operator "und"	1 oder 1 ergibt 1
\|	Dies ist der logische "oder" -Operator	1 oder 0 ergibt 1
\.	Dies ist der logische "Nicht" -Operator	\ 0 ergibt 1
&&	Dies ist der logische exklusive "oder" -Operator	1 && 0 ergibt 1

Bitweise Operatoren

Groovy bietet vier bitweise Operatoren. Nachfolgend finden Sie die in Groovy verfügbaren bitweisen Operatoren.

Beispiel zeigen

Sr.Nr.	Betreiber & Beschreibung
1	bitand Dies ist der bitweise "und" -Operator
2	bitor Dies ist der bitweise "oder" -Operator
3	bitxor Dies ist der bitweise "xor" oder Exclusive oder Operator

Vorrang des Bedieners

Die folgende Tabelle zeigt die Operator-Priorität für die Rexx-Operatoren in der Reihenfolge der absteigenden Priorität ihrer Priorität.

Betreiber	Vorrang
Präfixoperatoren	+ - \
Addition und Subtraktion	+ -
Vergleichsoperatoren	= ==> <> = <=
Logisches UND	&
Logisches ODER	\|
EXKLUSIV ODER	&&

Mit Arrays in einer beliebigen Programmiersprache können Sie eine Liste von Werten desselben Typs gruppieren. Die Verwendung von Arrays besteht darin, dass Sie eine Liste ähnlicher Wertetypen erstellen könnensortable, searchable und kann sein easily manipulated. Mit Rexx können auch Arrays definiert werden. Diese Arrays können eindimensional oder mehrdimensional sein.

Rexx-Arrays können spärlich sein. Das heißt, nicht jede Array-Position muss einen Wert haben oder sogar initialisiert werden. Zwischen denen, die Datenelemente enthalten, können leere Array-Positionen oder Slots stehen. Oder Arrays können dicht sein, in denen aufeinanderfolgende Array-Slots alle Datenelemente enthalten.

In vielen Programmiersprachen müssen Sie sich mit dem Index des ersten Eintrags in einer Tabelle befassen. Ist der erste numerische Index 0 oder 1? In Rexx ist der erste Index das, was Sie verwenden! Geben Sie also das erste Array-Element nach Belieben an Position 0 oder 1 ein.

array_name.0 = ‘first element’

oder

array_name.1 = ‘first element’

Schauen wir uns die verschiedenen Operationen an, die für Arrays verfügbar sind.

Arrays erstellen

Arrays werden mit derselben Namenskonvention erstellt, die für Variablen in Rexx verwendet wird.

Die allgemeine Syntax zum Erstellen von Arrays lautet wie folgt:

Arrayname.index = value

Arrayname - Dies ist der Name des Arrays.
Index - Dies ist die Indexposition im Array, die auf ein bestimmtes Element verweist.
Value - Dies ist der Wert, der dem Indexelement im Array zugewiesen ist.

Ein Beispiel für eine Array-Deklaration lautet wie folgt:

Example

/* Main program */ 
list.1 = 0 
list.2 = 0 
list.3 = 0

Die folgenden Punkte müssen zum obigen Programm beachtet werden:

Der Name des Arrays wird als Liste angegeben
Es gibt 3 Elemente des Arrays, die auf den Wert 0 initialisiert werden.

Zuweisen von Werten zu einem Array-Element

Werte können Array-Elementen auf die gleiche Weise neu zugewiesen werden, wie Array-Elemente initialisiert werden.

Das folgende Programm ist ein Beispiel für Werte, die verschiedenen Indexwerten eines vorhandenen Arrays zugewiesen werden können.

/* Main program */ 
list.1 = 0 
list.2 = 0 
list.3 = 0 

/* Assigning new values to the array*/ 
list.1 = 10 
list.3 = 30

Anzeigen der Werte eines Arrays

Die Werte eines Arrays können unter Bezugnahme auf die Indexposition des Array-Elements angezeigt werden. Das folgende Beispiel zeigt den Zugriff auf verschiedene Elemente des Arrays.

Example

/* Main program */ 
list.1 = 0 
list.2 = 0 
list.3 = 0 

/* Assigning new values to the array*/ 
list.1 = 10 
list.3 = 30 
say list.1 
say list.2 
say list.3

Die Ausgabe des obigen Programms wird wie folgt sein:

10
0
30

Arrays kopieren

Alle Elemente eines Arrays können auf ein anderes Array kopiert werden. Die allgemeine Syntax hierfür lautet wie folgt:

Newarray. = sourcearray.

Newarray - Dies ist das neue Array, in das die Elemente kopiert werden müssen.
Sourcearray - Dies ist das Quellarray, aus dem die Elemente kopiert werden müssen.

Ein Beispiel dafür, wie die Kopiervorgänge für Arrays ausgeführt werden können, ist im folgenden Programm dargestellt:

Example

/* Main program */ 
list.1 = 0 
list.2 = 0 
list.3 = 0 

/* Assigning new values to the array*/ 
list.1 = 10 
list.3 = 30 
listnew. = list. 

say listnew.1 
say listnew.2 
say listnew.3

Die Ausgabe des obigen Programms ist -

10
0
30

Durch Array-Elemente iterieren

Elemente eines Arrays können auch mithilfe der in Rexx verfügbaren iterativen Anweisungen iteriert werden. Ein Beispiel dafür ist wie folgt:

Example

/* Main program */ 
list.1 = 10 
list.2 = 20 
list.3 = 30 

number_of_elements = 3 
do j = 1 to number_of_elements 
say list.j 
end

Die folgenden Hinweise müssen zum obigen Programm beachtet werden:

Das do loop wird verwendet, um die Array-Elemente zu durchlaufen.
Die Variable number_of_elements wird verwendet, um die Anzahl der Elemente im Array zu speichern.
Das variable j wird verwendet, um jedes Element des Arrays zu durchlaufen.

Die Ausgabe des obigen Programms ist -

10
20
30

Zweidimensionale Arrays

Es wurde auch erwähnt, dass wir in Rexx mehrdimensionale Arrays erstellen können. Schauen wir uns ein Beispiel an, wie wir ein zweidimensionales Array implementieren können.

Example

/* Main program */ 
list.1 = 10 
list.1.1 = 11 
list.1.2 = 12 

say list.1 
say list.1.1 
say list.1.2

Die Ausgabe des obigen Programms wird wie folgt angezeigt:

10
11
12

Der folgende Punkt muss über das obige Programm beachtet werden:

Um ein mehrdimensionales Array zu erstellen, können wir eine andere Indizierungsebene verwenden. Also haben wir in unserem Beispiel verwendetlist.1.1 um ein weiteres inneres Array für den Indexwert 1 des Listenarrays zu erstellen.

Bisher haben wir Anweisungen gesehen, die nacheinander nacheinander ausgeführt wurden. Zusätzlich werden in Rexx Anweisungen bereitgestellt, um den Kontrollfluss in der Logik eines Programms zu ändern. Sie werden dann in einen Fluss von Kontrollanweisungen eingeteilt, die wir im Detail untersuchen werden.

Mit einer Schleifenanweisung können wir eine Anweisung oder eine Gruppe von Anweisungen mehrmals ausführen. Die folgende Abbildung ist die allgemeine Form einer Schleifenanweisung in den meisten Programmiersprachen.

Lassen Sie uns verschiedene von Rexx unterstützte Schleifen diskutieren.

Sr.Nr.	Schleifentyp & Beschreibung
1	do loop Das do loopwird verwendet, um eine Anzahl von Anweisungen für eine bestimmte Anzahl von Malen auszuführen. Die Häufigkeit, mit der die Anweisung ausgeführt werden muss, wird durch den an die do-Schleife übergebenen Wert bestimmt.
2	do-while-Schleife Die do-while-Anweisung wird verwendet, um die einfache while-Schleife zu simulieren, die in anderen Programmiersprachen vorhanden ist.
3	Do-Till-Schleife Die do-till-Schleife ist eine geringfügige Variation der do while-Schleife. Diese Schleife variiert in der Tatsache, dass sie beendet wird, wenn die zu bewertende Bedingung falsch ist.

Kontrollierte Wiederholung

Die do-Schleifen können für eine kontrollierte Wiederholung von Anweisungen vorgesehen werden.

Syntax

Die allgemeine Syntax dieser Art von Anweisung lautet wie folgt.

do index = start [to limit] [by increment] [for count] 
statement #1 
statement #2 
end

Der Unterschied in dieser Anweisung besteht darin, dass es einen Index gibt, mit dem gesteuert wird, wie oft die Schleife ausgeführt wird. Zweitens gibt es Parameter, die den Wert angeben, mit dem der Index beginnen soll, wo er enden soll und wie hoch der Inkrementwert ist.

Flussdiagramm

Schauen wir uns das Flussdiagramm dieser Schleife an -

Aus dem obigen Diagramm können Sie deutlich erkennen, dass die Schleife basierend auf dem Indexwert ausgeführt wird und wie der Indexwert erhöht wird.

Das folgende Programm ist ein Beispiel für die kontrollierte Wiederholungsanweisung.

Beispiel

/* Main program */ 
do i = 0 to 5 by 2 
   say "hello" 
end

Im obigen Programm ist der Wert des count iwird zuerst auf 0 gesetzt. Dann wird es in Zählungen von 2 erhöht, bis der Wert nicht größer als 5 ist.

Die Ausgabe des obigen Codes lautet -

hello 
hello 
hello

Entscheidungsstrukturen erfordern, dass der Programmierer eine oder mehrere Bedingungen angibt, die vom Programm bewertet oder getestet werden sollen.

Das folgende Diagramm zeigt die allgemeine Form einer typischen Entscheidungsstruktur, die in den meisten Programmiersprachen zu finden ist.

Es gibt eine Anweisung oder Anweisungen, die ausgeführt werden müssen, wenn die Bedingung bestimmt wird trueund optional andere Anweisungen, die ausgeführt werden sollen, wenn die Bedingung bestimmt wird false.

Schauen wir uns die verschiedenen Entscheidungserklärungen an, die in Rexx verfügbar sind.

Sr.Nr.	Aussage & Beschreibung
1	If-Anweisung Die erste Entscheidungserklärung ist die ifErklärung. Einif Anweisung besteht aus einem Booleschen Ausdruck, gefolgt von einer oder mehreren Anweisungen.
2	If-else-Anweisung Die nächste Entscheidungserklärung ist die if-else-Anweisung. Einif Auf die Anweisung kann eine optionale else-Anweisung folgen, die ausgeführt wird, wenn der Boolesche Ausdruck false ist.

Verschachtelte If-Anweisungen

Manchmal gibt es eine Anforderung zu haben multiple if statementsineinander eingebettet, wie es in anderen Programmiersprachen möglich ist. In Rexx ist dies ebenfalls möglich.

Syntax

if (condition1) then 
   do 
      #statement1 
   end 
else 
   if (condition2) then 
      do 
      #statement2 
   end

Flussdiagramm

Das Flussdiagramm von verschachtelt if Aussagen ist wie folgt -

Nehmen wir ein Beispiel für verschachtelt if Aussage -

Beispiel

/* Main program */ 
i = 50 
if (i < 10) then 
   do 
      say "i is less than 10" 
   end 
else 
if (i < 7) then 
   do 
      say "i is less than 7" 
   end 
else 
   do 
      say "i is greater than 10" 
   end

Die Ausgabe des obigen Programms ist -

i is greater than 10

Wählen Sie Anweisungen

Rexx bietet die select-Anweisung an, mit der Ausdrücke basierend auf der Ausgabe der select-Anweisung ausgeführt werden können.

Syntax

Die allgemeine Form dieser Aussage ist -

select 
when (condition#1) then 
statement#1 

when (condition#2) then 
statement#2 
otherwise 

defaultstatement 
end

Die allgemeine Funktionsweise dieser Aussage ist wie folgt:

Die select-Anweisung enthält eine Reihe von when-Anweisungen, um verschiedene Bedingungen zu bewerten.
Jeder when clause hat eine andere Bedingung, die ausgewertet werden muss und die nachfolgende Anweisung wird ausgeführt.
Die else-Anweisung wird verwendet, um eine Standardanweisung auszuführen, wenn die vorherigen Bedingungen dies nicht tun evaluate to true.

Flussdiagramm

Das Flussdiagramm der select Aussage ist wie folgt

Das folgende Programm ist ein Beispiel für die case-Anweisung in Rexx.

Beispiel

/* Main program */ 
i = 50 
select 
when(i <= 5) then 
say "i is less than 5" 

when(i <= 10) then 
say "i is less than 10" 

otherwise 
say "i is greater than 10" 
end

Die Ausgabe des obigen Programms wäre -

i is greater than 10

Rexx hat die folgenden Datentypen, wenn es um Zahlen geht.

Integer- Eine numerische Zeichenfolge, die keinen Dezimalpunkt oder Exponentenbezeichner enthält. Das erste Zeichen kann ein Pluszeichen (+) oder ein Minuszeichen (-) sein. Die dargestellte Nummer muss zwischen -2147483648 und 2147483647 einschließlich liegen.
Big Integer- Eine Zahlenfolge, die keinen Dezimalpunkt oder Exponentenbezeichner enthält. Das erste Zeichen kann ein Pluszeichen (+) oder ein Minuszeichen (-) sein. Die dargestellte Nummer muss zwischen -9223372036854775808 und 2147483648 einschließlich oder zwischen 2147483648 und 9223372036854775807 liegen.
Decimal - Eines der folgenden Formate -
- Eine numerische Zeichenfolge, die einen Dezimalpunkt, aber keine Exponenten-ID enthält p repräsentiert die Präzision und sstellt die Skala der Dezimalzahl dar, die die Zeichenfolge darstellt. Das erste Zeichen kann ein Pluszeichen (+) oder ein Minuszeichen (-) sein.
- Eine numerische Zeichenfolge, die keinen Dezimalpunkt oder Exponentenbezeichner enthält. Das erste Zeichen kann ein Pluszeichen (+) oder ein Minuszeichen (-) sein. Die dargestellte Zahl ist kleiner als -9223372036854775808 oder größer als 9223372036854775807.
Float- Eine Zeichenfolge, die eine Zahl in wissenschaftlicher Notation darstellt. Die Zeichenfolge besteht aus einer Reihe von Zahlen, gefolgt von einer Exponenten-ID (einem E oder e, gefolgt von einem optionalen Plus- (+) oder Minuszeichen (-) und einer Reihe von Zahlen). Die Zeichenfolge kann mit einem Pluszeichen (+) oder Minuszeichen (-) beginnen.

Schauen wir uns nun die verschiedenen an methods available for numbers.

Sr.Nr.	Für Zahlen verfügbare Methoden
1	Abs Diese Methode gibt den absoluten Wert einer eingegebenen Nummer zurück.
2	MAX Diese Methode gibt den Maximalwert aus einer Liste von Zahlen zurück.
3	MINDEST Diese Methode gibt den Mindestwert aus einer Liste von Zahlen zurück.
4	ZUFÄLLIG Diese Methode gibt eine zufällig generierte Zahl zurück.
5	ZEICHEN Gibt 1 zurück, wenn die Zahl größer als 0 ist, oder 0, wenn die Zahl 0 ist, oder -1, wenn die Zahl kleiner als 0 ist.
6	TRUNC Diese Methode schneidet eine Zahl ab.

Zeichenfolgen in Rexx werden durch eine Folge von Zeichen gekennzeichnet. Das folgende Programm ist ein Beispiel für Zeichenfolgen -

/* Main program */ 
a = "This is a string" 
say a

Die Ausgabe des obigen Programms ist wie folgt:

This is a string

Lassen Sie uns einige Methoden diskutieren, die in Rexx für Zeichenfolgen verfügbar sind.

Sr.Nr.	In Rexx für Strings verfügbare Methoden
1	links Diese Methode gibt eine bestimmte Anzahl von Zeichen links von der Zeichenfolge zurück.
2	Recht Diese Methode gibt eine bestimmte Anzahl von Zeichen rechts von der Zeichenfolge zurück.
3	Länge Diese Methode gibt die Anzahl der Zeichen in der Zeichenfolge zurück.
4	umkehren Diese Methode gibt die Zeichen in einem umgekehrten Format zurück.
5	vergleichen Sie Diese Methode vergleicht 2 Zeichenfolgen. Gibt "0" zurück, wenn "string1" und "string2" identisch sind. Andernfalls wird die Position des ersten Zeichens zurückgegeben, die nicht übereinstimmt.
6	Kopien Diese Methode kopiert a string n Anzahl.
7	substr Diese Methode ruft eine Teilzeichenfolge aus einer bestimmten Zeichenfolge ab.
8	pos Diese Methode gibt die Position einer Zeichenfolge innerhalb einer anderen zurück.
9	delstr Diese Methode löscht einen Teilstring aus einem String.

Der Code in Rexx ist normalerweise in Funktionen und Unterprogramme unterteilt. Die Verwendung von Funktionen hilft bei der Trennung des Codes in viel mehr logische Einheiten. Schauen wir uns diese Funktionen im Detail an.

Funktion definieren

Die Syntax einer Funktionsdeklaration lautet wie folgt:

FunctionName: 
PARSE ARG arguement1, arguement2… arguementN 
Return value

Wo,

FunctionName - Dies ist der der Funktion zugewiesene Name.
PARSE ARG - Dies sind Schlüsselwörter in Rexx, mit denen erwähnt wird, dass Parameter an die Funktion übergeben werden.
arguement1, arguement2… arguementN - Dies sind die Argumente, die an die Funktion übergeben werden.
Return value - Dies ist der von der Funktion zurückgegebene Wert.

Das folgende Programm ist ein einfaches Beispiel für die Verwendung von Funktionen in Rexx.

/* Main program */ 
say add(5,6) 
exit 
add: 
PARSE ARG a,b 
return a + b

Die folgenden Dinge sollten über das obige Programm beachtet werden -

Wir definieren eine Funktion namens add, die 2 Parameter a und b akzeptiert.
Die Funktion verwendet die return-Anweisung, um die Summe von a und b zurückzugeben.
Die exit-Anweisung muss verwendet werden, um das Ende des Hauptprogramms anzuzeigen.

Die Ausgabe des obigen Programms wäre wie folgt:

Mit Argumenten arbeiten

In Rexx gibt es bestimmte Funktionen, mit denen mit Argumenten gearbeitet werden kann. Schauen wir uns einige solcher Argumente an.

arg

Diese Methode wird verwendet, um die Anzahl der für die Funktion definierten Argumente zurückzugeben.

Syntax - -

arg()

Parameters - Keine

Return Value - Diese Methode gibt die Anzahl der für die Funktion definierten Argumente zurück.

Example - -

/* Main program */ 
say add(5,6) 
exit 
add: 
PARSE ARG a,b 

say arg() 
return a + b

Output - Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis.

2 
11

arg (Index)

Diese Methode wird verwendet, um den Wert des Arguments an der bestimmten Position zurückzugeben.

Syntax - -

arg(index)

Parameter - -

Index - Indexposition des zurückzugebenden Arguments.

Return Value - Diese Methode gibt den Wert des Arguments an der spezifischen Position zurück.

Example - -

/* Main program */ 
say add(5,6) 
exit 
add: 
PARSE ARG a,b 

say arg(1) 
return a + b

Output - Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis.

5 
11

Rekursive Funktionen

Eine rekursive Funktion oder Routine ruft sich selbst auf. Jede rekursive Funktion kann auf herkömmliche nicht rekursive Weise (oder iterativ) codiert werden, aber manchmal bietet die Rekursion eine bessere Problemlösung. Nicht alle Programmiersprachen unterstützen die Rekursion. Rexx tut es.

Sehen wir uns ein Beispiel für das berühmte Fakultätsprogramm mit rekursiven Funktionen in Rexx an.

/* Main program */ 
do n = 1 to 5 
say 'The factorial of' n 'is:' factorial( n ) 
end 
return  

/* Function to get factorial */ 
factorial : procedure 
n = arg(1) 
if n = 1 then 
return 1 
return n * factorial( n - 1 )

Die Ausgabe des obigen Programms ist wie folgt:

The factorial of 1 is: 1
The factorial of 2 is: 2 
The factorial of 3 is: 6 
The factorial of 3 is: 24 
The factorial of 3 is: 120

Der Stapel wird manchmal als externe Datenwarteschlange bezeichnet, aber wir folgen der allgemeinen Verwendung und bezeichnen ihn als Stapel. Es ist ein Speicherblock, der logisch außerhalb von Rexx liegt. Anweisungen wie Push und Queue platzieren Daten in den Stapel, und Anweisungen wie Pull und Parse Pull extrahieren Daten daraus. Die integrierte Funktion in der Warteschlange gibt an, wie viele Elemente sich im Stapel befinden.

Schauen wir uns ein Beispiel für einen Stapel an.

/* STACK: */
/* */ 
/* This program shows how to use the Rexx Stack as either a */ 

/* stack or a queue. */ 
do j = 1 to 3 
push ‘Stack: line #’ || j 

/* push 3 lines onto the stack */ 
end 
do j = 1 to queued() 

/* retrieve and display LIFO */ 
pull line 
say line 
end 
do j = 1 to 3 queue ‘Queue: line #’ || j 

/* queue 3 lines onto the stack */ 
end 
do queued() 

/* retrieve and display FIFO */ 
pull line 
say line 
end 
exit 0

Die erste do-Schleife im Programm platziert drei Datenzeilen auf dem Stapel. Dazu wird die Push-Anweisung verwendet. Wir nummerieren die Zeilen so, dass ihre Reihenfolge beim Abrufen in der LIFO-Reihenfolge ersichtlich ist.

Die durch die Push-Anweisung in den Stapel eingelegten Elemente werden in der LIFO-Reihenfolge abgerufen.

do j = 1 to 3 
push ‘Stack: line #’ || j     /* push 3 lines onto the stack */ 
end

Der nächste Codeblock zeigt die Verwendung der integrierten Funktion in der Warteschlange, um die Anzahl der Zeilen auf dem Stapel zu ermitteln, sowie eine Schleife, um alle Zeilen vom Stapel abzurufen.

do j = 1 to queued()    /* retrieve and display LIFO */ 
pull line 
say line 
end

Da die drei Elemente per Push auf den Stapel gelegt wurden, werden sie in der LIFO-Reihenfolge abgerufen.

Die Ausgabe des obigen Programms ist wie folgt.

STACK: LINE #3 
STACK: LINE #2 
STACK: LINE #1

Rexx bietet eine Reihe von Methoden für die Arbeit mit E / A. Rexx bietet einfachere Klassen, um die folgenden Funktionen für Dateien bereitzustellen.

Dateien lesen
Schreiben in Dateien
Überprüfen, ob eine Datei eine Datei oder ein Verzeichnis ist

Die in Rexx für Datei-E / A verfügbaren Funktionen basieren sowohl auf der Zeileneingabe als auch auf der Zeicheneingabe, und wir werden uns die für beide verfügbaren Funktionen im Detail ansehen.

Lassen Sie uns einige der Dateivorgänge untersuchen, die Rexx zu bieten hat. Für die Zwecke dieser Beispiele wird angenommen, dass eine Datei mit dem Namen vorhanden istNewFile.txt welches die folgenden Textzeilen enthält -

Example1

Example2

Example3

Diese Datei wird in den folgenden Beispielen für die Lese- und Schreibvorgänge verwendet. Hier werden wir diskutieren, wie der Inhalt einer Datei auf verschiedene Arten gelesen werden kann.

Lesen des Inhalts einer Datei zeilenweise

Die allgemeinen Operationen an Dateien werden mit den in der Rexx-Bibliothek selbst verfügbaren Methoden ausgeführt. Das Lesen von Dateien ist die einfachste aller Operationen in Rexx.

Schauen wir uns die Funktion an, mit der dies erreicht wurde.

linein

Diese Methode gibt eine Zeile aus der Textdatei zurück. Die Textdatei ist der Dateiname, der als Eingabeparameter für die Funktion bereitgestellt wird.

Syntax - -

linein(filename)

Parameter - -

filename - Dies ist der Name der Datei, aus der die Zeile gelesen werden muss.

Return Value - Diese Methode gibt jeweils eine Zeile der Datei zurück.

Example - -

/* Main program */ 
line_str = linein(Example.txt) 
say line_str

Der obige Code ist ziemlich einfach in der Tatsache, dass die Example.txtDer Dateiname wird der Linein-Funktion zur Verfügung gestellt. Diese Funktion liest dann eine Textzeile und liefert das Ergebnis an die Variableline_str.

Output - Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis.

Example1

Lesen des Inhalts einer Datei auf einmal

In Rexx kann das Lesen des gesamten Inhalts einer Datei mithilfe der while-Anweisung erreicht werden. Die while-Anweisung liest jede Zeile nacheinander, bis das Ende der Datei erreicht ist.

Ein Beispiel, wie dies erreicht werden kann, ist unten gezeigt.

/* Main program */ 
do while lines(Example.txt) > 0  
line_str = linein(Example.txt) 
say line_str 
end

Im obigen Programm müssen die folgenden Dinge beachtet werden:

Die Linienfunktion liest die Example.txt Datei.
Mit der while-Funktion wird überprüft, ob weitere Zeilen in der Datei Example.txt vorhanden sind.
Für jede aus der Datei gelesene Zeile wird die line_strVariable enthält den Wert der aktuellen Zeile. Dies wird dann als Ausgabe an die Konsole gesendet.

Output - Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis.

Example1 
Example2 
Example3

Schreiben von Inhalten in eine Datei

Genau wie das Lesen von Dateien kann Rexx auch in Dateien schreiben. Schauen wir uns die Funktion an, mit der dies erreicht wird.

Lineout

Diese Methode schreibt eine Zeile in eine Datei. Die Datei, in die die Zeile geschrieben werden soll, wird als Parameter für die Lineout-Anweisung bereitgestellt.

Syntax - -

lineout(filename)

Parameter - -

filename - Dies ist der Name der Datei, in die die Zeile geschrieben werden soll.

Return Value- Diese Methode gibt den Status der Lineout-Funktion zurück. Der zurückgegebene Wert ist 0, wenn die Zeile erfolgreich geschrieben wurde. Andernfalls wird der Wert 1 zurückgegeben.

Example - -

/* Main program */ 
out = lineout(Example.txt,"Example4")

Output - Immer wenn der obige Code ausgeführt wird, wird die Zeile "Beispiel4" in die Datei geschrieben Example.txt.

In diesem Kapitel werden einige der anderen Funktionen erläutert, die für Dateien verfügbar sind.

Sr.Nr.	Funktionen für Dateien
1	Linien Diese Funktion gibt entweder den Wert 1 oder die Anzahl der Zeilen zurück, die zum Einlesen eines Eingabestreams übrig sind. Der Dateiname wird als Eingabe für die Funktion angegeben.
2	Strom Mit dieser Funktion wird der Status einer Datei überprüft. Manchmal ist es erforderlich, den Status einer Datei zu überprüfen, bevor sie verwendet wird. Wenn die Datei beschädigt oder nicht verfügbar ist, können keine weiteren Vorgänge für die Datei ausgeführt werden. Daher ist es sinnvoller, zuerst den Status der Datei zu überprüfen.
3	charin Diese Funktion wird verwendet, um jeweils ein Zeichen aus einer Datei zu lesen. Manchmal müssen Programme Dateien zeichenweise lesen, und daher kann diese Funktion für diesen Zweck verwendet werden.
4	Zeichen Diese Funktion gibt entweder 1 oder die Anzahl der Zeichen zurück, die noch in die Datei selbst eingelesen werden müssen. Der Dateiname wird als Parameter für die Funktion angegeben.
5	charout Mit dieser Funktion wird jeweils ein Zeichen in eine Datei geschrieben. Der Dateiname wird als Parameter für die Funktion eingegeben.

In jeder Programmiersprache ist das gesamte Programm in logische Module unterteilt. Dies erleichtert das Schreiben von Code, der einfach gewartet werden kann. Dies ist eine Grundvoraussetzung für jede Programmiersprache.

In Rexx können Module mithilfe von Unterprogrammen und Funktionen geschrieben werden. Schauen wir uns die Unterprogramme im Detail an.

Unterprogramm definieren

Die Syntax einer Funktionsdeklaration lautet wie folgt:

FunctionName: 
   Statement#1 
   Statement#2 
   …. 
   Statement#N

Wo,

FunctionName - Dies ist der Name, der dem Unterprogramm zugewiesen ist.
Statement#1 .. Statement#N - Dies ist die Liste der Anweisungen, aus denen das Unterprogramm besteht.

Das folgende Programm ist ein einfaches Beispiel für die Verwendung von Unterprogrammen.

/* Main program */ 
call add 
exit 
add: 
a = 5 
b = 10 
c = a + b 
say c

Die folgenden Dinge sollten über das obige Programm beachtet werden -

Wir definieren eine Unterroutine namens add.
Das Unterprogramm führt eine einfache Funktion zum Hinzufügen aus.
Die exit-Anweisung muss verwendet werden, um das Ende des Hauptprogramms anzuzeigen.

Die Ausgabe des obigen Programms wäre wie folgt:

Mit Argumenten arbeiten

Es ist auch möglich, mit Argumenten in Rexx zu arbeiten. Das folgende Beispiel zeigt, wie dies erreicht werden kann.

/* Main program */ 
call add 1,2 
exit 
add: 
PARSE ARG a,b 
c = a + b 
say c

Die folgenden Dinge sollten über das obige Programm beachtet werden -

Wir definieren eine Unterroutine namens add, die 2 Parameter annimmt.
In den Unterprogrammen werden die beiden Parameter mit den Schlüsselwörtern PARSE und ARG analysiert.

Die Ausgabe des obigen Programms wäre wie folgt:

Verschiedene Methoden für Argumente

Schauen wir uns einige andere Methoden an, die für Argumente verfügbar sind.

arg

Diese Methode wird verwendet, um die Anzahl der für das Unterprogramm definierten Argumente zurückzugeben.

Syntax - -

arg()

Parameters - Keine

Return Value - Diese Methode gibt die Anzahl der für das Unterprogramm definierten Argumente zurück.

Example - -

/* Main program */ 
call add 1,2 
exit 
add: 
PARSE ARG a,b 

say arg() 
c = a + b 
say c

Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis.

2 
3

arg (Index)

Diese Methode wird verwendet, um den Wert des Arguments an der bestimmten Position zurückzugeben.

Syntax - -

arg(index)

Parameters

Index - Indexposition des zurückzugebenden Arguments.

Return Value - Diese Methode gibt den Wert des Arguments an der spezifischen Position zurück.

Example - -

/* Main program */ 
call add 1,2 
exit 
add: 
PARSE ARG a,b 

say arg(1) 
c = a + b 
say c

Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis.

1 
3

Jede Programmiersprache verfügt über einige integrierte Funktionen, die dem Programmierer bei Routineaufgaben helfen. Rexx hat auch viele eingebaute Funktionen.

Schauen wir uns all diese Funktionen an, die in Rexx verfügbar sind.

Sr.Nr.	In Rexx verfügbare Funktionen
1	ADRESSE Diese Methode gibt den Namen der Umgebung zurück, in der die Rexx-Befehle derzeit ausgeführt werden.
2	PIEP Diese Methode erzeugt einen Ton im System mit einer bestimmten Frequenz und Dauer.
3	Datentyp Diese Methode gibt den Wert von 'NUM' zurück, wenn die Eingabe eine gültige Zahl ist, andernfalls wird der Wert von 'CHAR' zurückgegeben. Sie können auch angeben, ob Sie den Eingabewert mit einem NUM- oder CHAR-Wert vergleichen möchten. In jedem Fall ist der zurückgegebene Wert je nach Ergebnis entweder 1 oder 0.
4	DATUM Diese Methode gibt das lokale Datum im folgenden Format zurück.
5	Ziffern Diese Methode gibt die aktuelle Einstellung von NUMERIC DIGITS zurück, wie sie im aktuellen System definiert ist.
6	FEHLERBEHEBUNG Diese Methode gibt die Rexx-Fehlermeldung zurück, die der Fehlernummer 'errorno' zugeordnet ist. Bitte beachten Sie, dass die Fehlernummer einen Wert zwischen 0 und 99 haben muss. Dies ist nützlich, wenn Ihr Programm einen Fehlercode zurückgegeben hat und Sie wissen möchten, was der Fehlercode bedeutet.
7	BILDEN Diese Methode gibt die aktuelle Einstellung von 'NUMERIC FORM' zurück, mit der mathematische Berechnungen auf dem System durchgeführt werden.
8	ZEIT Diese Methode gibt die Ortszeit im 24-Stunden-Format zurück, wie im folgenden Programm gezeigt.
9	BENUTZERIDENTIFIKATION Diese Methode gibt die aktuelle Benutzer-ID zurück, die im System angemeldet ist.
10	XRANGE Diese Methode gibt die Zeichen in dem durch das Start- und Endzeichen angegebenen Bereich zurück.
11	X2D Diese Methode gibt die Dezimalumrechnung von a zurück hexstring value.
12	X2C Diese Methode gibt die Zeichenkonvertierung eines Hexstring-Werts zurück.

Einer der größten Vorteile von Rexx ist die Möglichkeit, wiederverwendbare Skripte zu erstellen. Heutzutage ist es in Unternehmen häufig ein großer Mehrwert, wiederverwendbare Skripte zu haben, um Zeit für häufig wiederkehrende Aufgaben zu sparen.

Beispielsweise müssen Technologieteams in einer IT-Organisation möglicherweise über Skripte verfügen, die allgemeine Alltagsaufgaben ausführen. Diese Aufgaben können die Interaktion mit den Betriebssystemen umfassen. Diese Skripte können dann so programmiert werden, dass sie fehlerhafte Rückkehrcodes oder Fehler behandeln.

Rexx bietet viele Systembefehle, mit denen sich wiederholende Aufgaben ausführen können. Schauen wir uns einige der in Rexx verfügbaren Systembefehle an.

dir

Dies ist der normale Verzeichnislistenbefehl, der in Windows verwendet wird.

Syntax

dir

Parameter

Keiner

Rückgabewert

Diese Methode gibt die aktuelle Verzeichnisliste auf dem System zurück.

Beispiel

/* Main program */ 
dir

Die Ausgabe hängt vom Verzeichnis im System ab.

Das folgende Programm ist nur ein Beispiel.

Ausgabe

Volume in drive D is LENOVO 
Volume Serial Number is BAC9-9E3F  
Directory of D:\ 
04/06/2016  12:52 AM           268,205 100008676689.pdf 
10/20/2015  08:51 PM    <DIR>          data 
06/01/2016  10:23 AM                31 Example.txt 
10/28/2014  06:55 PM    <DIR>          Intel 
06/02/2016  11:15 AM                23 main.rexx 
12/22/2014  08:49 AM    <DIR>          PerfLogs  
12/13/2015  11:45 PM    <DIR>          Program Files 
12/24/2015  10:26 AM    <DIR>          Program Files (x86) 
07/17/2015  01:21 AM    <DIR>          Users 
12/23/2015  10:01 AM    <DIR>          Windows 
               3 File(s)        268,259 bytes 
               7 Dir(s)     202,567,680 bytes free

Ein weiteres Beispiel für die dir commandwird im folgenden Programm gezeigt. Nur dieses Mal nutzen wir diespecial rc variable. Diese Variable ist in Rexx speziell und gibt Ihnen den Status der Ausführung von Systembefehlen. Wenn der zurückgegebene Wert 0 ist, bedeutet dies, dass der Befehl erfolgreich ausgeführt wurde. Andernfalls wird die Fehlernummer im Namen der RC-Variablen angegeben.

Beispiel

/* Main program */ 
dir 
if rc = 0 then 
   say 'The command executed successfully' 
else 
   say 'The command failed, The error code is =' rc

Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis.

Ausgabe

The command failed, The error code is = 127

Umleitungsbefehle

Rexx hat auch die Möglichkeit, Umleitungsbefehle zu verwenden. Die folgenden Umleitungsbefehle sind in Rexx verfügbar.

< - Mit diesem Befehl wird die Eingabe aufgenommen, die aus einer Datei stammt.
>- Mit diesem Befehl wird der Inhalt in eine Datei ausgegeben. Wenn die Datei vorhanden ist, wird sie überschrieben.
>>- Dies wird auch verwendet, um den Inhalt in eine Datei auszugeben. Die Ausgabe wird jedoch am Ende der Datei hinzugefügt, um den vorhandenen Inhalt der Datei beizubehalten.

Schauen wir uns ein Beispiel an, wie wir Umleitungsbefehle verwenden können. Im folgenden Beispiel verwenden wir den Befehl sort, um eine aufgerufene Datei zu sortierensortin.txt. Die Daten aus der Datei werden an den Sortierbefehl gesendet. Die Ausgabe des Befehls sort wird dann an die Datei sortout.txt gesendet.

Beispiel

/* Main program */ 
'sort <sortin.txt> sortout.txt'

Angenommen, die Datei sortin.txt enthält die folgenden Daten.

Ausgabe

b 
c 
a

Die Datei sortout.txt wird dann die folgenden Daten haben.

a 
b 
c

Die ADRESS-Funktion

Diese Methode wird verwendet, um herauszufinden, welche Standardumgebung für die Eingabe-, Fehler- und Ausgabestreams verwendet wird.

Syntax

ADDRESS(options)

Parameter

Optionen für die Adresse eines bestimmten Systems.

Rückgabewert

Diese Methode gibt den Namen der Umgebung für die Streams Input, Error und Output zurück.

Beispiel

/* Main program */ 
say ADDRESS('I') 
say ADDRESS('O') 
say ADDRESS('E')

Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis.

Ausgabe

INPUT NORMAL 
REPLACE NORMAL 
REPLACE NORMAL

XML ist eine tragbare Open-Source-Sprache, mit der Programmierer Anwendungen entwickeln können, die von anderen Anwendungen gelesen werden können, unabhängig vom Betriebssystem und / oder der Entwicklungssprache. Dies ist eine der am häufigsten verwendeten Sprachen für den Datenaustausch zwischen Anwendungen.

Was ist XML?

Die XML-Erweiterungssprache ist eine Auszeichnungssprache, die HTML oder SGML sehr ähnlich ist. Dies wird vom World Wide Web Consortium empfohlen und ist als offener Standard verfügbar. XML ist äußerst nützlich, um kleine bis mittlere Datenmengen zu verfolgen, ohne ein SQL-basiertes Backbone zu benötigen.

Verwenden wir für alle unsere XML-Codebeispiele die folgende einfache XML-Datei movies.xml zum Erstellen der XML-Datei und zum anschließenden Lesen der Datei.

<collection shelf = "New Arrivals"> 
   <movie title = "Enemy Behind"> 
      <type>War, Thriller</type> 
      <format>DVD</format> 
      <year>2003</year> 
      <rating>PG</rating> 
      <stars>10</stars> 
      <description>Talk about a US-Japan war</description> 
   </movie> 
   
   <movie title = "Transformers"> 
      <type>Anime, Science Fiction</type> 
      <format>DVD</format> 
      <year>1989</year> 
      <rating>R</rating> 
      <stars>8</stars> 
      <description>A schientific fiction</description> 
   </movie> 
   
   <movie title = "Trigun"> 
      <type>Anime, Action</type> 
      <format>DVD</format> 
      <year>1986</year> 
      <rating>PG</rating> 
      <stars>10</stars> 
      <description>Vash the Stam pede!</description> 
   </movie> 
   
   <movie title = "Ishtar"> 
      <type>Comedy</type> 
      <format>VHS</format> 
      <year>1987</year> 
      <rating>PG</rating> 
      <stars>2</stars> 
      <description>Viewable boredom </description> 
   </movie> 
</collection>

Anfangen

Standardmäßig ist die XML-Funktionalität nicht im Rexx-Interpreter enthalten. Um mit XML in Rexx arbeiten zu können, müssen die folgenden Schritte ausgeführt werden.

Laden Sie die folgenden Dateien herunter -
- Rexxxml - www.interlog.com/~ptjm/
- Libxml2 - www.ctindustries.net/libxml/
- iconv-1.9.2.win32 - www.xmlsoft.org/sources/win32/oldreleases/
- libxslt-1.1.26.win32 - www.xmlsoft.org/sources/win32/oldreleases/
Extrahieren Sie alle Dateien und stellen Sie sicher, dass sie im Systempfad enthalten sind.

Laden von XML-Funktionen

Nachdem alle Dateien im obigen Abschnitt heruntergeladen und erfolgreich registriert wurden, besteht der nächste Schritt darin, den Code zum Laden der Rexx-XML-Funktionen zu schreiben. Dies erfolgt mit dem folgenden Code.

rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs') 

if rcc then do 
   say rxfuncerrmsg() 
   exit 1 
end 
call xmlloadfuncs

Die folgenden Dinge können über das obige Programm bemerkt werden -

Die Funktion rxfuncaddwird zum Laden externer Bibliotheken verwendet. Dasxmlloadfuncs Funktion wird verwendet, um alle Bibliotheken in der zu laden rexxxml Datei in den Speicher.
Wenn der Wert von rcc <> 0 ist, würde dies zu einem Fehler führen. Dafür können wir die anrufenrxfuncerrmsg um uns weitere Details zur Fehlermeldung zu geben.
Wir rufen endlich an xmlloadfuncs, sodass jetzt alle XML-bezogenen Funktionen im Rexx-Programm aktiviert werden können.

Schauen wir uns die verschiedenen an methods available for XML in Rexx.

xmlVersion

Diese Methode gibt die Version der auf dem System verwendeten XML- und XSLT-Bibliotheken zurück.

Syntax

xmlVersion()

Parameter

Keiner

Rückgabewert

Diese Methode gibt die Version der auf dem System verwendeten XML- und XSLT-Bibliotheken zurück.

Beispiel

rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs') 

if rcc then do 
   say rxfuncerrmsg() 
   exit 1 
end 
call xmlloadfuncs 
say xmlVersion()

Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis. Dies hängt wiederum von der Version der XML-Bibliotheken ab, die auf dem System verwendet werden.

Ausgabe

1.0.0 20631 10126

xmlParseXML

Diese Funktion wird verwendet, um die an die Funktion gesendeten XML-Daten zu analysieren. Der Dokumentbaum wird von der Funktion zurückgegeben.

Syntax

xmlParseXML(filename)

Parameter

Filename - Dies ist der Name der XML-Datei, die analysiert werden muss.

Rückgabewert

Der Dokumentbaum wird von der Funktion zurückgegeben. Andernfalls wird 0 zurückgegeben, wenn ein Fehler vorliegt.

Beispiel

rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs') 

if rcc then do 
   say rxfuncerrmsg() 
   exit 1 
end 
call xmlloadfuncs 

say xmlVersion() 
sw = xmlParseXML('test.xml')

Ausgabe

Keine allgemeine Ausgabe.

xmlFindNode

Diese Methode wertet die aus XPath expressionan ihn weitergegeben. Dies wird zum Parsen des Dokumentbaums verwendet, um a zu erhaltennodeset die weiter verarbeitet werden kann.

Syntax

xmlParseXML(XPath,document)

Parameter

XPath - Dies ist der Pfad des Knotens in der XML-Datei.
document - Dies ist das XML-Dokument

Rückgabewert

Wertet den XPath-Ausdruck aus und gibt das Ergebnis als Knotensatz zurück, der später verwendet werden kann.

Beispiel

rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs') 

if rcc then do 
   say rxfuncerrmsg() 
   exit 1 
end 
call xmlloadfuncs

say xmlVersion() 
document = xmlParseXML('test.xml') 
nodeset = xmlFindNode('//movie', document) 
say xmlNodesetCount(nodeset)

Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis.

Ausgabe

Die Ausgabe zeigt die Anzahl der Filmknoten in unserer XML-Liste

xmlEvalExpression

Die folgende Methode wird verwendet, um einen XPath-Ausdruck auszuwerten und als Ergebnis eine Zeichenfolge zurückzugeben.

Syntax

xmlParseXML(XPath,Node)

Parameter

XPath - Dies ist der Pfad des Knotens in der XML-Datei.
document - Das spezifische Knotenelement.

Rückgabewert

Eine Zeichenfolge wird basierend auf dem an sie gesendeten XPath-Ausdruck zurückgegeben.

Beispiel

rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs') 

if rcc then do 
   say rxfuncerrmsg() 
   exit 1 
end 
call xmlloadfuncs 

document = xmlParseXML('test.xml') 
nodeset = xmlFindNode('//movie', document) 
do j = 1 to xmlNodesetCount(nodeset) 
value = xmlEvalExpression('type', xmlNodesetItem(nodeset, j)) 
say value 
end

Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis.

Ausgabe

War, Thriller 
Anime, Science Fiction 
Anime, Action 
Comedy

Regina ist ein weiterer Rexx-Interpreter, mit dem Rexx-Programme kompiliert und ausgeführt werden können. Die offizielle Seite für Regina ist - www.regina-rexx.sourceforge.net/

Einige der Vorteile der Verwendung von Regina sind folgende:

Regina kann auf jeder Plattform ausgeführt werden, egal ob Windows, Linux oder Mac OS.
Regina arbeitet nach allen verfügbaren Standards.
Regina hat eine große Community und daher stehen Regina viele Foren und Lernmaterialien zur Verfügung.
Regina verfügt über viele Tools zum Schreiben und Testen von Rexx-Programmen.
In Regina können Sie Befehle ausführen, die im Standard-Rexx-Interpreter nicht möglich sind. Wenn Sie beispielsweise bestimmte Konfigurationseinstellungen angeben, können Sie grundlegende Befehle auf Systemebene ausführen, was in Rexx nicht möglich ist.

Wenn Sie Rexx über die in dokumentierte Installation installieren Chapter 2 – Rexx Environmentwird der Regina-Interpreter mit installiert.

Schauen wir uns nun einige der gängigen Methoden an, die bei der Verwendung von Regina verfügbar sind. Diese Funktionen sind die erweiterten Funktionen, die bei normalem Gebrauch nicht verfügbar sind.

Um die erweiterten Funktionen nutzen zu können, müssen Sie die folgende Codezeile einfügen. Dies ermöglicht die Verwendung erweiterter Regina-Funktionen.

options arexx_bifs

Verwenden Sie zweitens den folgenden Befehl, während Sie alle Rexx-Programme ausführen.

regina main.rexx

Where,

regina - Dies ist der Interpreter, der für Rexx-Programme verwendet wird.
main.rexx - Ihr Rexx-Programm.

Wir werden nun die verschiedenen im Detail diskutieren functions of Regina Rexx Interpreter.

Sr.Nr.	Funktionen von Regina Rexx Interpreter
1	b2c Diese Methode wird verwendet, um einen Binärwert in einen Zeichenfolgenwert umzuwandeln.
2	bitcomp Die Methode wird verwendet, um 2-Bit-Zeichenfolgen Stück für Stück zu vergleichen.
3	bittst Diese Methode wird verwendet, um den Status des angegebenen Bits in der Bitfolge anzuzeigen.
4	finden Diese Methode wird verwendet, um nach dem ersten Auftreten einer Zeichenfolge in einer anderen Zeichenfolge zu suchen.
5	getenv Diese Methode gibt den Wert einer Umgebungsvariablen auf dem System zurück.
6	getpid Diese Methode wird verwendet, um den Wert der aktuell ausgeführten Prozess-ID abzurufen.
7	Hash Diese Methode gibt das Hash-Attribut einer Zeichenfolge als Dezimalzahl zurück. Außerdem wird der interne Hashwert der Zeichenfolge aktualisiert.
8	rechtfertigen Diese Methode wird verwendet, um den Wert einer Zeichenfolge basierend auf dem Längenwert zu begründen oder zu kürzen.
9	putenv Diese Methode wird verwendet, um den Wert einer Umgebungsvariablen festzulegen.
10	Verzeichnis Diese Methode ruft den Wert des aktuellen Verzeichnisses auf dem System ab.
11	chdir Diese Methode ändert den Wert des aktuellen Arbeitsverzeichnisses auf dem System.
12	Randu Diese Methode gibt eine Pseudozufallszahl zwischen 0 und 1 zurück.

Eine der leistungsstärksten Funktionen von Rexx ist die Fähigkeit, Textwerte zu analysieren. Sie werden dies wahrscheinlich in keiner anderen Programmiersprache sehen.

Das allgemeine Format der Parse-Anweisung lautet wie folgt:

Syntax

PARSE {UPPER|LOWER|CASELESS} source {template}

Where,

UPPER - Die Quelle wird vor dem Parsen in Großbuchstaben konvertiert.
LOWER - Die Quelle wird vor dem Parsen in Kleinbuchstaben konvertiert.
CASELESS - Wenn dieser Parameter übergeben wird, wird das Gehäuse ignoriert.
source- Dies ist die Quelle, die analysiert werden muss. Hierfür stehen viele Optionen zur Verfügung, die eine der folgenden sein können:
- ARG - Die Argumente für das Programm oder die Prozedur können als Quelle verwendet werden.
- LINEIN - Der nächste Zeileneingang kann als Quelle verwendet werden.
- SOURCE - Die Quellinformationen des Programms können als Quelle verwendet werden.
- VAR name - Der Wert eines Variablennamens kann als Quelle verwendet werden.
template- Dieser Parameter gibt an, wie die Quelle analysiert werden soll. Hierfür stehen viele Optionen zur Verfügung. Einige von ihnen sind unten erwähnt.
- variable name - Dies ist der der Variablen zugewiesene Wert.
- literal string - Eine wörtliche Zeichenfolge, mit der ein Muster zum Teilen der Zeichenfolge verwendet werden kann.
- #- Eine absolute Zeichenposition innerhalb der Quelle. Wenn Sie also einen Wert von 5 angeben, wird das 5 - ^ten Zeichen verwendet werden.
- +#- Eine relative Zeichenposition innerhalb der Quelle. Wenn Sie also einen Wert von 5 angeben, die 5 ^th Charakter relativ verwendet werden.

Schauen wir uns ein einfaches Beispiel an, wie das Parsen in Rexx durchgeführt werden kann.

Beispiel

/* Main program */ 
parse value 'This is a Tutorial' with word1 word2 word3 word4 
say "'"word1"'" 
say "'"word2"'" 
say "'"word3"'" 
say "'"word4"'"

Das obige Programm analysiert die Wörter in der Phrase. Wenn ein Wert aus Wörtern besteht, die nur durch ein Leerzeichen getrennt sind und keine führenden oder nachfolgenden Leerzeichen vorhanden sind, kann der Wert wie folgt leicht in eine bekannte Anzahl von Wörtern analysiert werden.

Die Analysefunktion wird in Rexx verwendet, um einen Zeichenfolgenwert zu nehmen und ihn dann in Wörter zu zerlegen. Im obigen Beispiel werden die Wörter dann aufgeteilt und dann in den Wortvariablen gespeichert.

Die Ausgabe des obigen Programms wäre wie folgt:

'This' 
'is' 
'a' 
'Tutorial'

Ein weiteres Beispiel für das Parsen wird im folgenden Programm gezeigt. Dieses Mal verwenden wir eine while-Klausel, um das Parsen durchzuführen.

Beispiel

/* Main program */ 
phrase = 'This is a Tutorial' 

do while phrase <> '' 
   parse var phrase word phrase 
   say "'"word"'" 
   end

Das obige Programm gibt die folgende Ausgabe aus -

'This' 
'is' 
'a' 
'Tutorial'

Positionsanalyse

Mit Rexx kann man auch mit Positionsanalyse arbeiten. Sehen wir uns ein Beispiel an, wie wir mit der parse-Anweisung eine Positionsanalyse erreichen können.

Beispiel

/* Main program */ 
testString = "Doe       John M.   03/03/78  Mumbai              India"; 
parse var testString name1 11 name2 21 birthday 31 town 51 country 
say name1 
say name2 
say birthday 
say town 
say country

Aus dem obigen Beispiel können Sie ersehen, dass wir neben dem Variablennamen auch angeben, wo die Zeichenfolge enden soll. Für name1 sollten wir also mit dem 11. Zeichen enden und dann mit dem Parsen von name2 beginnen.

Die Ausgabe des obigen Programms wird wie folgt sein:

Doe 
John M. 
03/03/78 
Mumbai 
India

Sie können auch verwenden relative positional parsing in diesem Fall.

Beispiel

/* Main program */ 
testString = "Doe       John M.   03/03/78  Mumbai              India"; 
parse var testString name1 +10 name2 +10 birthday +10 town +20 country 
say name1 
say name2 
say birthday 
say town 
say country

Die Ausgabe des obigen Programms erfolgt wie unten gezeigt.

Doe 
John M. 
03/03/78 
Mumbai 
India

In Rexx wird der Signalbefehl im Allgemeinen für zwei Zwecke verwendet:

Eine besteht darin, die Kontrolle auf einen anderen Teil des Programms zu übertragen. Dies entspricht normalerweise dem Go-to-Label, das in anderen Programmiersprachen verwendet wird.
Das andere ist, zu einem bestimmten Trap-Label zu gehen.

Wenn der Signalbefehl in einem der folgenden Befehlsbefehle verwendet wird, werden die anstehenden Steuerstrukturen automatisch deaktiviert.

wenn ... dann ... sonst ...
tun ... enden
do i = 1 bis n ... end [und ähnliche do-Schleifen]
Wählen Sie wann ... dann ... ... usw. sonst ... ende

Die allgemeine Syntax der Signalanweisung wird wie folgt angezeigt:

Syntax

signal labelName  
   
signal [ VALUE ] labelExpression

Schauen wir uns ein Beispiel für die Verwendung der Signalanweisung an.

Beispiel

/* Main program */ 
n = 100.45 

if \ datatype( n, wholenumber ) then 
   signal msg 
   say 'This is a whole number' 
   return 0 
msg : 
   say 'This is an incorrect number'

Die Ausgabe des obigen Programms erfolgt wie unten gezeigt.

Ausgabe

This is an incorrect number.

Wenn Sie den Wert der Variablen n in eine ganze Zahl ändern, wie im folgenden Programm gezeigt -

/* Main program */ 
n = 100 

if \ datatype( n, wholenumber ) then 
   signal msg 
   say ' This is a whole number ' 
   return 0 
msg : 
   say ' This is an incorrect number '

Sie erhalten folgende Ausgabe:

This is a whole number

Man kann auch auf den Wert des Etiketts übertragen, wie im folgenden Programm gezeigt -

/* Main program */ 
n = 1 

if \ datatype( n, wholenumber ) then 
   signal msg 

if n < 1 | n > 3 then 
   signal msg  
   signal value n 
   3 : say 'This is the number 3' 
   2 : say ' This is the number 2' 
   1 : say ' This is the number 1' 
   return n 
msg : 
   say ' This is an incorrect number ' 
   exit 99

Die Ausgabe des obigen Programms wird wie folgt angezeigt:

This is the number 1

Aktivierung / Deaktivierung der Trap-Label-Übertragung

Wie bereits erwähnt, kann der Signalbefehl auch verwendet werden, um die Steuerung auf ein Trap-Label zu übertragen.

Die allgemeine Syntax der Trap-Label-Übertragung lautet wie folgt:

Syntax

signal ON conditionName [ NAME Label ] 
  
signal OFF conditionName

Wo,

conditionName - Dies ist der Zustand, für den das Signal entweder ein- oder ausgeschaltet werden soll.
Label - Die optionale Bezeichnung, auf die das Programm umgeleitet werden soll.

Sehen wir uns ein Beispiel für die Verwendung einer Trap-Label-Übertragung an.

Beispiel

/* Main program */ 
signal on error 
signal on failure 
signal on syntax 
signal on novalue 
beep(1) 
signal off error 
signal off failure 
signal off syntax 
signal off novalue 
exit 0 
error: failure: syntax: novalue: 
say 'An error has occured'

Im obigen Beispiel schalten wir zuerst die Fehlersignale ein. Wir fügen dann eine Anweisung hinzu, die zu einem Fehler führt. Wir haben dann das Fehlerfallen-Label, um eine benutzerdefinierte Fehlermeldung anzuzeigen.

Die Ausgabe des obigen Programms erfolgt wie folgt:

An error has occurred.

Das Debuggen ist eine wichtige Funktion in jeder Programmiersprache. Es hilft dem Entwickler, Fehler zu diagnostizieren, die Grundursache zu finden und sie dann entsprechend zu beheben. In Rexx wird das Trace-Dienstprogramm zum Debuggen verwendet. Der Trace-Befehl kann auf zwei Arten implementiert werden: der Batch-Modus und der interaktive Modus. Schauen wir uns an, wie beide Optionen implementiert werden.

Trace im Batch-Modus

Der Befehl trace wird verwendet, um eine detaillierte Ebene jedes ausgeführten Rexx-Befehls anzugeben.

Die allgemeine Syntax der Trace-Anweisung wird wie folgt angezeigt:

Syntax

trace [setting]

Wo die Einstellung eine der folgenden Optionen sein kann -

A - Verfolgt alle Befehle.
C - Verfolgt nur die Host-Befehle, die an das Betriebssystem gesendet werden.
E - Verfolgt nur die Host-Befehle, die an das Betriebssystem gesendet wurden und zu einem Fehler geführt haben.
F - Verfolgt nur die Host-Befehle, die an das Betriebssystem gesendet wurden und zu einem Fehler geführt haben.
I - Dies bietet eine Zwischenverfolgung von Rexx-Befehlen auf mittlerer Ebene.
L - Diese Option ist verfügbar, wenn Sie die Ablaufverfolgung während des Vorgangs kennzeichnen möchten.
N - Dies ist die Standardoption, bei der keine Ablaufverfolgung erfolgt.

Schauen wir uns ein Beispiel für den Befehl trace an.

Beispiel

/* Main program */ 
trace A 

/* Main program */ 
n = 100.45 if datatype( n, wholenumber ) then signal msg 

say 'This is a whole number' 
return 0 

msg : 
   say ' This is an incorrect number '

Die Ausgabe des obigen Programms wird wie folgt sein:

5 *-* n = 100.45 if datatype( n, wholenumber ) then signal msg
   7 *-* say 'This is a whole number
This is a whole number                                                   
   8 *-* return 0

An der Ausgabe können Sie erkennen, dass der Ausgabe des Programms eine zusätzliche Ablaufverfolgung hinzugefügt wurde. Die folgenden Dinge können über die Ausgabe bemerkt werden -

Die Zeilennummer wird zusammen mit der ausgeführten Anweisung zur Trace-Ausgabe hinzugefügt.
Jede Zeile, die ausgeführt wird, wird in der Trace-Ausgabe angezeigt.

Trace-Funktion

Trace kann auch mit Hilfe der Trace-Funktion aktiviert werden. Die allgemeine Syntax und das Beispiel sind unten aufgeführt.

Syntax

trace()

Die obige Funktion gibt den aktuellen Trace-Level zurück.

Parameter

Keiner

Rückgabewert

Die obige Funktion gibt den aktuellen Trace-Level an.

Beispiel

/* Main program */ 
say trace() 

/* Main program */ 
n = 100.45 if datatype( n, wholenumber ) then signal msg 

say 'This is a whole number' 
return 0 
msg : 

say 'This is an incorrect number '

Die Ausgabe des obigen Programms ist wie folgt.

N 
This is an incorrect number

Die erste Zeile von N zeigt an, dass die Kurve auf Normal gesetzt ist.

Trace-Wert einstellen

Der Trace-Level kann mit der Trace-Funktion eingestellt werden. Die allgemeine Syntax und das Beispiel sind unten aufgeführt.

Syntax

trace(travel_level)

Parameter

trace_level - Dies ähnelt den verfügbaren Optionen zum Einstellen der Ablaufverfolgungsstufe.

Rückgabewert

Die obige Funktion gibt den aktuellen Trace-Level an.

Beispiel

/* Main program */ 
say trace() 
current_trace = trace('A') 
say current_trace 

/* Main program */ 
n = 100.45 if datatype( n, wholenumber ) then 
signal msg say 'This is a whole number' 
return 0 
msg : 
say ' This is an incorrect number '

Die Ausgabe des obigen Programms wird wie folgt sein:

N 
   4 *-* say current_trace 
N 
   6 *-* n = 100.45 
   7 *-* if \ datatype( n, wholenumber ) then 
   8 *-* signal msg 
   12 *-* say 'This is an incorrect number' 
'This is an incorrect number'

Interaktive Verfolgung

Bei der interaktiven Ablaufverfolgung wird die Ablaufverfolgung während der Programmausführung ausgeführt. Genau wie in einer IDE wie Visual Studio für .Net, in der Sie Haltepunkte hinzufügen und sehen können, wie jede Anweisung ausgeführt wird, können Sie auch hier das Programm sehen, während jede Codezeile ausgeführt wird.

Die allgemeine Syntax lautet wie folgt:

Syntax

trace ?options

Dabei sind die Optionen für den Trace-Befehl dieselben wie unten gezeigt.

A - Verfolgt alle Befehle
C - Verfolgt nur die Host-Befehle, die an das Betriebssystem gesendet werden.
E - Verfolgt nur die Host-Befehle, die an das Betriebssystem gesendet wurden und zu einem Fehler geführt haben.
F - Verfolgt nur die Host-Befehle, die an das Betriebssystem gesendet wurden und zu einem Fehler geführt haben.
I - Dies bietet eine Zwischenverfolgung von Rexx-Befehlen auf mittlerer Ebene.
L - Diese Option ist verfügbar, wenn Sie die Ablaufverfolgung während des Vorgangs kennzeichnen möchten.
N - Dies ist die Standardoption, bei der keine Ablaufverfolgung erfolgt.

Schauen wir uns ein Beispiel für die Implementierung der aktiven Ablaufverfolgung an.

Beispiel

/* Main program */ 
trace ?A

/* Main program */ 
n = 100.45 if datatype( n, wholenumber ) then 
signal msg 

say 'This is a whole number' 
return 0 
msg : say 'This is an incorrect number'

Die Ausgabe des obigen Programms erfolgt wie im folgenden Programm gezeigt. Die Ablaufverfolgung stoppt in jeder Codezeile. Dann müssen Sie die Eingabetaste drücken, um zur nächsten Codezeile zu gelangen.

This is an incorrect number
       +++ "LINUX COMMAND /home/cg/root/5798511/main.rex"
     5 *-* n = 100.45 if datatype( n, wholenumber ) then 
+++ Interactive trace. "Trace Off" to end debug, ENTER to Continue. +++
     6 *-* signal msg 
    10 *-* msg :
    10 *-* say 'This is an incorrect number'

Rexx kann auch wie in anderen Programmiersprachen an der Fehlerbehandlung arbeiten.

Im Folgenden sind einige der verschiedenen Fehlerbedingungen aufgeführt, die in Rexx auftreten.

ERROR - Dies wird sogar ausgelöst, wenn ein Befehl, der an das Betriebssystem gesendet wird, zu einem Fehler führt.
FAILURE - Dies wird sogar ausgelöst, wenn ein Befehl, der an das Betriebssystem gesendet wird, zu einem Fehler führt.
HALT- Dies wird normalerweise ausgelöst, wenn eine Operation von einer anderen Operation abhängig ist. Ein Beispiel ist, wenn eine E / A-Operation aus irgendeinem Grund angehalten wird.
NOVALUE - Dieses Ereignis wird ausgelöst, wenn einer Variablen kein Wert zugewiesen wurde.
NOTREADY - Dies wird von jedem E / A-Gerät ausgelöst, das nicht bereit ist, eine Operation zu akzeptieren.
SYNTAX - Dieses Ereignis wird ausgelöst, wenn der Code einen Syntaxfehler enthält.
LOSTDIGITS - Dieses Ereignis wird ausgelöst, wenn eine arithmetische Operation zu einem Ziffernverlust während der Operation führt.

Fehler einfangen

Fehler werden mit Hilfe des Signalbefehls abgefangen. Schauen wir uns die Syntax und ein Beispiel dafür an.

Syntax

signal on [Errorcondition]

Wo,

Errorcondition - Dies ist die oben angegebene Fehlerbedingung.

Beispiel

Schauen wir uns dazu ein Beispiel an.

/* Main program */ 
signal on error 
signal on failure 
signal on syntax 
signal on novalue beep(1) 
signal off error 
signal off failure
signal off syntax 
signal off novalue 
exit 0 
error: failure: syntax: novalue: 
say 'An error has occured'

Die Ausgabe des obigen Programms erfolgt wie unten gezeigt.

An error has occurred.

Ein Beispiel für Fehlercodes wird im folgenden Programm gezeigt.

/* Main program */ 
signal on error 
signal on failure 
signal on syntax 
signal on novalue beep(1) 
exit 0 
error: failure: syntax: novalue: 

say 'An error has occured' 
say rc 
say sigl

Die Ausgabe des obigen Programms erfolgt wie unten gezeigt.

An error has occured 
40 
6

Wenn Sie ooRexx gemäß dem Kapitel "Umgebung" installieren, können Sie auch mit Klassen und Objekten arbeiten. Bitte beachten Sie, dass der gesamte folgende Code im ooRexx-Interpreter ausgeführt werden muss. Der normale Rexx-Interpreter kann diesen objektorientierten Code nicht ausführen.

Klassen- und Methodenerklärungen

Eine Klasse wird mit der folgenden Syntaxdeklaration definiert.

Syntax

::class classname

wo classname ist der Name der Klasse.

Eine Methode in einer Klasse wird mit der folgenden Syntaxdeklaration definiert.

Syntax

::method methodname

Wo methodname ist der Name der Methode.

Eine Eigenschaft in einer Klasse wird mit der folgenden Syntaxdeklaration definiert.

Syntax

::attribute propertyname

Wo propertyname ist der Name der Eigenschaft.

Beispiel

Das Folgende ist ein Beispiel für eine Klasse in Rexx.

::class student 
::attribute StudentID 
::attribute StudentName

Die folgenden Punkte müssen zum obigen Programm beachtet werden.

Der Name der Klasse ist Student.
Die Klasse hat zwei Eigenschaften, StudentID und StudentName.

Getter- und Setter-Methoden

Die Methoden Getter und Setter werden verwendet, um die Werte der Eigenschaften automatisch festzulegen und abzurufen. Wenn Sie in Rexx eine Eigenschaft mit dem Attributschlüsselwort deklarieren, sind die Methoden getter und setter bereits vorhanden.

Beispiel

::class student 
::attribute StudentID 
::attribute StudentName

Im obigen Beispiel gibt es Getter- und Setter-Methoden für StudentId und StudentName.

Ein Beispiel für ihre Verwendung finden Sie im folgenden Programm.

/* Main program */ 
value = .student~new 
value~StudentID = 1 
value~StudentName = 'Joe' 
say value~StudentID 
say value~StudentName 

exit 0 
::class student 
::attribute StudentID 
::attribute StudentName

Die Ausgabe des obigen Programms erfolgt wie unten gezeigt.

1 
Joe

Instanzmethoden

Objekte können aus der Klasse über das erstellt werden ~new operator. Eine Methode aus der Klasse kann folgendermaßen aufgerufen werden.

Object~methodname

Wo methodname ist die Methode, die von der Klasse aufgerufen werden muss.

Beispiel

Das folgende Beispiel zeigt, wie ein Objekt aus einer Klasse erstellt und die jeweilige Methode aufgerufen werden kann.

/* Main program */ 
value = .student~new 
value~StudentID = 1 
value~StudentName = 'Joe' 
value~Marks1 = 10 
value~Marks2 = 20 
value~Marks3 = 30 
total = value~Total(value~Marks1,value~Marks2,value~Marks3) 
say total 

exit 0 
::class student 
::attribute StudentID 
::attribute StudentName 
::attribute Marks1 
::attribute Marks2 
::attribute Marks3 
::method 'Total' 
use arg a,b,c 
return (ABS(a) + ABS(b) + ABS(c))

Die Ausgabe des obigen Programms erfolgt wie unten gezeigt.

Mehrere Objekte erstellen

Man kann auch mehrere Objekte einer Klasse erstellen. Das folgende Beispiel zeigt, wie dies erreicht werden kann.

Hier erstellen wir 3 Objekte (st, st1 und st2) und rufen ihre Instanzmitglieder und Instanzmethoden entsprechend auf.

Schauen wir uns ein Beispiel an, wie mehrere Objekte erstellt werden können.

Beispiel

/* Main program */ 
st = .student~new 
st~StudentID = 1 
st~StudentName = 'Joe' 
st~Marks1 = 10 
st~Marks2 = 20 
st~Marks3 = 30 
total = st~Total(st~Marks1,st~Marks2,st~Marks3) 
say total  

st1  =  .student~new 
st1~StudentID = 2 
st1~StudentName = 'John' 
st1~Marks1 = 10 
st1~Marks2 = 20 
st1~Marks3 = 40 
total = st1~Total(st1~Marks1,st1~Marks2,st1~Marks3) 
say total  

st2  =  .student~new 
st2~StudentID = 3 
st2~StudentName = 'Mark' 
st2~Marks1 = 10 
st2~Marks2 = 20 
st2~Marks3 = 30 
total = st2~Total(st2~Marks1,st2~Marks2,st2~Marks3) 
say total  

exit 0 
::class student 
::attribute StudentID 
::attribute StudentName 
::attribute Marks1 
::attribute Marks2 
::attribute Marks3 
::method 'Total' 
use arg a,b,c 
return (ABS(a) + ABS(b) + ABS(c))

Die Ausgabe des obigen Programms erfolgt wie unten gezeigt.

60 
70 
60

Erbe

Vererbung kann als der Prozess definiert werden, bei dem eine Klasse die Eigenschaften (Methoden und Felder) einer anderen Klasse erhält. Durch die Verwendung der Vererbung werden die Informationen in einer hierarchischen Reihenfolge verwaltet.

Die Klasse, die die Eigenschaften anderer erbt, ist bekannt als subclass (abgeleitete Klasse, untergeordnete Klasse) und die Klasse, deren Eigenschaften vererbt werden, ist bekannt als superclass (Basisklasse, Elternklasse).

Sehen wir uns ein Beispiel für die Vererbung in Rexx an. Im folgenden Beispiel erstellen wir eine Klasse namensPerson. Von dort aus verwenden wir das Schlüsselwort subclass, um das zu erstellenStudent class Als ein sub-class of Person.

Beispiel

/* Main program */ 
st = .student~new 
st~StudentID = 1 
st~StudentName = 'Joe' 
st~Marks1 = 10 
st~Marks2 = 20 
st~Marks3 = 30 
say st~Total(st~Marks1,st~Marks2,st~Marks3)  

exit 0 
::class Person 
::class student subclass Person 
::attribute StudentID 
::attribute StudentName 
::attribute Marks1 
::attribute Marks2 
::attribute Marks3 
::method 'Total' 
use arg a,b,c 
return (ABS(a) + ABS(b) + ABS(c))

Die Ausgabe des obigen Programms erfolgt wie unten gezeigt.

Portabilität ist ein wichtiger Aspekt in jeder Programmiersprache. Wie bekannt, ist Rexx in einer Vielzahl von Betriebssystemen wie Windows und Linux verfügbar. Es muss also sichergestellt werden, dass bei der Entwicklung eines Programms auf der Windows-Plattform die erforderlichen Vorsichtsmaßnahmen getroffen werden, wenn dieselben Programme auf einer Linux-Plattform ausgeführt werden.

Rexx kann Befehle auf Systemebene ausführen. Es gibt Befehle, mit denen Sie verstehen können, auf welchem Betriebssystem es ausgeführt wird. Basierend auf der Ausgabe kann es dann die entsprechenden Aktionen ausführen, um zu sehen, welche Befehle auf diesem Betriebssystem ausgeführt werden können.

Beispiel

Das folgende Beispiel zeigt, wie die Analysefunktionen verwendet werden, um die Details des Betriebssystems abzurufen, auf dem das Programm ausgeführt wird.

/* Main program */ 
parse version language level date month year. 
parse source system invocation filename. 
language = translate(language) 

if pos('REGINA',language) = 0 then 
   say 'Error , the default interpreter is not Regina' language 
   say 'The Interpreter version/release date is:' date month year 
   say 'The Language level is: ' level say 'The Operating System is'  

   select 
when system = 'WIN32' then 
   'ver'
when system = 'UNIX' | system = 'LINUX' then 
   'uname -a' 
   otherwise 
   say 'Unknown System:' system 
end 
if rc <> 0 then 
   say 'Error :' rc

Die Ausgabe variiert je nach Betriebssystem. Eine Beispielausgabe ist unten angegeben.

The Interpreter version/release date: 5 Apr 2015 
The Language level is:  5.00 
The Operating System is 
Unknown System: WIN64 
Bad return code: RC

Rexx bietet eine Reihe erweiterter Funktionen, die eine Vielzahl von Funktionen bieten, von denen die meisten die Interaktion mit dem Betriebssystem ermöglichen. Schauen wir uns einige davon im Detail an, wie unten erläutert.

Sr.Nr.	Erweiterte Funktionen
1	b2c Diese Funktion konvertiert einen Binärwert in einen Zeichenfolgenwert.
2	bitclr Diese Funktion wird verwendet, um das angegebene Bit in der Binärzeichenfolge auf 0 umzuschalten.
3	bitcomp Diese Funktion wird verwendet, um 2 Binärzeichenfolgen zu vergleichen, die mit Bit 0 beginnen.
4	Buftyp Diese Funktion wird verwendet, um den Inhalt des Stapels anzuzeigen, der normalerweise für Debugging-Zwecke verwendet wird.
5	Krypta Diese Funktion wird zum Verschlüsseln einer Zeichenfolge verwendet.
6	Gabel Diese Funktion wird verwendet, um einen neuen untergeordneten Prozess auf dem System zu erzeugen.
7	getpid Diese Funktion ruft die ID des aktuell ausgeführten Prozesses ab.
8	Hash Diese Funktion gibt den Hashwert einer Zeichenfolge zurück.

Rexx bietet eine Reihe von Anweisungen mit einer Vielzahl von Funktionen, von denen die meisten die Interaktion mit dem Betriebssystem ermöglichen. Schauen wir uns einige davon im Detail an.

Sr.Nr.	Rexx Anleitung
1	Adresse Mit dieser Funktion wird die aktuelle Befehlsumgebung angezeigt.
2	fallen Diese Funktion wird verwendet, um die Zuordnung einer Variablen aufzuheben.
3	interpretieren Interpretiert oder führt die definierte Anweisung aus.
4	nein Diese Funktion bedeutet, keine Operation auszuführen. Dieser Befehl wird normalerweise in verwendetif statements.
5	ziehen Dies wird verwendet, um Eingaben vom Stapel oder vom Standard-Stream abzurufen.
6	drücken Dies wird verwendet, um einen Wert auf den Rexx-Stapel zu übertragen.

Die Rexx-Sprache hat viele verschiedene Implementierungen, wie wir bereits in den vorherigen Kapiteln gesehen haben. Jede Implementierung hat ihre eigene Funktionalität. Schauen wir uns die verschiedenen für Rexx verfügbaren Implementierungen an.

OoRexx

Dies ist die objektorientierte Version von Rexx. Standardmäßig basiert die Rexx-Basisimplementierung auf Prozeduren. Mit ooRexx können Sie jedoch mehr Flexibilität bieten, indem Sie einen objektorientierten Ansatz für Rexx verfolgen. Mit ooRexx können Sie eine bessere Wiederverwendung erzielen, indem Sie wiederverwendbare Klassen und Objekte erstellen.

Das folgende Programm ist ein Beispiel für ein einfaches Rexx-Programm, das mit dem ooRexx-Implementierer ausgeführt werden kann.

Beispiel

/* Main program */ 
say ‘hello’

Führen Sie den folgenden Befehl aus, um dieses Programm auszuführen.

rexx main.rexx

Wenn Sie den obigen Befehl ausführen, erhalten Sie die folgende Ausgabe.

hello

Netrexx

Dies gilt für alle Java-basierten Entwickler, da es eine Java-basierte Alternative für die Rexx-Sprache bietet. Alle Objekte basieren also auf dem Java-Objektmodell. Der Vorteil dieses Frameworks besteht darin, dass es für Entwickler einfacher wird, dieses Framework zu verwenden, da Java eine weit verbreitete Sprache ist. In dieser Implementierung wird der Rexx-Code in ein Java-Programm konvertiert, das dann auf jeder virtuellen Java-Maschine ausgeführt werden kann.

Der folgende Code ist ein Beispiel für ein NetRexx-Programm.

Erstellen Sie eine Datei mit dem Namen main.nrx und platzieren Sie den folgenden Code in der Datei.

/* Main program */ 
say ‘hello’

Führen Sie den folgenden Befehl aus, um den Code zu kompilieren:

NetRexxC main.nrx

Sie erhalten dann die folgende Ausgabe. NetRexxC ist der Compiler, der das Rexx-Programm in sein Java-Äquivalent konvertiert.

java -cp ";;G:\NetRexx-3.04GA\lib\NetRexxF.jar;." 
-Dnrx.compiler = ecj org.netrexx.process.NetRexxC  main.nrx 
NetRexx portable processor 3.04 GA build 4-20150630-1657 
Copyright (c) RexxLA, 2011,2015.   All rights reserved. 
Parts Copyright (c) IBM Corporation, 1995,2008. 
Program main.nrx 
Compilation of 'main.nrx' successful

Sie können Ihr Java-Programm jetzt mit dem folgenden Java-Befehl ausführen.

java main

Wenn Sie den obigen Befehl ausführen, erhalten Sie die folgende Ausgabe.

Hello

Brexx

Dies ist eine leichte Implementierung von Rexx. Dies ist ein leichteres Paket als der Standard-Rexx-Implementierer. Aber es hat immer noch die volle Funktionalität von Rexx.

Der folgende Code ist ein Beispiel für ein BRexx-Programm.

/* Main program */ 
say ‘hello’

Führen Sie den folgenden Befehl aus, um das Programm auszuführen.

rexx32 main.rexx

Wenn Sie den obigen Befehl ausführen, erhalten Sie die folgende Ausgabe.

hello

NetRexx ist die Java-Implementierung von Rexx. In NetRexx wird der Implementierer verwendet, um das Rexx-Programm in ein Java-Programm zu konvertieren, das dann auf jeder virtuellen Java-Maschine ausgeführt werden kann.

NetRexx einrichten

Der erste Schritt in NetRexx besteht darin, es auf dem lokalen Computer einzurichten. Dazu müssen die folgenden Schritte ausgeführt werden:

Step 1 - Gehen Sie zur NetRexx-Download-Site - http://www.netrexx.org/downloads.nsp

Laden Sie die Datei NetRexx.3.04.GA herunter.

Step 2- Stellen Sie sicher, dass Java auf Ihrem System installiert ist und ausgeführt wird. Sie können überprüfen, ob Java ausgeführt wird, indem Sie den Befehl java - version verwenden.

Ein Beispiel für die Ausgabe ist unten dargestellt.

H:\>java -version 
java version "1.7.0_79" 
Java(TM) SE Runtime Environment (build 1.7.0_79-b15) 
Java HotSpot(TM) Client VM (build 24.79-b02, mixed mode, sharing)

Step 3- Entpacken Sie den Inhalt der komprimierten Netrexx-Datei. Kopieren Sie die Dateien aus dem Ordner NetRexx3.04GA \ lib in Ihren Java-Installationsordner / lib / etc.

Step 4 - Fügen Sie der Pfadvariablen auf dem System den Pfad NetRexx-3.04GA \ bin hinzu.

Ausführen des ersten NetRexx-Programms

Erstellen Sie eine Datei mit dem Namen main.nrx und platzieren Sie den folgenden Code in der Datei.

/* Main program */ 
say ‘hello’

Führen Sie den folgenden Befehl aus, um den Code zu kompilieren.

NetRexxC main.nrx

Sie erhalten dann die folgende Ausgabe. NetRexxC ist der Compiler, der das rexx-Programm in sein Java-Äquivalent konvertiert.

java -cp ";;G:\NetRexx-3.04GA\lib\NetRexxF.jar;." 
-Dnrx.compiler = ecj org.netrexx.process.NetRexxC  main.nrx 
NetRexx portable processor 3.04 GA build 4-20150630-1657 
Copyright (c) RexxLA, 2011,2015.   All rights reserved. 
Parts Copyright (c) IBM Corporation, 1995,2008. 
Program main.nrx 
Compilation of 'main.nrx' successful

Sie können Ihr Java-Programm jetzt mit dem folgenden Java-Befehl ausführen.

java main

Wenn Sie den obigen Befehl ausführen, erhalten Sie die folgende Ausgabe.

Hello

Lassen Sie uns nun einige der special aspects of the Netrexx library.

Indizierte Zeichenfolgen

In NetRexx können Zeichenfolgen zu Indizes für Arrays werden. Ein Beispiel ist unten gezeigt.

Beispiel

/* Main program */ 
value = 'unknown' 
value['a'] = 'b' 
c = 'a' 
say value[c]

Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis.

Ausgabe

Mehrere Indizes

In NetRexx können Sie mehrere Indizes für Arrays haben. Ein Beispiel ist unten gezeigt.

Beispiel

/* Main program */ 
value = 'null' 
value['a', 'b'] = 1 
say value['a', 'b']

Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis.

Ausgabe

Sr.Nr.	Befehl & Beschreibung
1	Befehl fragen Mit diesem Befehl wird eine Zeile aus dem Standardeingabestream gelesen.
2	Ziffern Befehl Dieser Befehl wird verwendet, um den aktuellen Wert des Ziffernwerts anzuzeigen.
3	Formular Befehl Mit diesem Befehl wird der aktuelle Wert des Formularwerts angezeigt.
4	Länge Befehl Dieser Befehl wird verwendet, um die Länge eines Zeichenfolgenwerts anzuzeigen.
5	Versionsbefehl Dieser Befehl wird verwendet, um die aktuell verwendete Version von NetRexx zurückzugeben.
6	Trace-Befehl Dieser Befehl wird verwendet, um die aktuelle Traceeinstellung zurückzugeben, die von NetRexx verwendet wird.

BRexx ist eine leichtere Implementierung von Rexx. Im Rahmen der Rexx-Implementierung bietet es noch viele Funktionen.

BRexx einrichten

Der erste Schritt in BRexx besteht darin, es auf dem lokalen Computer einzurichten. Dazu müssen die folgenden Schritte ausgeführt werden:

Step 1 - Gehen Sie zur BRexx-Download-Site - https://ftp.gwdg.de/pub/languages/rexx/brexx/html/rx.html

Gehen Sie zum Download-Bereich und laden Sie das Produkt herunter.

Step 2 - Entpacken Sie den Inhalt der Brexx-ZIP-Datei.

Step 3 - Fügen Sie der Pfadvariablen auf dem System den Pfad BRexx \ bin hinzu.

Step 4 - Erstellen Sie eine neue Variable namens RXLIB und verweisen Sie auf den Ordner lib im Ordner Brexx.

Ausführen des ersten BRexx-Programms

Erstellen Sie eine Datei mit dem Namen main.rexx und platzieren Sie den folgenden Code in der Datei.

/* Main program */ 
say ‘hello’

Führen Sie den folgenden Befehl aus, um das Programm auszuführen.

rexx32 main.rexx

Wenn Sie den obigen Befehl ausführen, erhalten Sie die folgende Ausgabe.

hello

Lassen Sie uns nun einige der am häufigsten verwendeten Funktionen diskutieren, die in der BRexx-Bibliothek verfügbar sind.

Sr.Nr.	In der BRexx-Bibliothek verfügbare Funktionen
1	acos Befehl Dieser Befehl wird verwendet, um die Bogen-Kosinus-Konvertierung einer Zahl zu erhalten.
2	cos Befehl Dieser Befehl wird verwendet, um die Kosinuskonvertierung einer Zahl abzurufen.
3	sin Befehl Dieser Befehl wird verwendet, um die Sinuskonvertierung einer Zahl zu erhalten.
4	asin Befehl Dieser Befehl wird verwendet, um die Bogen-Sinus-Konvertierung einer Zahl zu erhalten.
5	tan Befehl Dieser Befehl wird verwendet, um die Tangentenkonvertierung einer Zahl zu erhalten.
6	atan Befehl Dieser Befehl wird verwendet, um die Bogen-Tangenten-Konvertierung einer Zahl zu erhalten.
7	Befehl mkdir Mit diesem Befehl wird ein Verzeichnis im aktuellen Arbeitsverzeichnis erstellt.
8	Befehl rmdir Mit diesem Befehl wird ein Verzeichnis im aktuellen Arbeitsverzeichnis entfernt.
9	dir Befehl Dieser Befehl wird verwendet, um die gesamte Verzeichnisliste zurückzugeben.

Rexx kann mit einer Vielzahl von Datenbanken arbeiten, die unten aufgeführt sind.

HSQLDB
Oracle
SQL Server
MySQL
MongoDB

Alle Informationen für Rexx-Datenbanken finden Sie, sobald Sie auf den folgenden Link klicken: https://rexxsql.sourceforge.net/

In unserem Beispiel verwenden wir MySQL DB als Beispiel. Der erste Schritt besteht also darin, sicherzustellen, dass die erforderlichen Treiber von der Rexx SQL-Site heruntergeladen werden, damit Rexx-Programme entsprechend mit SQL arbeiten können. Befolgen Sie daher die folgenden Schritte, um sicherzustellen, dass Rexx-Programme mit MySQL-Datenbanken arbeiten können.

Step 1 - Gehen Sie zur folgenden Treiber-Download-Seite von der Rexx-Website - https://sourceforge.net/projects/rexxsql/files/rexxsql/2.6/

Step 2 - Laden Sie die MYSQL-Treiber herunter - rxsql26B3_my_w32_ooRexx

Step 3 - Entpacken Sie den Inhalt auf den lokalen Computer.

Step 4 - Fügen Sie den Pfad des entpackten Ordners zur Pfadvariablen auf Ihrem Computer hinzu.

Stellen Sie für alle nachfolgenden Beispiele sicher, dass die folgenden Zeiger vorhanden sind:

Sie haben eine Datenbank TESTDB erstellt.
Sie haben in TESTDB eine Tabelle EMPLOYEE erstellt.
Diese Tabelle enthält die Felder FIRST_NAME, LAST_NAME, AGE, SEX und INCOME.
Die Benutzer-ID "testuser" und das Kennwort "test123" sind für den Zugriff auf TESTDB festgelegt.
Stellen Sie sicher, dass Sie die MySQL-JAR-Datei heruntergeladen und Ihrem Klassenpfad hinzugefügt haben.
Sie haben das MySQL-Tutorial durchlaufen

Datenbankverbindung

Um eine Datenbankverbindung herzustellen, müssen Sie zuerst die Rexxsql-DLL aufrufen und dann mit der SQLConnect-Funktion eine Verbindung zur Datenbank herstellen. Die Syntax und das Beispiel, wie dies erreicht werden kann, sind unten angegeben.

Syntax

SQLConnect(cname,username,password,dbname)

Parameter

cname - Dies ist der Name, der der Verbindung gegeben werden soll.
username - Der Benutzername für die Verbindung zur Datenbank.
password - Das Passwort für die Verbindung zur Datenbank.
dbname - Das Datenbankschema, zu dem eine Verbindung hergestellt werden soll.

Rückgabewert

Ein Wert gleich 0 bedeutet, dass die Datenbankverbindung erfolgreich ist.

Beispiel

/* Main program */ 
Call RxFuncAdd 'SQLLoadFuncs', 'rexxsql', 'SQLLoadFuncs' 
Call SQLLoadFuncs 
say SQLConnect(c1,' testuser ',' test123','testdb')

Die Ausgabe des obigen Programms wäre wie unten gezeigt.

Erstellen einer Datenbanktabelle

Der nächste Schritt nach dem Herstellen einer Verbindung zur Datenbank besteht darin, die Tabellen in unserer Datenbank zu erstellen. Das folgende Beispiel zeigt, wie Sie mit Rexx eine Tabelle in der Datenbank erstellen. Alle Befehle in Rexx SQL werden mithilfe der SQLCommand-Funktion ausgeführt.

Syntax

SQLConnect(sname,statement)

Parameter

sname - Dies ist der Name, der der auszuführenden Anweisung gegeben werden soll.
statement - Dies ist die Anweisung, die für die Datenbank ausgeführt werden muss.

Rückgabewert

Ein Wert gleich 0 bedeutet, dass der Befehl erfolgreich war.

Beispiel

/* Main program */ 
Call RxFuncAdd 'SQLLoadFuncs', 'rexxsql', 'SQLLoadFuncs' 
Call SQLLoadFuncs 

if SQLConnect(c1,'testuser','test123','testdb') == 0 then say 'Connect Succedded' 
if SQLCommand(u1,"use testdb") == 0 then say 'Changed database to testdb' 
   sqlstr = 'create table employee (first_name char(20) not null, last_name 
   char(20),age int, sex   
   char(1), income float)' 

if SQLCommand(c2,sqlstr) == 0 then say 'Employee table created'

Die Ausgabe des obigen Programms wäre wie unten gezeigt.

Connect Succedded 
Changed database to testdb 
Employee table created

Operationen an einer Datenbanktabelle

Die folgenden Arten von Operationen werden am häufigsten für eine Datenbanktabelle ausgeführt.

Sr.Nr.	Operationsbeschreibung
1	Operation einfügen Dies ist erforderlich, wenn Sie Ihre Datensätze in einer Datenbanktabelle erstellen möchten.
2	Betrieb lesen Eine READ-Operation für eine beliebige Datenbank bedeutet, einige nützliche Informationen aus der Datenbank abzurufen.
3	Vorgang aktualisieren Die UPDATE-Operation für eine beliebige Datenbank bedeutet, einen oder mehrere Datensätze zu aktualisieren, die bereits in der Datenbank verfügbar sind.
4	Vorgang löschen Die Operation DELETE ist erforderlich, wenn Sie einige Datensätze aus Ihrer Datenbank löschen möchten.
5	Schließen einer Verbindung Mit dem folgenden Befehl können Sie eine Verbindung zur Datenbank schließen.

Transaktion durchführen

Transaktionen sind ein Mechanismus, der die Datenkonsistenz gewährleistet. Transaktionen haben die folgenden vier Eigenschaften:

Atomicity - Entweder wird eine Transaktion abgeschlossen oder es passiert überhaupt nichts.
Consistency - Eine Transaktion muss in einem konsistenten Zustand beginnen und das System in einem konsistenten Zustand belassen.
Isolation - Zwischenergebnisse einer Transaktion sind außerhalb der aktuellen Transaktion nicht sichtbar.
Durability - Sobald eine Transaktion festgeschrieben wurde, bleiben die Auswirkungen auch nach einem Systemausfall bestehen.

Hier ist ein einfaches Beispiel für die Implementierung von Transaktionen.

Beispiel

/* Main program */ 
Call RxFuncAdd 'SQLLoadFuncs', 'rexxsql', 'SQLLoadFuncs' 
Call SQLLoadFuncs 

if SQLConnect(c1,'testuser','test123','testdb') == 0 then say 'Connect Succedded' 
if SQLCommand(u1,"use testdb") == 0 then say 'Changed database to testdb' 
   sqlstr = "DELETE FROM EMPLOYEE WHERE AGE > 20" 

if SQLCommand(c2,sqlstr) == 0 then 
if sqlcommit() == 0 then say committed

Die Ausgabe des obigen Programms wäre wie unten gezeigt.

Connect Succedded 
Changed database to testdb 
COMMITTED

Operation festschreiben

Die Festschreibungsoperation weist die Datenbank an, mit der Operation fortzufahren und alle Änderungen an der Datenbank abzuschließen. In unserem obigen Beispiel wird dies durch den folgenden Befehl erreicht.

Sqlcommit()

Rollback-Betrieb

Wenn Sie mit einer oder mehreren Änderungen nicht zufrieden sind und diese Änderungen vollständig zurücksetzen möchten, verwenden Sie die Rollback-Methode. In unserem obigen Beispiel wird dies durch den folgenden Befehl erreicht.

SqlRollback()

Handheld-Geräte haben einen langen Weg zurückgelegt, und Rexx bietet viele Möglichkeiten, wie es auf diesen Geräten ausgeführt werden kann. Rexx unterstützt Pocket PCs, Palm-Geräte, PDAs und andere Smartphones. Der Vorteil von Rexx bei der Arbeit auf diesen Plattformen ist, dass Rexx wirklich ein Programmiersystem mit geringem Gewicht ist, das nur in wenigen Kilobyte läuft. Daher wird es einfacher, Rexx-Programme auf diesen Geräten auszuführen.

Rexx auf Handheld-Geräten kann in den folgenden Modi ausgeführt werden:

Der erste Modus ist der native Knoten, auf dem er direkt auf dem Betriebssystem selbst ausgeführt wird. Der Vorteil beim Ausführen in diesem Modus ist, dass es schneller ist, da es direkt vom Betriebssystem ausgeführt wird.
Der nächste Modus befindet sich über dem DOS- oder Emulatorprogramm auf dem Handgerät. Der Vorteil dieses Modus ist, dass er auf jedem Betriebssystem ausgeführt werden kann, solange der Emulator auf diesem Betriebssystem ausgeführt wird.

Die Rexx-Dolmetscher für die verschiedenen Kategorien von Handgeräten sind unten aufgeführt.

Windows CE - Brexx
Palm OS - Rexx für Palm OS
Symbian OS - Regina

Für den DOS-Emulator müssen die folgenden Schritte ausgeführt werden:

Step 1- Zuerst müssen Sie PocketDOS herunterladen, einen beliebten DOS-Emulator. Es kann auf vielen Betriebssystemen ausgeführt werden und unterstützt gängige VGA-Bildschirme sowie serielle und parallele Ports.

Step 2 - Der nächste Schritt ist das Herunterladen der BRexx-Dateien für 16-Bit-DOS auf einen Windows-PC.

Step 3 - Der letzte Schritt besteht darin, das Rexx-Programm mit ActiveSync mit dem Handheld-Gerät zu synchronisieren.

Es gibt einige andere kommerzielle DOS-basierte Produkte. XTM ist ein Produkt, das unter diese Kategorie fällt. Die Merkmale dieses Produkts sind wie folgt:

Unterstützung für die 80186-CPU und den Befehlssatz.
Es funktioniert irgendwie mit dem BIOS-Code für eine bessere Leistung.
Es kann eine Emulation für den Math-Co-Prozessor, Version 8087 MPU, bereitstellen
Es bietet Zugriff auf die seriellen Schnittstellen.
Es unterstützt eine Vielzahl von Sprachen wie Englisch, Französisch und Deutsch.

Einer der Schlüsselaspekte jeder Programmiersprache ist die Leistung der Anwendung. Es müssen spezielle Praktiken beachtet werden, um sicherzustellen, dass die Leistung der Anwendung nicht beeinträchtigt wird. Schauen wir uns zum besseren Verständnis einige der in den Schritten beschriebenen Überlegungen an.

Step 1- Versuchen Sie, die Anzahl der Anweisungen zu verringern. - In Rexx ist jede Anweisung mit einem Overhead verbunden. Versuchen Sie also, die Anzahl der Anweisungen in Ihrem Programm zu reduzieren. Ein Beispiel für Anweisungen, die neu gestaltet werden können, ist unten dargestellt.

Anstatt mehrere if else-Anweisungen zu verwenden, kann die parse-Anweisung verwendet werden. Verwenden Sie also wie im folgenden Programm die parse-Anweisung, anstatt für jeden Wert eine if-Bedingung zu haben und den Wert von word1, word2, word3 und word4 abzurufen.

/* Main program */  

parse value 'This is a Tutorial' with word1 word2 word3 word4 
say "'"word1"'" 
say "'"word2"'" 
say "'"word3"'" 
say "'"word4"'"

Step 2- Versuchen Sie, mehrere Anweisungen zu einer Anweisung zu kombinieren. Ein Beispiel ist unten gezeigt.

Angenommen, Sie hätten den folgenden Code, der die Zuordnung für - vorgenommen hat. a and b und übergab es an eine Methode namens proc.

do i = 1 to 100 
   a = 0 
   b = 1 
   call proc a,b 
end

Mit der parse-Anweisung können Sie den oben angegebenen Code einfach durch den folgenden Code ersetzen.

do i = 1 for 100 
   parse value 0 1 with 
   a, 
   b, 
   call proc a,b 
end

Step 3 - Versuchen Sie, die zu ersetzen do..to loop mit dem do..for loopwoimmer möglich. Dies wird normalerweise empfohlen, wenn die Steuervariable durch eine Schleife iteriert wird.

/* Main program */ 
do i = 1 to 10 
   say i 
end

Das obige Programm sollte durch das folgende Programm ersetzt werden.

/* Main program */ 
do i = 1 for 10 
   say i 
end

Step 4- Entfernen Sie nach Möglichkeit die for-Bedingung aus einer do-Schleife, wie im folgenden Programm gezeigt. Wenn die Steuervariable nicht benötigt wird, geben Sie einfach den Endwert wie unten gezeigt in die do-Schleife ein.

/* Main program */ 
do 10 
   say hello 
end

Step 5 - In a select clauseWas auch immer Sie für die beste Bedingung halten, die bewertet wird, muss an erster Stelle stehen when clause. Wenn wir also im folgenden Beispiel wissen, dass 1 die häufigste Option ist, setzen wir diewhen 1 clause als erste Klausel in der select-Anweisung.

/* Main program */ 
select 
   when 1 then say'1' 
   when 2 then say'2' 
   otherwise say '3' 
end

Jeder Programmierer möchte, dass sein Programm das Beste ist, wenn es um Qualität und Effizienz geht. Im Folgenden finden Sie einige der besten Programmiermethoden oder Hinweise zum Schreiben von Rexx-Programmen, mit denen Sie diese Ziele erreichen können.

Tipp 1

Verwenden Sie den Befehl address, bevor Sie einen Befehl an das Betriebssystem oder die Eingabeaufforderung senden. Dies hilft Ihnen, den Adressraum vorher im Speicher abzurufen und Ihr Programm effizienter auszuführen.

Ein Beispiel für den Adressbefehl ist unten dargestellt.

Beispiel

/* Main program */ 
address system dir

Die Ausgabe des Befehls lautet wie folgt, kann jedoch von System zu System variieren.

Volume in drive H is Apps 
Volume Serial Number is 8E66-AC3D  
Directory of H:\  
06/30/2016  01:28 AM    <DIR>          Apps 
07/05/2016  03:40 AM               463 main.class 
07/07/2016  01:30 AM                46 main.nrx 
07/07/2016  01:42 AM                38 main.rexx 
3 File(s)            547 bytes 
Dir(s)  313,085,173,760 bytes free

Tipp 2

Stellen Sie sicher, dass alle Befehle an das Betriebssystem nach Möglichkeit in Großbuchstaben und in Anführungszeichen stehen.

Ein Beispiel dafür ist unten gezeigt.

Beispiel

/* Main program */ 
options arexx_bifs 
say chdir('\REXXML100') 
say directory()

Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis.

0 
D:\rexxxml100

Tipp 3

Vermeiden Sie das Erstellen großer Kommentarblöcke, wie im folgenden Programm gezeigt.

Beispiel

/******/ 
/* */ 
/* */ 
/* */ 
/******/ 
/* Main program */ 
address system dir

Tipp 4

Verwenden Sie die Parse-Anweisung, um Standardwerte zuzuweisen. Ein Beispiel dafür ist unten gezeigt.

Beispiel

parse value 0 1 with 
a, 
b

Tipp 5

Verwenden Sie nach Möglichkeit die Anweisung "Left (var1,2)" anstelle der Anweisung "substr (var1,1,2)".

Tipp 6

Verwenden Sie nach Möglichkeit die Anweisung "Right (var1,2)" anstelle der Anweisung "substr (var1, length (var1), 2)".

Um die in Rexx verfügbaren grafischen Benutzeroberflächen verwenden zu können, müssen zwei Pakete verwendet werden, eines wird aufgerufen ActiveTcl und der andere ist der RexxtkPaket. Zusammen mit diesen beiden Paketen kann man normale Formulare entwerfen, die Schaltflächen und andere Steuerelemente in den Formularen enthalten können.

Umgebungs-Setup

Das erste, was zu tun ist, ist die Einrichtung der Umgebung. Lassen Sie uns die folgenden Schritte ausführen, um die Umgebung einzurichten.

Step 1 - Laden Sie das Activetcl-Paket von der folgenden Website herunter - https://www.activestate.com/activetcl

Step 2- Der nächste Schritt besteht darin, die Installation von ActiveTCl zu starten. Klicken Sie auf dem Bildschirm auf die Schaltfläche Weiter, um fortzufahren.

Step 3 - Akzeptieren Sie die Lizenzvereinbarung und klicken Sie auf die Schaltfläche Weiter.

Step 4 - Wählen Sie einen Ort für die Installation und klicken Sie auf die Schaltfläche Weiter.

Step 5 - Wählen Sie einen Ort für die Installation der Demos und klicken Sie auf die Schaltfläche Weiter.

Step 6 - Klicken Sie auf die Schaltfläche Weiter, um mit der Installation fortzufahren.

Step 7 - Klicken Sie auf die Schaltfläche Fertig stellen, um die Installation abzuschließen.

Step 8 - Der nächste Schritt ist das Herunterladen der Rexxtk-Software über den folgenden Link: - https://sourceforge.net/projects/rexxtk/

Step 9- Doppelklicken Sie im vorherigen Schritt über den Link auf die Installationsdatei, um die Installation zu starten. Klicken Sie auf die Schaltfläche Weiter, um fortzufahren.

Step 10 - Klicken Sie im nächsten Bildschirm auf die Schaltfläche Ja, um der Lizenzvereinbarung zuzustimmen.

Step 11 - Wählen Sie im nächsten Bildschirm den Speicherort für die Installation und klicken Sie auf die Schaltfläche Weiter.

Step 12 - Wählen Sie den Speicherort des Programmordners und klicken Sie auf die Schaltfläche Weiter.

Sobald die Installation abgeschlossen ist, können wir mit der Programmierung der GUI in Rexx beginnen.

Grundprogramm

Mal sehen, wie wir mit Rexx ein einfaches Basisprogramm in einem grafischen Benutzeroberflächenformat entwerfen können.

Beispiel

/* Main program */ 
call RxFuncAdd 'TkLoadFuncs','rexxtk','TkLoadFuncs' 
call TkLoadFuncs 
do forever 
   interpret 'Call' TkWait() 
end 
call TkDropFuncs 
exit 0

Die folgenden Dinge müssen über das obige Programm beachtet werden -

Die Rexxtk-Bibliothek und alle ihre Funktionen werden mit dem Befehl RxFuncAdd geladen.
Die do forever-Schleife hält das Fenster offen und wartet auf die Benutzereingabe.
Sobald die Benutzereingabe erkannt wurde, wird das Programm beendet.

Wenn das obige Programm ausgeführt wird, erhalten Sie die folgende Ausgabe.

Menüs erstellen

Menüs werden mit Hilfe der Funktionen TkMenu und TkAdd erstellt. Die Syntax dieser Funktionen ist unten angegeben.

Syntax

TkMenu(widgetname,options,0)

Parameter

Widgetname - Ein Name, der dem Menü gegeben werden soll.

Optionen können eine der folgenden sein:

selectcolor - Wenn Kontrollkästchen oder Optionsfelder als Menüoptionen verwendet werden, gibt diese Option die Farbe an, die ausgewählt werden soll, wenn eine Menüoption ausgewählt wird.
tearoff - Mit dieser Option können Sie dem Hauptmenü Untermenüs hinzufügen.
title - Die Zeichenfolge, die verwendet werden muss, um dem Fenster einen Titel zu geben.

Rückgabewert

Ein Handle zum erstellten Menü.

Beispiel

/* Main program */ 
call RxFuncAdd 'TkLoadFuncs','rexxtk','TkLoadFuncs' 
call TkLoadFuncs 

menubar = TkMenu('.m1') 
filemenu = TkMenu('.m1.file','-tearoff', 0) 
call TkAdd menubar, 'cascade', '-label', 'File', '-menu', filemenu 
call TkAdd filemenu, 'command', '-label', 'Open...', '-rexx', 'getfile' 
call TkConfig '.', '-menu', menubar 

do forever 
   interpret 'Call' TkWait() 
end 
call TkDropFuncs 
exit 0

Die folgenden Dinge müssen über das obige Programm beachtet werden -

Die Menüleiste wird mit der Funktion TkMenu erstellt. Der Parameter 'Tearoff' bedeutet, dass wir Untermenüs erstellen müssen, die an das Hauptmenü angehängt werden.
Wir fügen dann 2 Menüoptionen hinzu, die als Datei und Öffnen mit der TkAdd-Funktion bezeichnet werden.

Wenn das obige Programm ausgeführt wird, erhalten Sie die folgende Ausgabe.

Reginald ist ein weiterer Rexx-Interpreter, der von Jeff Glantt entwickelt wurde und einige Anpassungen hinsichtlich der Ausführung von Rexx-Programmen enthält. In diesem Abschnitt erfahren Sie, wie Sie Reginald einrichten und einige Rexx-Programme darin ausführen.

Umgebungs-Setup

Der erste Schritt ist das Umgebungs-Setup, bei dem die Reginald-Dateien heruntergeladen werden. Dies kann über den folgenden Website-Link erfolgen:http://www.manmrk.net/tutorials/rexx/Reginald/win32/rxusrw32.htm

Sobald der Download abgeschlossen ist und Sie das Installationsprogramm starten, können Sie im nächsten Bildschirm den Installationsort auswählen.

Klicken Sie auf die Schaltfläche Installieren, um fortzufahren.

Nach Abschluss können wir nun ein Beispielprogramm im Reginald-Interpreter ausführen. Erstellen Sie ein einfaches Programm wie unten gezeigt.

/* Main program */ 
say 'Hello'

Führen Sie dann den folgenden Befehl aus:

RxLaunch.exe main.rexx

Sie erhalten dann die folgende Ausgabe. Dieses Programm wird jetzt im Reginald-Interpreter ausgeführt.

Andere Funktionen verfügbar

Abgesehen von den normalen Rexx-Befehlen verfügte Reginald über einige spezifische Befehle, die auf das Windows-Betriebssystem zugeschnitten waren. DriveMap ist ein solcher Befehl -

DriveMap

Diese Funktion gibt Auskunft über das Laufwerk.

Syntax - -

Drivemap(,options)

Parameters - -

Options - Dies ist eine Liste von Schlüsselwörtern, mit denen verschiedene Informationen zu den Laufwerken des lokalen Computers abgerufen werden können.

Return Value

Ein Zeichenfolgenwert, der Informationen zum Laufwerk enthält.

Example - -

/* Main program */ 
say 'Drives on system : ' DriveMap(,'FIXED')

Wenn das obige Programm ausgeführt wird, erhalten Sie die folgende Ausgabe. Diese Ausgabe hängt von System zu System ab.

List of disk drives :  C:\ D:\

Rexx kann auch mit Webservern arbeiten. Am häufigsten ist der Apache-Webserver. Um Rexxw mit dem Apache-Webserver zu verwenden, müssen Sie zuerst die Rexx-Module über den folgenden Link herunterladen:https://sourceforge.net/projects/modrexx/?source=typ_redirect

Stellen Sie anschließend sicher, dass Sie die Mod Rexx-Module zum Klassenpfad hinzufügen.

Die folgenden Zeilen müssen zur Apache-Konfigurationsdatei hinzugefügt und geändert werden.

Die folgenden Zeilen müssen am Ende des entsprechenden Feldes eingefügt werden -

httpd.conf LoadModule-Liste.
LoadModule rexx_module modules / mod_rexx.dll

Die folgenden Zeilen sollten am Ende der hinzugefügt werden http.conf Datei.

AddType-Anwendung / x-httpd-rexx-script .rex .rexx
AddType-Anwendung / x-httpd-rexx-rsp .rsp
Fügen Sie diese für die Unterstützung von REXX Server-Seiten hinzu
RexxRspCompiler “c: / Programme / Apache Group / Apache2 / bin / rspcomp.rex”

Sobald die oben genannten Änderungen vorgenommen wurden, müssen Sie Ihren Apache-Webserver herunterfahren und neu starten.

Mit den obigen Zeilen können Sie auch Rexx-basierte Serverseiten wie Java-Serverseiten verwenden. Sie können den Rexx-Code direkt zu den HTML-Seiten hinzufügen.

Ein Beispiel ist unten gezeigt -

<p>The current date and time is 
   <?rexx 
      /* Inserting the rexx statement */ 
      say date() time() 
   ?>
</p>

Wenn eine Rexx-basierte Serverseite ausgeführt wird, werden die folgenden Schritte ausgeführt:

Zuerst wird eine temporäre Datei erstellt.
Anschließend kompiliert der Rexx Server-Compiler die Datei in ein Rexx-Programm und legt sie in der temporären Datei ab.
Der nächste Schritt besteht darin, das Rexx-Programm tatsächlich auszuführen.

Schließlich wird die temporäre Datei entfernt.