View Full Version : RCLRSC Verständnisproblem
HiHo miteinander!
Meine Frage bezieht sich auf die OPM Umgebung und lautet wie folgt:
"Welche (RPG-)Programme sind von einem RCLRSC Aufruf mit LVL(*) betroffen?"
Ich möchte das etwas verdeutlichen:
CL-Program 'CL1' ruft per CALL RPG-Programm 'R1' auf.
R1 ruft per CALL RPG-Programm R2 auf
R2 kehrt zurück, ohne LR zu setzen.
Wenn ich nun aus R1 wiederholt R2 aufrufe, hat dieses seine alten Werte, *INZSR wird nicht durchlaufen.
Wenn ich nun aus R1 QCMDEXC RCLRSC aufrufe, wird R2 freigegeben.
Beim nächsten Aufruf von R2 wird dieses neu gestartet, inklusive Ausführung von *INZSR.
Soweit so gut.
Was ich aber nicht verstehe ich dieses Verhalten:
CL-Program 'CL1' ruft per CALL RPG-Programm 'R1' auf.
R1 ruft per CALL RPG-Programm R2 auf
R2 kehrt zurück, ohne LR zu setzen.
R1 kehrt ebenfalls zurück, und zwar zu CL1, auch ohne LR zu setzen.
Wenn ich nun aus CL1 (es ist immer noch aktiv) wieder R1 aufrufe, und dann von dort ein RCLRSC absetze, bleibt R2 davon völlig unbeeindruckt.
Ich kann R2 ab dem Moment, wo ich einmal R1 verlassen habe, nur noch vom Ursprungsskript aus freigeben.
In der Literatur habe ich dazu keine für mich klar interpretierbare Erklärung gefunden.
Wer weiss Rat?
Viele Grüße,
Edgar
Im Helptext zu RCLRSC finde ich dazu folgendes:
Example 5 (OPM)
In this example, PROGA calls PROGB, which in turn calls PROGC.
PROGC opens a file. Control returns to PROGA. PROGA calls PROGB a
second time, and PROGB invokes RCLRSC. Since RCLRSC is based upon
the position in the stack of the current invocation of a program,
the file opened by PROGC is not affected. PROGC was invoked earlier
than the current PROGB. In order for RCLRSC to close the file, the
RCLRSC command will have to be invoked by PROGA. Dies beschreibt doch genau Dein Szenario, oder?
Daher ist es wohl "works-as-designed".
Hallo Ernst,
erst mal vielen Dank für die Antwort. Den Text kenne ich, genau das hatte ich gestern auf den IBM-Seiten gefunden.
> Daher ist es wohl "works-as-designed".
Zweifelsohne. Das Problem ist nur, dass ich das Design nicht vollständig verstehe. Und zwar bereitet mir genau das hier Kopfschmerzen:
> is based upon the position in the stack
> of the current invocation of a
> program,
Denn das klassische Paradigma eines Stacks ist doch 'last-in, first out'.
Wenn also B auf den Stack gelegt wird, und dann C, dann wird in genau dieser Reihenfolge auch wieder abgeräumt: Wenn C zurückkehrt, liegt nur noch B auf den Stack. Kehrt B ebenfalls zurück, nämlich zu A, dann ist der Stack leer (abgesehen von 'A' selber natürlich),
Rufe ich nun 'B' erneut auf, liegt es wieder genau da, wo es beim ersten Mal auch war: Als Erstes auf dem Stack. Alles also genau wie vorher.
Worin besteht also der Unterschied zwischen dem Erst- und dem Zweitaufruf?
In RPG kannst du die Anweisung FREE verwenden.
Ich vermute das System "vergißt" den Aufruf von Pgm R2 wenn R1 beendet wird. Obwohl R1 ja weiterhin "aktiv" ist weil es ohne LR beendet worden ist.
Aber die "current invocation" von R1 wurde beendet.
Daher funktioniert ein RCLRSC beim zweiten Aufruf von R1 nicht weil in diesem zweiten Aufruf R2 noch nicht aufgerufen worden ist. Daher "weiß" das System (oder ignoriert es) nicht mehr, dass eigentlich R2 auch schon vorher von R1 aufgerufen worden ist.
So klingt es für mich zumindest mit dem Helptext plausibel.
Wenn Dich dies weiterhin stört hiflt wohl nur mehr ein Anruf beim IBM Helpdesk und eine Eröffnung eines PMR um dieses Problem näher zu analyisieren.
Wie ist den das mit der 'current invocation'. Ich glaube, wenn ich dazu etwas Genaueres finden könnte, käme ich ein Stück weiter.
Mal heisst das in der Dokumentation 'current-invocation' dann finde ich 'run-level', dann wieder 'stack'. Da ich nun in Erinnerung habe, dass von RCLRSC alle 'höheren run-level' betroffen sind, scheint mir der Schlüssel zum Problem in diesem Wert zu liegen.
hat jemand dazu vielleicht einen Hinweis oder Link?
PS: Nur mal zur Erläuterung: Wir implementieren hier etwas, was die RCLRSC Funktionalität nachbilden soll, deshalb möchte ich es so genau wissen.
RCLRSC nachbilden?
Vergiss es, da gehört eigentlich ziemlich viel dazu.
Ausserdem gibts ja auch noch den RCLACTGRP!
Vergiss es
Bei einem im achten Jahr laufenden Projekt ist das keine gute Option.
Ausserdem gibts ja auch noch den RCLACTGRP!
Sie oben: Nur OPM.
Wie Dieter nun sagen würde, Fehler im Design.
Wenn du sicher sein willst, dass der folgende Aufruf eines OPM's immer mit *INZSR beginnt, verwende eben die "FREE"-Anweisung.
Diese entfernt das Programm nach dem CALL.
Hallo Edgar,
bei Programmen, die ohne LR verlassen werden, habe ich immer einen Parameter MODUS, der die LR-Steuerung macht.
Logik:
- Wenn LR=0 ist, dann wird das Pgm am Ende mit LR='0' beendet
- Wenn LR=1 ist, dann wird das Pgm am Ende mit LR='1' beendet
- Wenn LR=2 ist, dann werden
1. ggf. tiefere derartige Pgm mit MODUS=2 aufgerufen,
2. dann LR='1' gesetzt,
3. und dann _direkt_ das Pgm verlassen.
Dann weiß ich wenigstens, was geschieht, und muss nicht über RCLRSC grübeln.
Ob Dir dieser Ansatz hilft?
Wenn Du dann Hunderte Programme umschreiben müsstest, suchst Du vermutlich lieber eine andere Lösung ...
Gruß, Christian