Verwaltung und Programmierung

Sprachumgebungen für Programmiersprachen

Net.Data stellt die folgenden Sprachumgebungen für das Aufrufen externer Programme bereit:

Zugriffsrechte: Stellen Sie sicher, dass die Benutzer-ID, unter der Net.Data ausgeführt wird, Zugriffsrechte für die Programmausführung sowie für alle Objekte besitzt, auf die das Programm zugreift. Weitere Informationen hierzu finden Sie in Erteilen von Zugriffsrechten für Dateien, auf die Net.Data zugreift.

Java-Anwendungssprachumgebung

Net.Data unterstützt Ihre vorhandenen Java-Anwendungen in der Java-Sprachumgebung. Mit der Unterstützung für Java-Applets und Java-Methoden (bzw. Anwendungen) können Sie über die API für Java Database Connectivity (JDBC**) auf DB2 zugreifen.

Konfigurieren der Java-Sprachumgebung

Zur Verwendung der Java-Sprachumgebung müssen Sie die Net.Data-Einstellungen für die Initialisierung prüfen und die Sprachumgebung definieren.

Prüfen Sie, ob sich eine Konfigurationsanweisung wie die folgende in der Initialisierungsdatei befindet und in einer Zeile steht:

ENVIRONMENT (DTW_JAVAPPS)  /opt/IBMNetData/lib/libdtwjava.so ( OUT RETURN_CODE ) 
   {% CLIETTE "DTW_JAVAPPS" %}

In diesem Beispiel ist die CLIETTE-Zeichenfolge am Ende des Eintrags ENVIRONMENT als Kommentar markiert. Wenn die CLIETTE-Zeichenfolge nicht als Kommentar markiert ist, versucht Net.Data, die Java-Anwendung über die Net.Data-Direktverbindung aufzurufen. Sie müssen die Net.Data-Direktverbindung verwenden, wenn Sie Net.Data mit einer anderen Schnittstelle als CGI oder FCGI ausführen. Wenn die CLIETTE-Zeichenfolge nicht als Kommentar markiert ist und die Net.Data-Direktverbindung nicht aktiv ist, versucht Net.Data, die Java-Anwendung direkt auszuführen. Wenn Sie Net.Data mit einer anderen Schnittstelle als CGI oder FCGI ausführen, kann dies allerdings ein unvorhersehbares Verhalten verursachen.

Weitere Informationen zur Net.Data-Initialisierungsdatei sowie zu Anweisungen ENVIRONMENT für die Sprachumgebung finden Sie in Umgebungskonfigurationsanweisungen.

Wichtig: In Definieren der Java-Sprachumgebung mit Cliette finden Sie eine Einführung, wie Sie die Java-Sprachumgebung für den Aufruf von Java-Anwendungen über die Direktverbindung definieren.

Aufrufen von Java-Funktionen

Mit der Java-Sprachumgebung können Sie Java-Funktionsaufrufe von dem Net.Data-Makro aus mit Net.Data-Zeichenfolgen absetzen, die als Parameter verwendet werden. Diese aufgerufenen Java-Funktionsaufrufe können eine Zeichenfolge zurückgeben.

Net.Data bietet die folgenden zwei Methoden, um Java-Funktionen aufzurufen:

  1. Net.Data kann die Java-Anwendung direkt startet, indem die Java-Sprachumgebung in den Net.Data-Prozess geladen wird.

    Das ist die einfachste Methode in Bezug auf Installation und Konfiguration. Sie wird empfohlen, wenn Sie Net.Data über CGI oder FCGI ausführen. Diese Methode steht unter Windows, AIX, Linux und Solaris zur Verfügung.

  2. Net.Data stellt die Verbindung zur Java-Sprachumgebung über die Net.Data-Direktverbindung her.

    Diese Methode wird empfohlen, wenn Sie Net.Data als Webserver-API ausführen. Die Java-Anwendung wird als getrennter Prozess über die Direktverbindung ausgeführt und ist von einer möglichen Interferenz durch andere stattfindende Java-Verarbeitungen "abgeschirmt". Diese Methode steht unter Windows, OS/2 und AIX zur Verfügung.

Der Prozess zur Einstellung von Net.Data, damit Java-Funktionen aufgerufen werden, hängt von der von Ihnen verwendeten Methode ab.

Aufrufen von Java-Funktionen durch Laden der Java-Anwendung

Gehen Sie wie folgt vor, um die Java-Funktionen durch das Laden der Java-Anwendung aufzurufen:

  1. Schreiben Sie Ihre Java-Funktionen, und stellen Sie den Quellcode in die Java-Funktionenbeispieldatei UserFunctions.java, die von Net.Data angeboten wird.
  2. Fügen Sie Ihrer CLASSPATH-Einstellung die Datei gnu.regexp-1.0.8.jar hinzu. Fügen Sie unter AIX z. B. den folgenden Pfad hinzu:
    /opt/IBMNetData/bkends/javaapps/gnu.regexp-1.0.8.jar 
    

    Die Datei gnu.regexp-1.0.8.jar wird mit Net.Data ausgeliefert.

  3. Erstellen Sie wie folgt die Java-Klassendateien.

    1. Führen Sie die Stapeldatei zur Wiederherstellung in dem Verzeichnis aus, das die Datei UserFunctions.java enthält.
    2. Nach erfolgreicher Beendigung generiert diese Datei die zwei Java-Klassendateien dtw_getsignature.class und dtw_userfunction.class.
  4. Stellen Sie die Java-Klassendateien dtw_getsignature.class und dtw_userfunction.class in ein Verzeichnis, in dem die Java-Sprachumgebung von Net.Data sie finden kann. Normalerweise ist das ein Verzeichnis, das in der CLASSPATH-Einstellung angegeben wurde.
  5. Führen Sie das Net.Data-Makro aus, das die Java-Sprachumgebung aufruft. Stellen Sie sicher, dass der Sprachumgebungseintrag für die Java-Anwendung in der Konfigurationsdatei von Net.Data nicht die Cliette-Zeichenfolge CLIETTE "DTW_JAVAPPS" enthält oder dass diese Cliette-Zeichenfolge als Kommentar markiert ist.
Anmerkung:
Führen Sie diese Schritte jedesmal aus, wenn sich der Quellcode Ihrer Java-Funktion ändert. Diese Methode steht unter Windows, AIX, Linux und Solaris zur Verfügung.

Aufrufen von Java-Funktionen durch die Net.Data-Direktverbindung

Gehen Sie wie folgt vor, um Java-Funktionen über die Direktverbindung aufzurufen:

  1. Schreiben Sie Ihre Java-Funktionen.
  2. Erstellen Sie eine Net.Data-Cliette für alle Ihre Java-Funktionen.

    Net.Data-Cliettes starten die virtuelle Java-Maschine, über die Ihre Java-Funktionen ausgeführt werden.

  3. Definieren Sie eine Cliette in der Java-Anweisung ENVIRONMENT in der Konfigurationsdatei für Direktverbindungen.

    Bei jeder Einführung neuer Java-Funktionen müssen Sie die Java-Cliette erneut erstellen.

  4. Starten Sie Connection Manager.
  5. Führen Sie das Net.Data-Makro aus, das die Java-Sprachumgebung aufruft.

Definieren der Java-Sprachumgebungs-Cliette

Ändern Sie die Beispieldatei makeClas.bat, oder erstellen Sie eine neue BAT-Datei zum Generieren der Net.Data-Cliette-Klasse dtw_samp.class für alle Ihre Java-Funktionen. Das folgende Beispiel zeigt, wie die Stapeldatei CreateServer drei Java-Funktionen verarbeitet:

rem Batch file to create dtw_samp for Net.Data
java CreateServer dtw_samp.java UserFunctions.java myfile.java
javac dtw_samp.java

Die Stapeldatei verarbeitet die folgenden Dateien zusammen mit der von Net.Data bereitgestellten Stub-Datei Stub.java, um dtw_samp.class zu erstellen.

Erstellen der Java-Funktion

Ändern Sie die Java-Funktionsbeispieldatei UserFunctions.java mit Ihren eigenen Java-Funktionen:

====================UserFuctions.java====================
import mypackage.*
 public String myfctcall(...parameters from macro...)
{
 return ( mypackage.mymethod(...parameters...));
 }
 
public String lowlevelcall(...parameters...)
{
 string result;
  .......code using many functions of your package...
  return(result)
}
   

Dateistruktur der Java-Sprachumgebung

Net.Data erstellt während der Net.Data-Installation mehrere Verzeichnisse. Diese Verzeichnisse enthalten die Dateien, die zum Erstellen Ihrer Java-Funktionen, Definieren der Cliette und Ausführen des Makros in der Java-Sprachumgebung erforderlich sind:

Tabelle 13 beschreibt die Verzeichnis- und Dateinamen für die Dateien auf Ihrem Betriebssystem.

Tabelle 13. Zum Erstellen von Java-Funktionen verwendete Dateien
Betriebssystem Dateiname Verzeichnis
OS/2 UserFunctions.java javaapps
launchjv.com connect
Windows NT UserFunctions.java javaclas
makeClas.bat javaclas
launchjv.bat connect
AIX UserFunctions.java javaapps
launchjv javaapps
rebuild javaapps
gnu.regexp-1.0.8.jar javaapps
Linux & Solaris User Functions.java javaapps
rebuild javaapps
gnu.regexp-1.0.8.jar javaapps

Beispiel für die Java-Sprachumgebung

Nach dem Erstellen der Java-Funktion, Definieren der Cliette-Klasse, Ausführen der Datei "rebuild" und Konfigurieren von Net.Data können Sie das Makro mit Verweisen auf die Java-Funktion ausführen.

Das folgende Beispiel-Makro zeigt die Funktionsdefinition und den Funktionsaufruf der Java-Anwendungsfunktion reverse_line().

%{ to call the sample }
%FUNCTION (DTW_JAVAPPS) reverse_line(str);
 
%HTML(report){
you should see the string "Hello World" in reverse.
@reverse_line("Hello World")
You should have the result of your function call.
%}

Perl-Sprachumgebung

Die Perl-Sprachumgebung kann interne Perl-Scripts interpretieren, die in einem FUNCTION-Block des Net.Data-Makros angegeben sind, oder sie kann externe Perl-Scripts verarbeiten, die in separaten Dateien auf dem Server gespeichert sind.

Konfigurieren der Perl-Sprachumgebung

Prüfen Sie, ob sich die folgende Konfigurationsanweisung in der Net.Data-Initialisierungsdatei befindet und in einer Zeile steht:

ENVIRONMENT (DTW_PERL)     DTWPERL   ( OUT RETURN_CODE )
 

Weitere Informationen zur Net.Data-Initialisierungsdatei sowie zu Anweisungen ENVIRONMENT für die Sprachumgebung finden Sie in Umgebungskonfigurationsanweisungen.

Für Benutzer der japanischen Version:
Einige Zeichen im japanischen SJIS-Zeichensatz können von Perl als Steuerzeichen fehlinterpretiert werden. Zur Lösung dieses Problems gibt es ein Open Source-Paket mit dem Namen jperl. Laden Sie das Paket herunter, installieren Sie es, und fügen Sie anschließend die Anweisung use I18N::Japanese.pm in den Header des Perl-Scripts ein.

Aufrufen externer Perl-Scripts

Aufrufe an externe Perl-Scripts werden in einem FUNCTION-Block durch eine EXEC-Anweisung mit der folgenden Syntax angegeben:

%EXEC{ perl_script_name [optional parameters] %}
Wichtiger Hinweis: Stellen Sie sicher, dass perl_script_name, der Perl-Script-Name, in einem für die Konfigurationsvariable EXEC_PATH angegebenen Pfad in der Net.Data-Initialisierungsdatei aufgelistet ist.
 %FUNCTION(DTW_PERL) perl1() {
 %EXEC{ MyPerl.pl %}
 %}

Übergeben von Parametern

Es gibt zwei Möglichkeiten, Informationen an ein Programm zu übergeben, das durch die Perl-Sprachumgebung (DTW_PERL) aufgerufen wird: direkt und indirekt.

Direkt
Übergeben Sie Parameter direkt beim Aufruf des Perl-Scripts. Beispiel:
%DEFINE INPARM1 = "SWITCH1"
 
%FUNCTION(DTW_PERL) sys1() {
 %EXEC{
    MyPerl.pl $(INPARM1) "literal string"
 %}
%}

Die Net.Data-Variable INPARM1 wird mit einem Verweis versehen und an das Perl-Script übergeben. Die Parameter werden auf gleiche Weise an das Perl-Script übergeben wie bei einem Aufruf des Perl-Scripts über die Befehlszeile. Die Parameter, die dem Perl-Script mit dieser Methode übergeben werden, werden als Eingabeparameter behandelt und Änderungen an den Werten werden nicht an Net.Data zurückgemeldet.

Indirekt

Übergeben Sie Parameter indirekt beim Aufruf des Perl-Scripts mit einer der folgenden Methoden:

Das folgende Beispiel zeigt, wie Net.Data Variablen von einem Makro übergibt.

%FUNCTION(DTW_PERL) today() RETURNS(result) {
  $date = `date`;
  chop $date;
  open(DTW, "> $ENV{DTWPIPE}") || die "Could not open: $!";
  print DTW "result = \"$date\"\n";
%}
   %HTML(INPUT){
  @today()
%}

Wenn das Perl-Script die externe Datei today.pl ist, kann die gleiche Funktion so wie im nächsten Beispiel geschrieben werden:

%FUNCTION(DTW_PERL) today() RETURNS(result) {
  %EXEC { today.pl %}
%}

Sie können Net.Data-Tabellen an ein Perl-Script übergeben, das von der Perl-Sprachumgebung aufgerufen wird. Das Perl-Script greift auf die Werte eines Net.Data-Makrotabellenparameters anhand ihrer Net.Data-Namen zu. Die Spaltenüberschriften und Feldwerte sind in Variablen enthalten, die mit dem Tabellennamen und der Spaltennummer angegeben werden. Zum Beispiel sind in der Tabelle myTable die Spaltenüberschriften myTable_N_ j und die Feldwerte myTable_V_i_j, wobei i die Zeilennummer und j die Spaltennummer ist. Die Anzahl der Zeilen und Spalten für die Tabelle sind myTable_ROWS und myTable_COLS.

REPORT- und MESSAGE-Blöcke in FUNCTION-Blöcken

REPORT- und MESSAGE-Blöcke sind so wie in jedem anderen FUNCTION-Abschnitt zulässig. Sie werden von Net.Data und nicht von der Sprachumgebung verarbeitet. Ein Perl-Script kann jedoch Text in den Standardausgabedatenstrom schreiben, um als Teil der Webseite aufgenommen zu werden.

Beispiel für die Perl-Sprachumgebung

Das folgende Beispiel zeigt, wie Net.Data eine Tabelle durch Ausführen des externen Perl-Scripts generiert.

%define { 
 c = %TABLE(20) 
 rows = "5" 
 columns = "5" %} 
 %function(DTW_PERL) genTable(in rows, in columns, out table) { 
 open(D2W,"> $ENV{DTWPIPE}"); 
 print "genTable begins ... ";
 
 $r = $ENV{ROWS}; 
 $c = $ENV{COLUMNS}; 
 print D2W "table_ROWS=\"$r\" "; 
 print D2W "table_COLS=\"$c\" "; 
 print "rows: $r ";
 
 print "columns: $c"; 
 for ($j=1; $j<=$c; $j++) 
 {
 print D2W "table_N_$j=\"COL$j\" "; 
 }
 for ($i=1; $i<=$r; $i++) 
 {
 for ($j=1; $j<=$c; $j++) 
 {
 print D2W "table_V_$i","_","$j=\"" $i $j "\" ";
 }
 }
 close(D2W);  %}
 
 %message{ 
 default: "genTable: Unexpected Error" 
 %}
 %}
 
%HTML(REPORT){ 
 @genTable(rows, columns, c) 
 return code is $(RETURN_CODE) 
 %} 
 

Ergebnisse: genTable generiert Folgendes:

rows: 5 columns: 5   
  COL1  |  COL2   |  COL3   |  COL4   |  COL5   |  
--------------------------------------------------
[ 1 1 ] | [ 1 2 ] | [ 1 3 ] | [ 1 4 ] | [ 1 5 ] |  
--------------------------------------------------
[ 2 1 ] | [ 2 2 ] | [ 2 3 ] | [ 2 4 ] | [ 2 5 ] |  
--------------------------------------------------
[ 3 1 ] | [ 3 2 ] | [ 3 3 ] | [ 3 4 ] | [ 3 5 ] |  
--------------------------------------------------
[ 4 1 ] | [ 4 2 ] | [ 4 3 ] | [ 4 4 ] | [ 4 5 ] |  
--------------------------------------------------
[ 5 1 ] | [ 5 2 ] | [ 5 3 ] | [ 5 4 ] | [ 5 5 ] |  
--------------------------------------------------
return code is 0  

REXX-Sprachumgebung

In der REXX-Sprachumgebung können Sie REXX-Programme ausführen, die für die Ausführung in der DTW_REXX-Umgebung geschrieben wurden. Die Net.Data REXX-Sprachumgebung verfügt über Steuerelemente, mit denen REXX-Programme große Datenmengen auf einfache Weise zurückgeben können.

Net.Data stellt außerdem Unterstützung für die REXX-Anweisung SAY zur Verfügung, die die Ausgabe an den Browser leitet, und zwar unabhängig von der Webserverumgebung, die Sie für Net.Data verwenden. Wenn Sie natives REXX mit Hilfe der FastCGI-, GWAPI- oder Servlet-Konfiguration des Webservers ausführen, wird die Ausgabe der REXX-Anweisung SAY an die Protokolldatei der Webserver und nicht an den Browser weitergeleitet. Dies gilt nicht für REXX-Programme, die für die Ausführung in der DTW_REXX-Umgebung geschrieben wurden.

Unterstützung für Variablen: Damit REXX-Programme große Datenmengen einfach zurückgeben können, fügt Net.Data automatisch Code am Anfang und am Ende des REXX-Programms ein. Dieser Code soll Variablen bearbeiten, die in der DTW_REXX-Funktionsanweisung angegeben werden.

Unterstützung für REXX-Anweisung SAY (FastCGI-, GWAPI- und SERVLET-Umgebung): REXX-Anweisungen SAY werden automatisch in REXX-Zuordnungsanweisungen konvertiert, bevor das REXX-Programm ausgeführt wird. Net.Data fügt dem REXX-Programm automatisch Code hinzu, der die Ausgabe der ursprünglichen REXX-Anweisungen SAY an den Browser leiten soll.

Verwendung von REXX-Subroutinen und -Funktionen: Da Net.Data Code am Anfang und am Ende des REXX-Programms einfügt, muss die REXX-Hauptroutine mit der letzten Anweisung des REXX-Programms enden. Wenn Sie REXX-Subroutinen oder -Funktionen verwenden, müssen Sie sicherstellen, dass die letzte Anweisung des REXX-Programms der REXX-Hauptroutine zugeordnet ist. Das folgende Beispiel zeigt die Verwendung einer Subroutine und Funktion in einem REXX-Programm, das für die Ausführung in der DTW_REXX-Umgebung geschrieben wurde:

%function(DTW_REXX) genData(out s1,s2) {
         call subrtn1
         s2=funrtn1()
        signal rexxEnd  /* Go to end of Program */
      subrtn1: PROCEDURE EXPOSE s1
         string1 = "data for s1"
         return 0
      funrtn1: PROCEDURE
         retvar = "data for s2"
         return retvar
      rexxEnd:          /* End of Main Program */
         return 0
    %}
    %HTML (Report) {
  
  
    @genData(a,c)
    
  Value for s1: $(a)
    
  Value for s2: $(c)
   %}

Verwendung der REXX-Anweisungen EXIT und RETURN: Net.Data fügt REXX-Programmen automatisch Code hinzu, der Werte für Ausgabevariablen zur Verfügung stellt und die Ausgabe von SAY-Anweisungen an den Browser weiterleitet. Wenn das REXX-Programm eine Anweisung RETURN von der Hauptroutine oder eine Anweisung EXIT an einer beliebigen Position (mit Ausnahme der letzten Anweisung des REXX-Programms) ausgibt, wird der Code, den Net.Data an das REXX-Programm anfügte, nicht ausgeführt. Dies hat einen Verlust von Ausgabevariablen und der Ausgabe der SAY-Anweisungen zur Folge. Wenn Sie ein REXX-Programm vor Erreichen der letzten Anweisung beenden müssen, sollten Sie zur letzten Anweisung in dem REXX-Programm verzweigen, die normalerweise die Beendigung durchführt. Wenn Sie die Anweisung RETURN oder EXIT zum Beenden des REXX-Hauptprogramms verwenden, muss sie die letzte Anweisung im REXX-Programm sein. Dies schließt REXX-Kommentaranweisungen ein. Beispiel:

 %function(DTW_REXX) genData(out s1,s2) {
 ......
 If S2 < 0 Then signal rexxEnd
 ......
 ......
 rexxEnd:
 /* This comment must be before the following
 RETURN statement */
 return 0
 %}
 %HTML (Report) {
 @genData(a,c)
 ......
 %}

Externe REXX-Programme von einer DTW_REXX-Funktion aufrufen: Sie können ein REXX-Programm mit Hilfe der Net.Data-Anweisung %EXEC von einer DTW_REXX-Funktion oder mit Hilfe von REXX-Methoden von einem REXX-Programm aus aufrufen.

Wird ein externes REXX-Programm mit Hilfe der Net.Data-Anweisung %EXEC aufgerufen, fügt Net.Data automatisch Code am Anfang und am Ende des REXX-Programms ein, um Ausgabevariablen zu bearbeiten und Ausgabe von REXX-Anweisungen SAY an den Browser weiterzuleiten.

Wird ein REXX-Programm mit Hilfe von REXX-Methoden aufgerufen, erhält Net.Data nicht die Steuerung und fügt dem REXX-Programm keinen Code hinzu. Das aufgerufene REXX-Programm muss die Ausgabe mit Hilfe von REXX-Standardkonventionen zurück an das aufrufende REXX-Programm übergeben. Bei einer Ausführung in einer GWAPI- oder SERVLET-Umgebung wird die Ausgabe der REXX-Anweisungen SAY an die Protokolldatei der Webserver gesendet.

Konfigurieren der REXX-Sprachumgebung

Zur Verwendung der REXX-Sprachumgebung müssen Sie die Net.Data-Einstellungen für die Initialisierung prüfen und die Sprachumgebung definieren.

Prüfen Sie, ob sich die folgende Konfigurationsanweisung in der Initialisierungsdatei befindet und in einer Zeile steht:

ENVIRONMENT (DTW_REXX)     DTWREXX   ( OUT RETURN_CODE )
 

Weitere Informationen zur Net.Data-Initialisierungsdatei sowie zu ENVIRONMENT-Anweisungen für die Sprachumgebung finden Sie in Net.Data Verwaltung und Programmierung.

Ausführen von REXX-Programmen

In der REXX-Sprachumgebung können Sie sowohl interne REXX-Programme als auch externe REXX-Programme ausführen. Ein internes REXX-Programm ist ein REXX-Programm, dessen Quelle sich im Makro befindet. Bei einem externen REXX-Programm befindet sich die Quelle des REXX-Programms in einer externen Datei.

Gehen Sie wie folgt vor, um ein internes REXX-Programm auszuführen:

Definieren Sie eine Funktion, die die REXX-Sprachumgebung (DTW_REXX) verwendet und den REXX-Code in der Funktion (Abschnitt zur Ausführung in der Sprachumgebung) enthält.

Beispiel: Eine Funktion mit einem internen REXX-Programm

%function(DTW_REXX) helloWorld() {
        SAY 'Hello World'
%}

Gehen Sie wie folgt vor, um ein externes REXX-Programm auszuführen:

Definieren Sie eine Funktion, die die REXX-Sprachumgebung (DTW_REXX) verwendet und einen Pfad zu dem REXX-Programm enthält, das in einer EXEC-Anweisung ausgeführt werden soll.

Beispiel: Eine Funktion mit einer EXEC-Anweisung, die auf ein externes Programm zeigt

%function(DTW_REXX) externalHelloWorld() {        
%EXEC{ helloworld.cmd%}       
%}

Wichtiger Hinweis: Stellen Sie sicher, dass der REXX-Dateiname in einem Pfad für die Konfigurationsvariable EXEC_PATH in der Net.Data-Initialisierungsdatei aufgelistet ist. Informationen zum Definieren der Konfigurationsvariablen EXEC_PATH finden Sie in EXEC_PATH.

Übergeben von Parametern an REXX-Programme

Es gibt zwei Möglichkeiten, Informationen an ein REXX-Programm zu übergeben, das durch die REXX-Sprachumgebung (DTW_REXX) aufgerufen wird: direkt und indirekt.

Direkt
Mit der Anweisung %EXEC übergeben Sie Parameter direkt an ein externes REXX-Programm. Beispiel:
%FUNCTION(DTW_REXX) rexx1() {                               
  %EXEC{CALL1.CMD $(INPARM) "literal string"   %}                            
%}

Die Net.Data-Variable INPARM1 wird mit einem Verweis versehen und an das externe REXX-Programm übergeben. Das REXX-Programm kann durch Verwendung der Anweisung REXX PARSE ARG auf die Variable verweisen. Die Parameter, die dem REXX-Programm mit dieser Methode übergeben werden, werden als Eingabeparameter behandelt, und Änderungen der Werte werden nicht an Net.Data zurückgemeldet. (Die dem Programm übergebenen Parameter können vom Programm verwendet und bearbeitet werden, Änderungen an den Parametern werden jedoch nicht an Net.Data zurückgemeldet.)

Indirekt

Mit dem Variablenpool des REXX-Programms übergeben Sie Parameter indirekt. Wenn ein REXX-Programm gestartet wird, wird vom REXX-Interpreter ein Bereich, der Informationen zu allen Variablen enthält, erstellt und verwaltet. Dieser Bereich wird als Variablenpool bezeichnet.

Wenn eine Funktion der REXX-Sprachumgebung (DTW_REXX) aufgerufen wird, werden Eingabeparameter (IN) oder Ein-/Ausgabeparameter (INOUT) von der REXX-Sprachumgebung gespeichert, bevor das REXX-Programm ausgeführt wird. Wenn das REXX-Programm aufgerufen wird, kann es direkt auf diese Variablen zugreifen. Nach erfolgreicher Beendigung des REXX-Programms ermittelt die Sprachumgebung DTW_REXX, ob es OUT- oder INOUT-Funktionsparameter gibt. Trifft dies zu, ruft die Sprachumgebung den Wert, der dem Funktionsparameter entspricht, aus dem Variablenpool ab und aktualisiert den Funktionsparameterwert mit dem neuen Wert. Wenn Net.Data die Steuerung erhält, aktualisiert es alle OUT- oder INOUT-Parameter mit den neuen, aus der REXX-Sprachumgebung erhaltenen Werten. Beispiel:

%DEFINE a = "3"
%DEFINE b = "0"
%FUNCTION(DTW_REXX) double_func(IN inp1, OUT outp1){
   outp1 = 2*inp1
%}
 
%HTML (Report) { 
Value of b is $(b), @double_func(a, b) Value of b is $(b)
%}

Im obigen Beispiel übergibt der Aufruf @double_func zwei Parameter, a und b. Die REXX-Funktion double_func verdoppelt den ersten Parameter und speichert das Ergebnis im zweiten Parameter. Wenn Net.Data das Makro aufruft, hat b den Wert 6.

Sie können Net.Data-Tabellen an ein REXX-Programm übergeben. Ein REXX-Programm greift auf die Werte eines Net.Data-Makrotabellenparameters als REXX-Stammvariablen zu. Für ein REXX-Programm sind die Spaltenüberschriften und Feldwerte in Variablen enthalten, die mit dem Tabellennamen und der Spaltennummer angegeben werden. Zum Beispiel sind in der Tabelle myTable die Spaltenüberschriften myTable_V.j und die Feldwerte myTable_V.i.j, wobei i die Zeilennummer und j die Spaltennummer ist. Die Anzahl der Zeilen in der Tabelle ist myTable_ROWS, die Anzahl der Spalten myTable_COLS.

Leistungsoptimierung für das Betriebssystem AIX:

Wenn Sie die REXX-Sprachumgebung auf Ihrem AIX-System oft aufrufen, sollten Sie die Umgebungsvariable RXQUEUE_OWNER_PID auf 0 setzen. Makros, die viele Aufrufe an die REXX-Sprachumgebung ausführen, können viele Prozesse erstellen, die die Systemressourcen aufbrauchen.

Sie haben drei Möglichkeiten, die Umgebungsvariable einzustellen:

Beispiel für die REXX-Sprachumgebung

Das folgende Beispiel zeigt ein Makro, das eine REXX-Funktion aufruft, um eine Net.Data-Tabelle zu generieren, die zwei Spalten und drei Zeilen enthält. Nach dem Aufruf der REXX-Funktion wird eine integrierte Funktion, DTW_TB_TABLE(), aufgerufen, um eine HTML-Tabelle zu generieren, die an den Browser zurückgesendet wird.

%DEFINE myTable = %TABLE
%DEFINE DTW_DEFAULT_REPORT = "NO"  
 
%FUNCTION(DTW_REXX) genTable(out out_table) {
  out_table_ROWS = 3
  out_table_COLS = 2
 
  /* Set Column Headings */
  do j=1 to out_table_COLS
    out_table_N.j = 'COL'j
    end
 
  /* Set the fields in the row */
  do i = 1 to out_table_ROWS
    do j = 1 to out_table_COLS
      out_table_V.i.j = '[' i j ']'
    end
    end
%}
 
%HTML (Report)  {
 @genTable(myTable)
 @DTW_TB_TABLE(myTable)
%}

Ergebnisse:

<table> 
  <tr>
<th>COL1</th>
<th>COL2</th>
</tr>
<tr>
<td>[1 1]</td>
<td>[1 2],</td>
</tr>
<tr>
<td>[2 1]</td>
<td>[2 2],</td>
</tr>
<tr>
<td>[3 1]</td>
<td>[3 2],</td>
</tr>
</table>
 
 

SYSTEM-Sprachumgebung

Die SYSTEM-Sprachumgebung unterstützt das Ausführen von Befehlen und das Aufrufen externer Programme.

Konfigurieren der SYSTEM-Sprachumgebung

Fügen Sie der Initialisierungsdatei die folgende Konfigurationsanweisung in einer Zeile hinzu:

ENVIRONMENT (DTW_SYSTEM)   DTWSYS    ( OUT RETURN_CODE )

Weitere Informationen zur Net.Data-Initialisierungsdatei sowie zu ENVIRONMENT-Anweisungen für die Sprachumgebung finden Sie in Net.Data Verwaltung und Programmierung.

Absetzen von Befehlen und Aufrufen von Programmen

Definieren Sie zum Absetzen eines Befehls eine Funktion, die die SYSTEM-Sprachumgebung (DTW_SYSTEM) verwendet und einen Pfad zu dem Befehl enthält, der in einer EXEC-Anweisung abgesetzt werden soll. Beispiel:

%FUNCTION(DTW_SYSTEM) sys1() {
      %EXEC { ADDLIBLE.CMD %}
 %}

Sie können den Pfad zu ausführbaren Objekten kürzen, wenn Sie die Konfigurationsvariable EXEC_PATH zum Definieren von Pfaden zu Verzeichnissen mit den Objekten (wie Befehle und Programme) verwenden. Informationen zum Definieren der Konfigurationsvariablen EXEC_PATH finden Sie in EXEC_PATH.

Beispiel 1: Aufrufen eines Programms

%FUNCTION(DTW_SYSTEM) sys3() {
      %EXEC {MYPGM.EXE %}
 %

Übergeben von Parametern an Programme

Es gibt zwei Möglichkeiten, Informationen an ein Programm zu übergeben, das durch die SYSTEM-Sprachumgebung (DTW_SYSTEM) aufgerufen wird: direkt und indirekt.

Direkt
Sie übergeben Parameter direkt beim Aufruf des Programms. Beispiel:
%DEFINE INPARM1 = "SWITCH1"
                           
%FUNCTION(DTW_SYSTEM) sys1() {
 %EXEC{
  CALL1.CMD  $(INPARM1) "literal string"
 %}
%}

Die Net.Data-Variable INPARM1 wird mit einem Verweis versehen und an das Programm übergeben. Die Parameter werden dem Programm auf die gleiche Weise übergeben wie bei einem Aufruf des Programms von der Befehlszeile aus. Die Parameter, die dem Programm mit dieser Methode übergeben werden, werden als Eingabeparameter behandelt, und Änderungen der Werte werden nicht an Net.Data zurückgemeldet (die dem Programm übergebenen Parameter können vom Programm verwendet und bearbeitet werden, Änderungen an den Parametern werden jedoch nicht an Net.Data zurückgemeldet).

Indirekt

Die SYSTEM-Sprachumgebung kann Net.Data-Variablen nicht direkt übergeben oder abrufen. Daher werden sie Programmen auf folgende Art zur Verfügung gestellt:

Das folgende Beispiel zeigt, wie Net.Data Variablen von einem Makro übergibt.

 %FUNCTION(DTW_SYSTEM) sys1 (IN P1, OUT P2, P3) {
   %EXEC {
      UPDPGM
   %}
 %}

Sie können Net.Data-Tabellen an ein Programm übergeben, das von der SYSTEM-Sprachumgebung aufgerufen wird. Das Programm greift auf die Werte eines Net.Data-Makrotabellenparameters anhand der Net.Data-Namen dieser Werte zu. Die Spaltenüberschriften und Feldwerte sind in Variablen enthalten, die mit dem Tabellennamen und der Spaltennummer angegeben werden. Zum Beispiel sind in der Tabelle myTable die Spaltenüberschriften myTable_N_j und die Feldwerte myTable_V_i_j, wobei i die Zeilennummer und j die Spaltennummer ist. Die Anzahl der Zeilen in der Tabelle ist myTable_ROWS, die Anzahl der Spalten myTable_COLS.

Beispiel für die SYSTEM-Sprachumgebung

Das folgende Beispiel zeigt ein Makro, das eine Funktionsdefinition mit den drei Parametern P1, P2 und P3 enthält. P1 ist ein Eingabeparameter (IN), P2 und P3 sind Ausgabeparameter (OUT). Die Funktion ruft ein Programm, UPDPGM, auf, das den Parameter P2 mit dem Wert von P1 aktualisiert und P3 auf eine Zeichenfolge setzt. Vor der Verarbeitung der Anweisung im %EXEC-Block speichert die Sprachumgebung DTW_SYSTEM P1 und den zugehörigen Wert im Umgebungsbereich.

%DEFINE {
   MYPARM2 	= "ValueOfParm2"
   MYPARM3 	= "ValueOfParm3"
 %}
 %FUNCTION(DTW_SYSTEM) sys1 (IN P1, OUT P2, P3) {
   %EXEC {
      UPDPGM
   %}
 %}
 
 %HTML(upd1) {
<p>
 Passing data to a program.  The current value 
 of MYPARM2 is "$(MYPARM2)", and the current value of MYPARM3 is
 "$(MYPARM3)".  Now we invoke the Web macro function.
<p>                                                                   
 @sys1("ValueOfParm1", MYPARM2, MYPARM3)  
 
<p>
 After the function call, the value of MYPARM2 is "$(MYPARM2)", 
 and the value of MYPARM3 is "$(MYPARM3)".
<p>                                                                   
 %}


[ Seitenanfang | Vorherige Seite | Nächste Seite ]