Das folgende Beispiel für die make-Funktionalität besteht aus mehrere Prozeduren.
Die Prozedur MAINPROCEDURE hat folgende Parameter:
TARGET: | Zielkomponente des make-Laufs |
SUCC-PROC: | Folgeverarbeitung |
SELECT: | Berücksichtigen der Zeitstempel |
PROCEDURE: | erzeugte Prozedur |
MAKEFILE: | Beschreibung des eigenen Programmsystems |
MAKEDEFAULTS: | Beschreibung globaler Voreinstellungen |
Die Parameter TARGET, SUCC-PROC, SELECT und PROCEDURE sind in der gleichen Weise anzugeben wie bei BEGIN-MAKE. Bei Aufruf mit den voreingestellten Parametern ist die Zielkomponente des make-Laufs das erste Ziel in MAKEDEFAULTS bzw.
MAKEFILE; es wird eine Prozedur erzeugt, die anschließend mit INCLUDE-PROCEDURE aufgerufen wird.
Die Datei MAKEDEFAULTS enthält Defaulteinstellungen und Standardaktionen, also die Teile, die von mehreren Programmsystemen gemeinsam benutzt werden können.
Die Datei MAKEFILE enthält die eigentlichen Definitionen des Programmsystems, die Abhängigkeiten.
Das Programmsystem enthält eine Phasendatei, die aus zwei Objektmodulen gebunden wird. Die Objektmodule werden aus gleichnamigen Typ-S-Elementen unter Zuhilfenahme von zwei Typ-M-Elementen übersetzt. Die Pseudo-Ziele CLEAR und PRINT ermöglichen es, spezielle Aktionen für das Programmsystem zu veranlassen (Aufräumen und Drucken).
Prozedur MAINPROCEDURE:
/DECLARE-PARAMETER (TARGET(INI-VALUE= ́*FIRST-TARGET ́),- / SUCC-PROC(INI-VALUE= ́*CREATE-PROC ́),- / SELECT(INI-VALUE= ́*MODIFIED ́),- / PROCEDURE(INI-VALUE= ́#P ́),- / MAKEFILE(INI-VALUE= ́MAKEFILE ́),- / MAKEDEFAULTS(INI-VALUE= ́MAKEDEFAULTS ́)) /SET-VAR SUB0=SUBSTR( ́&(PROCEDURE) ́,1,2) „DATEI ODER BIB.-ELEMENT" -------------- (1) /BEGIN-BLOCK DATA-INSERTION=YES /START-LMS
(1) | Zulassen der /INCLUDE-PROCEDURE-Kommandos. |
/IF (SUB0= ́*L ́) // MODIFY-LMS-DEFAULTS TYPE=J // DELETE-ELEMENT &(PROCEDURE) „BIB.-ELEMENT LOESCHEN" // STEP /ELSE // EXEC-SYSTEM-CMD DELETE-FILE &(PROCEDURE) „DATEI LOESCHEN" // STEP /END-IF //BEGIN-MAKE TARGET=&(TARGET), - ------------------------------------------------- (2) // SELECT=&(SELECT), - // SUCCESS-PROCESSING=&(SUCC-PROC), - // PROCEDURE=&(PROCEDURE) /INCLUDE-PROCEDURE NAME=&MAKEDEFAULTS -------------------------------------------- (3) /INCLUDE-PROCEDURE NAME=&MAKEFILE /END-BLOCK //END-MAKE ----------------------------------------------------------------------- (4) //END /IF (SUBSTR( ́&(SUCC-PROC) ́,2,2) <> ́CR ́)́ „NICHT CREATE-PROC" / EXIT-PROC „FOLGEVERARBEITUNG BEREITS AUSGEFUEHRT" /END-IF /INC-PROC &(PROCEDURE) „AUSFUEHREN, EVTL. NICHT VORHANDEN" /SET-JOB-STEP /EXIT-PROCEDURE
(2) | Der make-Lauf wird gestartet. |
(3) | Aufrufen von MAKEDEFAULTS und MAKEFILE. |
(4) | Die make-Subanweisungen und damit der make-Lauf werden beendet. Die make-Folgeverarbeitung, wie in BEGIN-MAKE (hier der Default INCLUDE-PROCEDURE) wird angestoßen. |
Datei MAKEDEFAULTS:
/RESUME-PROGRAM //MODIFY-MAKE-DEFAULTS LIBRARY=BSPLIB,- // CURRENT-TARGET-VAR=CURT,FROM-OBJECTS-VAR=ALLOBJ ------------------------------ (5) //SET-STD-ACTION - ---------------------------------------------------------------- (6) // TARGET-TYPE=R,FROM-TYPE=S,- // ACTION='/CALL-PROCEDURE *LIB(BSPLIB,COMPILE),(&&(CURT.ELEM))' /HOLD-PROGRAM --------------------------------------------------------------------- (7) /EXIT-PROC
(5) | Default-Bibliothek und make-Variablen werden eingestellt. Die Werte gelten für die nachfolgenden Anweisungen. |
(6) | Es wird eine Standard-Aktion (Übersetzen) für den Übergang vom Elementtyp S nach Elementtyp R vereinbart. |
(7) | Vorbereiten des Rücksprungs aus der Prozedur. |
Datei MAKEFILE:
/RESUME-PROGRAM
//SET-DEPENDENCY - --------------------------------------------------------------- (8)
// TARGET-OBJECT=PROG, -
// FROM-OBJECT=(*LIB(,TEIL1,R),*LIB(,TEIL2,R)), -
// ACTION='/CALL-PROCEDURE LINK,(OBJVAR=ALLOBJ)'
//SET-DEPENDENCY - --------------------------------------------------------------- (9)
// TARGET-OBJECT=*LIB(,*,R),-
// FROM-OBJECT=(*LIB(,*,S), *LIB(,GLOBALDATA,M), *LIB(,HEADERS,M)) ------------- (10)
//SET-DEPENDENCY - --------------------------------------------------------------- (11)
// TARGET-OBJECT=CLEAR,-
// ACTION='/CALL-PROCEDURE *LIB(BSPLIB,DELETE.TEMPS)'
//SET-DEPENDENCY - --------------------------------------------------------------- (12)
// TARGET-OBJECT=PRINT,-
// ACTION='/CALL-PROCEDURE *LIB(BSPLIB,PRINT.LISTFILES)'
//SET-PREPROCESSING - ------------------------------------------------------------ (13)
// ACTION=('/CALL-PROCEDURE *LIB(BSPLIB,INIT)',-
// '/DECL-VAR ALLOBJ(TYPE=STRUC),MULT-ELEM=LIST,SCOPE=TASK')
//SET-POSTPROCESSING - ----------------------------------------------------------- (14)
// ACTION='/CALL-PROCEDURE *LIB(BSPLIB,STOP)'
/HOLD-PROGRAM
/EXIT-PROC
(8) | Darstellung der Abhängigkeit „Phase wird aus Objektmodulen gebunden“. Die Phasendatei PROG ist das erste Ziel des make-Laufs (*FIRST-TARGET). |
(9) | Darstellung der Abhängigkeit „Objektmodul wird aus gleichnamigem Source erzeugt, weitere Komponenten (Typ M) werden benötigt.“ Die Standard-Aktion unter (3) wird verwendet. |
(10) | „Gleichnamig“ wird durch die Verwendung von make-Auswahl und -Konstruktion formuliert. Unter TARGET-OBJECT steht die Auswahl, unter FROM-OBJECT die Konstruktion. Die LMS-Einschränkung, dass die Konstruktion mindestens ein Wild-card-Symbol enthalten muss, gilt nicht für make-Konstruktionsangaben. *LIB(,HEADERS,M) enthält kein Wildcard-Symbol. |
(11) | Die Zieldatei CLEAR ist von keinem FROM-OBJECT abhängig, ist also nie aktuell. Wird CLEAR als Ziel des make-Laufs angegeben, werden Aufräumaktionen für das Programmsystem angestoßen. Die Aktionen für CLEAR sollen nicht jedesmal durchgeführt werden, wenn das Programmsystem aktualisiert wird. |
(12) | Wie (11). Als Aktion für PRINT ist das Drucken von Ergebnissen vorgesehen. |
(13) | Wenn eine Prozedur erzeugt wird, soll die Aktion ́/CALL INIT ́ an deren Anfang gestellt werden. Ebenfalls soll die Variable ALLOBJ taskglobal deklariert werden, da sie später in der Prozedur LINK importiert werden soll. Die Deklaration wird im Ablauf der erzeugten Prozedur nicht überschrieben. |
(14) | Wenn eine Prozedur erzeugt wird, soll die Aktion ́/CALL STOP ́ an deren Ende gestellt werden. |
Die Datei MAKEFILE soll noch in einer, dem UNIX-make ähnlichen Schreibweise vorgestellt werden:
Datei MAKEFILE:
/RESUME-PROGRAM
//SET-DEPENDENCY PROG, (*LIB(,TEIL1,R),*LIB(,TEIL2,R)), -
// '/CALL-PROCEDURE *LIB(BSPLIB,LINK),(OBJVAR=ALLOBJ)'
//SET-DEPENDENCY *LIB(,*,R),(*LIB(,*,S),*LIB(,GLOBALDATA,M),*LIB(,HEADERS,M))
//SET-DEPENDENCY CLEAR, *NONE,-
// '/CALL-PROCEDURE *LIB(BSPLIB,DELETE.TEMPS)'
//SET-DEPENDENCY PRINT, *NONE,-
// '/CALL-PROCEDURE *LIB(BSPLIB,PRINT.LISTFILES)'
//SET-PREPROCESSING ('/CALL-PROCEDURE *LIB(BSPLIB,INIT)',-
// '/DECL-VAR ALLOBJ(TYPE=STRUC),MULT-ELEM=LIST,SCOPE=TASK')
//SET-POSTPROCESSING '/CALL-PROCEDURE *LIB(BSPLIB,STOP)'
/HOLD-PROGRAM
/EXIT-PROC
Wenn das Programmsystem vollständig erzeugt werden muss, sieht die resultierende Prozedur im Prinzip so aus:
/DECL-VAR SYSLMSMAKE(TYPE=STRUC(DEF=*DYN)) --------------------------------------- (1) /CALL-PROCEDURE *LIB(BSPLIB,INIT) /DECL-VAR ALLOBJ(TYPE=STRUC),MULT-ELEM=*LIST,SCOPE=*TASK /IF-BLOCK-ERROR ------------------------------------------------------------------ (2) /EXIT-PROCEDURE /END-IF /DECLARE-VARIABLE CURT(TYPE=*STRUC) ---------------------------------------------- (3) /IF-BLOCK-ERROR /END-IF ... /SET-VARIABLE CURT.ELEM = 'TEIL1' ------------------------------------------------ (4) ... /CALL-PROCEDURE *LIB(BSPLIB,COMPILE),(&(CURT.ELEM)) ... /SET-VARIABLE CURT.ELEM = 'TEIL2' ... /CALL-PROCEDURE *LIB(BSPLIB,COMPILE),(&(CURT.ELEM)) ... /DECLARE-VARIABLE ALLOBJ(TYPE=*STRUC),MULT-ELEM=*LIST ---------------------------- (5) /IF-BLOCK-ERROR /END-IF /FREE-VARIABLE ALLOBJ ... /SET-VARIABLE SYSLMSMAKE.ELEM = 'TEIL1' ... /SET-VARIABLE ALLOBJ = SYSLMSMAKE,MODE=APPEND ------------------------------------ (6) /SET-VARIABLE SYSLMSMAKE.ELEM = 'TEIL2' ... /SET-VARIABLE ALLOBJ = SYSLMSMAKE,MODE=APPEND /CALL-PROCEDURE *LIB(BSPLIB,LINK),(OBJVAR=ALLOBJ) ... /CALL-PROCEDURE *LIB(BSPLIB,STOP)
(1) | Deklaration der make-internen Hilfsvariablen zum Listenaufbau. |
(2) | Diese Anweisungsfolge wird nach jeder Aktion (außer POSTPROCESSING) eingefügt, um einen sauberen Fehlerrückzug zu gewährleisten. |
(3) | Deklarieren von CURT (Fehler werden toleriert, da CURT z.B. global deklariert sein kann). |
(4) | Die anderen Komponenten der S-Variablen sowie der S-Listenvariable ALLOBJ werden ebenfalls gesetzt. |
(5) | Deklarieren einer leeren S-Listenvariablen für ALLOBJ. Die Behandlung von ALLOBJ findet ebenfalls vor den anderen Prozeduraufrufen statt. Das Ergebnis wird dort jedoch nicht verwendet. |
(6) | Anhängen der FROM-OBJECTS an die S-Listenvariable ALLOBJ. |
Die in MAKEFILE gerufenen Prozeduren haben folgende Schnittstellen:
INIT und STOP haben keine Parameter.
COMPILE hat nur einen Elementnamen als Parameter, Bibliothek und andere Informationen werden der Einfachheit halber nicht eingegeben.
LINK hat den Namen einer S-Listenvariablen als Eingabe, die alle Objekte enthält, die zusammengebunden werden sollen. Die Listenvariable wird wie im folgenden Muster abgearbeitet:
/DECL-PAR NAME=INPUTVAR(TYPE=STRING) /DECL-VAR I(TYPE=STRUC(DEF=*DYN)) /IMPORT-VAR &(INPUTVAR) ----------------------------------------------------------- (1) ... /FOR I=*LIST(&INPUTVAR) ----------------------------------------------------------- (2) / DO-SOMETHING ... &(I) -------------------------------------------------------- (3) /END-FOR
(1) | Importieren der angegebenen Listenvariablen (sie muss taskglobal sein). |
(2) | Aufzählen der Listenelemente in der Variablen I. |
(3) | Verwenden von I entweder direkt in SDF-Eingaben, oder in /SEND-DATA oder /SEND-STATEMENT. |