//BCHJOB JOB(JCLN) JOBD(NERONI2/NERONI2) OUTQ(QPRINT) + ENDSEV(60) LOG(4 00 *SECLVL) MSGQ(*USRPRF) CCSID(280) /* Open source from www.neroni.it */ /* LA JOB DESCRIPTION "NERONI2/NERONI2" DEVE PREESISTERE. PUO' ESSERE */ /* IDENTICA A QBATCH E PUO' ESSERE SOSTITUITA DA QBATCH O SIMILE. */ /* From System: "DEV720" */ /* From Library: "NERONI2" */ /* Unload Time: 2016-05-31 16:46 */ /* To File : "JCLN" */ /* To Library : "NERONI2" */ /* To Text : "Cleanings. Src" */ /********* INIZIO ISTRUZIONI **************************************************/ /* LE SUCCESSIVE ISTRUZIONI PERMETTONO DI RICARICARE I SORGENTI. */ /* 1) DA UN VIDEO COMANDI DELL'AS400 RICEVENTE */ /* CREARE UN FILE SORGENTE DI LUNGHEZZA RECORD 112: */ /* CRTSRCPF FILE(NERONI2/STRINGHE) RCDLEN(112) */ /* 2) SPOSTARE IL FILE "JCLN.txt" NELL'INDIRIZZARIO */ /* DI UN PC CONNESSO IN RETE CON L'AS400 RICEVENTE */ /* (AD ES.: "c:\"). */ /* 3) DAL VIDEO COMANDI DEL PC CHIAMARE FTP: */ /* ftp nomeas400 */ /* 4) DIGITARE UTENTE E PASSWORD. */ /* 5) ESEGUIRE IL COMANDO DI COPIA DA FILE PC A MEMBRO AS400: */ /* put "c:\JCLN.txt" "/qsys.lib/NERONI2.lib/stringhe.file/JCLN.mbr" */ /* 6) ABBANDONARE FTP: */ /* quit */ /* 7) DA UN VIDEO COMANDI DELL'AS400 RICEVENTE */ /* ESEGUIRE LA STRINGA COPIATA NEL MEMBRO SORGENTE: */ /* SBMDBJOB FILE(NERONI2/STRINGHE) MBR(JCLN) JOBQ(QBATCH) */ /* LE SUCCESSIVE ISTRUZIONI PERMETTONO DI CREARE L'UTILITY. */ /* 8) DA UN VIDEO COMANDI DELL'AS400 RICEVENTE */ /* ESEGUIRE LA STRINGA O LE STRINGHE SORGENTE DI TIPO SEU "CL" */ /* (IL CUI NOME TERMINA SEMPRE CON ".") */ /* PRESENTI NEL FILE RICARICATO "NERONI2/JCLN" */ /* FACENDO ATTENZIONE ALL'ORDINE DI ESECUZIONE INDICATO NEL */ /* MEMBRO FACOLTATIVO "A.LEGGIMI", AD ESEMPIO: */ /* SBMDBJOB FILE(NERONI2/JCLN) MBR(JCLN.) JOBQ(QBATCH) */ /********* FINE ISTRUZIONI ****************************************************/ /* Crea la libreria. */ MKDIR DIR('/qsys.lib/NERONI2.lib') CHGLIB LIB(NERONI2) TEXT('Claudio Neroni Utility') /* Imposta la lista librerie. */ CHGLIBL LIBL(QTEMP NERONI2 QGPL) /* Crea il file sorgente. */ DLTF FILE(NERONI2/JCLN) CRTSRCPF FILE(NERONI2/JCLN) RCDLEN(112) + TEXT('Cleanings. Src') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLN.BPFMX) TOFILE(NERONI2/JCLN) + TOMBR(JCLN.BPFMX) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLN.BPFMX) + SRCTYPE(CL) + TEXT('Analisi BPMFXSOTF su AS400H') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLN.BPMF) TOFILE(NERONI2/JCLN) + TOMBR(JCLN.BPMF) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLN.BPMF) + SRCTYPE(CL) + TEXT('Analisi BPMF su AS400B') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLN.NERO) TOFILE(NERONI2/JCLN) + TOMBR(JCLN.NERO) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLN.NERO) + SRCTYPE(CL) + TEXT('Analisi UFNERONI+NERONI2 su AS400H') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLN.NNERO) TOFILE(NERONI2/JCLN) + TOMBR(JCLN.NNERO) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLN.NNERO) + SRCTYPE(CL) + TEXT('Analisi TRK+NERONI2 su DEV720') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLN.PRIS) TOFILE(NERONI2/JCLN) + TOMBR(JCLN.PRIS) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLN.PRIS) + SRCTYPE(CL) + TEXT('Analisi PRIS su AS400B') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLN.TST) TOFILE(NERONI2/JCLN) + TOMBR(JCLN.TST) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLN.TST) + SRCTYPE(CL) + TEXT('Analisi UFNEROTST su AS400H') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF) + SRCTYPE(CMD) + TEXT('Cleanings Phy. Procedure Help. Cmd') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF.) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF.) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF.) + SRCTYPE(CL) + TEXT('Cleanings Phy. CrtJs') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPFC) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPFC) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPFC) + SRCTYPE(CLLE) + TEXT('Cleanings Phy. Procedure Help. Cpp') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPFCA) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPFCA) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPFCA) + SRCTYPE(PF) + TEXT('Cleanings Phy. Candidates') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPFCDL) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPFCDL) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPFCDL) + SRCTYPE(CLLE) + TEXT('Cleanings Phy. ChkDupLib') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPFFF) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPFFF) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPFFF) + SRCTYPE(PF) + TEXT('Cleanings Phy. ForcedFlags') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPFFFQ) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPFFFQ) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPFFFQ) + SRCTYPE(QMQRY) + TEXT('Cleanings Phy. ForcedFlagsQry') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPFFFQI) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPFFFQI) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPFFFQI) + SRCTYPE(CL) + TEXT('Cleanings Phy. ForcedFlagsQry Inter') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPFMB) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPFMB) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPFMB) + SRCTYPE(PF) + TEXT('Cleanings Phy. Mbr') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPFMB1) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPFMB1) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPFMB1) + SRCTYPE(LF) + TEXT('Cleanings Phy. Mbr') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPFOD) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPFOD) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPFOD) + SRCTYPE(PF) + TEXT('Cleanings Phy. ObjD') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPFOD1) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPFOD1) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPFOD1) + SRCTYPE(LF) + TEXT('Cleanings Phy. ObjD') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPFP) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPFP) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPFP) + SRCTYPE(PNLGRP) + TEXT('Cleanings Phy. Procedure Help. Help') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF1) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF1) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF1) + SRCTYPE(CMD) + TEXT('Cleanings Phy. Crt&FillWrkLib. Cmd') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF1C) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF1C) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF1C) + SRCTYPE(CLLE) + TEXT('Cleanings Phy. Crt&FillWrkLib. Cpp') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF1D) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF1D) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF1D) + SRCTYPE(RPGLE) + TEXT('Cleanings Phy. Crt&FillWrkLib. DltLibInfo') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF1P) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF1P) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF1P) + SRCTYPE(PNLGRP) + TEXT('Cleanings Phy. Crt&FillWrkLib. Help') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF2) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF2) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF2) + SRCTYPE(CMD) + TEXT('Cleanings Phy. SltCandidates. Cmd') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF2C) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF2C) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF2C) + SRCTYPE(CLLE) + TEXT('Cleanings Phy. SltCandidates. Cpp') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF2D) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF2D) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF2D) + SRCTYPE(RPGLE) + TEXT('Cleanings Phy. SltCandidates. Wri') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF2E) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF2E) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF2E) + SRCTYPE(RPGLE) + TEXT('Cleanings Phy. SltCandidates. Analysis') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF2F) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF2F) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF2F) + SRCTYPE(RPGLE) + TEXT('Cleanings Phy. SltCandidates. ReadPrvParm') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF2P) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF2P) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF2P) + SRCTYPE(PNLGRP) + TEXT('Cleanings Phy. SltCandidates. Help') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF3) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF3) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF3) + SRCTYPE(CMD) + TEXT('Cleanings Phy. MngForcedFlags. Cmd') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF3C) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF3C) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF3C) + SRCTYPE(CLLE) + TEXT('Cleanings Phy. MngForcedFlags. Cpp') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF3D) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF3D) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF3D) + SRCTYPE(RPGLE) + TEXT('Cleanings Phy. MngForcedFlags. Wri') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF3E) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF3E) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF3E) + SRCTYPE(RPGLE) + TEXT('Cleanings Phy. MngForcedFlags. Analysis') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF3F) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF3F) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF3F) + SRCTYPE(RPGLE) + TEXT('Cleanings Phy. MngForcedFlags. ClrNull') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF3P) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF3P) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF3P) + SRCTYPE(PNLGRP) + TEXT('Cleanings Phy. MngForcedFlags. Help') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF4) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF4) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF4) + SRCTYPE(CMD) + TEXT('Cleanings Phy. Dup. Cmd') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF4C) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF4C) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF4C) + SRCTYPE(CLLE) + TEXT('Cleanings Phy. Dup. Cpp') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF4D) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF4D) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF4D) + SRCTYPE(CLLE) + TEXT('Cleanings Phy. Dup. Chk&Dup') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF4P) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF4P) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF4P) + SRCTYPE(PNLGRP) + TEXT('Cleanings Phy. Dup. Help') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF5) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF5) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF5) + SRCTYPE(CMD) + TEXT('Cleanings Phy. Dlt. Cmd') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF5C) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF5C) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF5C) + SRCTYPE(CLLE) + TEXT('Cleanings Phy. Dlt. Cpp') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF5D) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF5D) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF5D) + SRCTYPE(CLLE) + TEXT('Cleanings Phy. Dlt. Chk&Dlt') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF5P) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF5P) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF5P) + SRCTYPE(PNLGRP) + TEXT('Cleanings Phy. Dlt. Help') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF8) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF8) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF8) + SRCTYPE(CMD) + TEXT('Cleanings Phy. DupMbr. Cmd') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF8C) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF8C) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF8C) + SRCTYPE(CLLE) + TEXT('Cleanings Phy. DupMbr. Cpp') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF8I) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF8I) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF8I) + SRCTYPE(CMD) + TEXT('Cleanings Phy. DupMbr. CmdInteract') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF8X) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF8X) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF8X) + SRCTYPE(CMD) + TEXT('Cleanings Phy. DltMbr. Cmd') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF8XC) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF8XC) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF8XC) + SRCTYPE(CLLE) + TEXT('Cleanings Phy. DltMbr. Cpp') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF8XI) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF8XI) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF8XI) + SRCTYPE(CMD) + TEXT('Cleanings Phy. DltMbr. CmdInteract') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF9) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF9) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF9) + SRCTYPE(CMD) + TEXT('Cleanings Phy. DupFile. Cmd') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF9C) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF9C) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF9C) + SRCTYPE(CLLE) + TEXT('Cleanings Phy. DupFile. Cpp') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF9I) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF9I) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF9I) + SRCTYPE(CMD) + TEXT('Cleanings Phy. DupFile. CmdInteract') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF9X) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF9X) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF9X) + SRCTYPE(CMD) + TEXT('Cleanings Phy. DltFile. Cmd') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF9XC) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF9XC) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF9XC) + SRCTYPE(CLLE) + TEXT('Cleanings Phy. DltFile. Cpp') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNPF9XI) TOFILE(NERONI2/JCLN) + TOMBR(JCLNPF9XI) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNPF9XI) + SRCTYPE(CMD) + TEXT('Cleanings Phy. DltFile. CmdInteract') /* Copia il sorgente dalla stringa al membro del file sorgente. */ /* Modifica testo e tipo seu del sorgente caricato. */ CPYF FROMFILE(JCLNTSTDAT) TOFILE(NERONI2/JCLN) + TOMBR(JCLNTSTDAT) MBROPT(*REPLACE) SRCOPT(*SEQNBR) CHGPFM FILE(NERONI2/JCLN) MBR(JCLNTSTDAT) + SRCTYPE(RPGLE) + TEXT('Cleanings. Test date.') /*----------------------------------------------------------------------------*/ //DATA FILE(JCLN.BPFMX) FILETYPE(*SRC) ENDCHAR('//ENDSRC') //BCHJOB JOB(JCLN.BPFMX) JOBD(NERONI2/NERONI2) OUTQ(QPRINTS) + ENDSEV(60) LOG(4 00 *SECLVL) MSGQ(*USRPRF) JCMD JCLNPF1 WRK(BPMFX) LIB(BPMFXSOTF) MBROPT(*REPLACE) JCLNPF2 WRK(BPMFX) SLTDAT(150815) SLTCNT(2) JCLNPF3 WRK(BPMFX) JCLNPF4 WRK(BPMFX) //ENDBCHJOB //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLN.BPMF) FILETYPE(*SRC) ENDCHAR('//ENDSRC') //BCHJOB JOB(JCLN.BPMF) JOBD(NERONI2/NERONI2) OUTQ(QPRINTS) + ENDSEV(60) LOG(4 00 *SECLVL) MSGQ(*USRPRF) JCMD JNETLIBL LIBR(BPMFNETF) AMBI(SOTS) JCLNPF1 WRK(BPMF) LIB(*USRLIBL) MBROPT(*REPLACE) TEXT('JNETLIBL + LIBR(BPMFNETF) AMBI(SOTS)') JCLNPF2 WRK(BPMF) SLTDAT(01012012) SLTCNT(2) JCLNPF3 WRK(BPMF) JCLNPF4 WRK(BPMF) RUN(*DIAG) //ENDBCHJOB //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLN.NERO) FILETYPE(*SRC) ENDCHAR('//ENDSRC') //BCHJOB JOB(JCLN.NERO) JOBD(NERONI2/NERONI2) OUTQ(QPRINTS) + ENDSEV(60) LOG(4 00 *SECLVL) MSGQ(*USRPRF) JCMD JCLNPF1 WRK(NERO) LIB(UFNERONI) TEXT(*LIB) JCLNPF1 WRK(NERO) LIB(NERONI2) MBROPT(*ADD) TEXT(*LIBADD) JCLNPF2 WRK(NERO) SLTDAT(01012012) SLTCNT(2) JCLNPF3 WRK(NERO) JCLNPF4 WRK(NERO) RUN(*DIAG) //ENDBCHJOB //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLN.NNERO) FILETYPE(*SRC) ENDCHAR('//ENDSRC') //BCHJOB JOB(JCLN.NNERO) JOBD(NERONI2/NERONI2) OUTQ(QPRINTS) + ENDSEV(60) LOG(4 00 *SECLVL) MSGQ(*USRPRF) CCSID(280) jcmd jmy JCLNPF1 WRK(NNERO) LIB(TRK) TEXT(*LIB) JCLNPF1 WRK(NNERO) LIB(NERONI2) MBROPT(*ADD) TEXT(*LIBADD) JCLNPF2 WRK(NNERO) SLTDAT(01012012) SLTCNT(2) JCLNPF3 WRK(NNERO) JCLNPF4 WRK(NNERO) RUN(*DIAG) //ENDBCHJOB //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLN.PRIS) FILETYPE(*SRC) ENDCHAR('//ENDSRC') //BCHJOB JOB(JCLN.PRIS) JOBD(NERONI2/NERONI2) OUTQ(QPRINTS) + ENDSEV(60) LOG(4 00 *SECLVL) MSGQ(*USRPRF) JCMD JNETLIBL LIBR(BPMFNETF) AMBI(PRIS) JCLNPF1 WRK(PRIS) TEXT('JNETLIBL LIBR(BPMFNETF) AMBI(PRIS)') JCLNPF2 WRK(PRIS) SLTDAT(01012012) SLTCNT(2) JCLNPF3 WRK(PRIS) JCLNPF4 WRK(PRIS) RUN(*DIAG) //ENDBCHJOB //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLN.TST) FILETYPE(*SRC) ENDCHAR('//ENDSRC') //BCHJOB JOB(JCLN.TST) JOBD(NERONI2/NERONI2) OUTQ(QPRINTS) + ENDSEV(60) LOG(4 00 *SECLVL) MSGQ(*USRPRF) JCMD JCLNPF1 WRK(TST) LIB(UFNEROTST) MBROPT(*REPLACE) JCLNPF2 WRK(TST) SLTDAT(01012012) SLTCNT(2) JCLNPF3 WRK(TST) JCLNPF4 WRK(TST) RUN(*DIAG) //ENDBCHJOB //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 03-05-2016 Creato. */ /* Cleanings Phy. Procedure Help. Cmd */ /* Pulizie Fisici. Aiuto per la Procedura. Cmd */ /* */ CMD PROMPT('Cleanings Physical Files Help') //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF.) FILETYPE(*SRC) ENDCHAR('//ENDSRC') //BCHJOB JOB(JCLNPF.) JOBD(NERONI2/NERONI2) OUTQ(QPRINTS) + ENDSEV(60) LOG(4 00 *SECLVL) MSGQ(*USRPRF) CCSID(280) jcmd jmy /* Claudio Neroni 09-09-2015 Creato. */ /* JCLNPF */ /* Cleanings Physical. */ /* Pulizie Fisici. */ /* Prerequisiti: JCPYCLR JRQT JRSNMSG JDECCHA JLOG JRSTF JRTVFD */ /* Imposta la lista librerie. */ CHGLIBL LIBL(QTEMP QGPL) ADDLIBLE LIB(NERONI2) POSITION(*AFTER QTEMP) /* Cancella il file messaggi preesistente. */ DLTMSGF MSGF(NERONI2/JCLNPF) /* Cancella i testi d'aiuto preesistenti. */ DLTPNLGRP PNLGRP(NERONI2/JCLNPFP) DLTPNLGRP PNLGRP(NERONI2/JCLNPF1P) DLTPNLGRP PNLGRP(NERONI2/JCLNPF2P) DLTPNLGRP PNLGRP(NERONI2/JCLNPF3P) DLTPNLGRP PNLGRP(NERONI2/JCLNPF4P) DLTPNLGRP PNLGRP(NERONI2/JCLNPF5P) DLTPNLGRP PNLGRP(NERONI2/JCLNPF8P) DLTPNLGRP PNLGRP(NERONI2/JCLNPF8XP) DLTPNLGRP PNLGRP(NERONI2/JCLNPF9P) DLTPNLGRP PNLGRP(NERONI2/JCLNPF9XP) /* Cancella i logici preesistenti. */ DLTF FILE(NERONI2/JCLNPFMB1) DLTF FILE(NERONI2/JCLNPFOD1) /* Cancella i fisici preesistenti. */ DLTF FILE(NERONI2/JCLNPFMB) DLTF FILE(NERONI2/JCLNPFCA) DLTF FILE(NERONI2/JCLNPFOD) DLTF FILE(NERONI2/JCLNPFFF) /* Cancella i comandi preesistenti. */ DLTCMD CMD(NERONI2/JCLNPF) DLTCMD CMD(NERONI2/JCLNPF1) DLTCMD CMD(NERONI2/JCLNPF2) DLTCMD CMD(NERONI2/JCLNPF3) DLTCMD CMD(NERONI2/JCLNPF4) DLTCMD CMD(NERONI2/JCLNPF5) DLTCMD CMD(NERONI2/JCLNPF8) DLTCMD CMD(NERONI2/JCLNPF8I) DLTCMD CMD(NERONI2/JCLNPF8X) DLTCMD CMD(NERONI2/JCLNPF8XI) DLTCMD CMD(NERONI2/JCLNPF9) DLTCMD CMD(NERONI2/JCLNPF9I) DLTCMD CMD(NERONI2/JCLNPF9X) DLTCMD CMD(NERONI2/JCLNPF9XI) /* Cancella i programmi preesistenti. */ DLTPGM PGM(NERONI2/JCLNPFC) DLTPGM PGM(NERONI2/JCLNPFCDL) DLTPGM PGM(NERONI2/JCLNPF1C) DLTPGM PGM(NERONI2/JCLNPF1D) DLTPGM PGM(NERONI2/JCLNPF2C) DLTPGM PGM(NERONI2/JCLNPF2D) DLTPGM PGM(NERONI2/JCLNPF2E) DLTPGM PGM(NERONI2/JCLNPF2F) DLTPGM PGM(NERONI2/JCLNPF3C) DLTPGM PGM(NERONI2/JCLNPF3D) DLTPGM PGM(NERONI2/JCLNPF3E) DLTPGM PGM(NERONI2/JCLNPF3F) DLTPGM PGM(NERONI2/JCLNPF4C) DLTPGM PGM(NERONI2/JCLNPF4D) DLTPGM PGM(NERONI2/JCLNPF5C) DLTPGM PGM(NERONI2/JCLNPF5D) DLTPGM PGM(NERONI2/JCLNPF8C) DLTPGM PGM(NERONI2/JCLNPF8XC) DLTPGM PGM(NERONI2/JCLNPF9C) DLTPGM PGM(NERONI2/JCLNPF9XC) DLTPGM PGM(NERONI2/JCLNTSTDAT) /* Crea i file fisici. */ CRTPF FILE(NERONI2/JCLNPFMB) SRCFILE(JCLN) SIZE(*NOMAX) + LVLCHK(*YES) CRTPF FILE(NERONI2/JCLNPFCA) SRCFILE(JCLN) SIZE(*NOMAX) + LVLCHK(*YES) CRTPF FILE(NERONI2/JCLNPFOD) SRCFILE(JCLN) SIZE(*NOMAX) + LVLCHK(*YES) CRTPF FILE(NERONI2/JCLNPFFF) SRCFILE(JCLN) SIZE(*NOMAX) + LVLCHK(*YES) dsplibl /* Crea i file logici. */ CRTLF FILE(NERONI2/JCLNPFMB1) SRCFILE(JCLN) + LVLCHK(*YES) CRTLF FILE(NERONI2/JCLNPFOD1) SRCFILE(JCLN) + LVLCHK(*YES) /* Crea i comandi. */ CRTCMD CMD(NERONI2/JCLNPF) PGM(JCLNPFC) SRCFILE(JCLN) + HLPPNLGRP(JCLNPFP) HLPID(CMD) PRDLIB(NERONI2) CRTCMD CMD(NERONI2/JCLNPF1) PGM(JCLNPF1C) SRCFILE(JCLN) + HLPPNLGRP(JCLNPF1P) HLPID(CMD) PRDLIB(NERONI2) CRTCMD CMD(NERONI2/JCLNPF2) PGM(JCLNPF2C) SRCFILE(JCLN) + HLPPNLGRP(JCLNPF2P) HLPID(CMD) PRDLIB(NERONI2) CRTCMD CMD(NERONI2/JCLNPF3) PGM(JCLNPF3C) SRCFILE(JCLN) + HLPPNLGRP(JCLNPF3P) HLPID(CMD) PRDLIB(NERONI2) CRTCMD CMD(NERONI2/JCLNPF4) PGM(JCLNPF4C) SRCFILE(JCLN) + HLPPNLGRP(JCLNPF4P) HLPID(CMD) PRDLIB(NERONI2) CRTCMD CMD(NERONI2/JCLNPF5) PGM(JCLNPF5C) SRCFILE(JCLN) + HLPPNLGRP(JCLNPF5P) HLPID(CMD) PRDLIB(NERONI2) CRTCMD CMD(NERONI2/JCLNPF8) PGM(JCLNPF8C) SRCFILE(JCLN) + ALLOW(*IPGM *BPGM) HLPPNLGRP(JCLNPF8P) HLPID(CMD) + PRDLIB(NERONI2) CRTCMD CMD(NERONI2/JCLNPF8I) PGM(JCLNPF8C) SRCFILE(JCLN) + HLPPNLGRP(JCLNPF8P) HLPID(CMD) PRDLIB(NERONI2) CRTCMD CMD(NERONI2/JCLNPF8X) PGM(JCLNPF8XC) SRCFILE(JCLN) + ALLOW(*IPGM *BPGM) HLPPNLGRP(JCLNPF8XP) HLPID(CMD) + PRDLIB(NERONI2) CRTCMD CMD(NERONI2/JCLNPF8XI) PGM(JCLNPF8XC) SRCFILE(JCLN) + HLPPNLGRP(JCLNPF8XP) HLPID(CMD) PRDLIB(NERONI2) CRTCMD CMD(NERONI2/JCLNPF9) PGM(JCLNPF9C) SRCFILE(JCLN) + ALLOW(*IPGM *BPGM) HLPPNLGRP(JCLNPF9P) HLPID(CMD) + PRDLIB(NERONI2) CRTCMD CMD(NERONI2/JCLNPF9I) PGM(JCLNPF9C) SRCFILE(JCLN) + HLPPNLGRP(JCLNPF9P) HLPID(CMD) PRDLIB(NERONI2) CRTCMD CMD(NERONI2/JCLNPF9X) PGM(JCLNPF9XC) SRCFILE(JCLN) + ALLOW(*IPGM *BPGM) HLPPNLGRP(JCLNPF9XP) HLPID(CMD) + PRDLIB(NERONI2) CRTCMD CMD(NERONI2/JCLNPF9XI) PGM(JCLNPF9XC) SRCFILE(JCLN) + HLPPNLGRP(JCLNPF9XP) HLPID(CMD) PRDLIB(NERONI2) /* Duplica i comandi in QGPL. */ CRTPRXCMD CMD(QGPL/JCLNPF ) TGTCMD(NERONI2/JCLNPF ) AUT(*USE) + REPLACE(*YES) CRTPRXCMD CMD(QGPL/JCLNPF1 ) TGTCMD(NERONI2/JCLNPF1 ) AUT(*USE) + REPLACE(*YES) CRTPRXCMD CMD(QGPL/JCLNPF2 ) TGTCMD(NERONI2/JCLNPF2 ) AUT(*USE) + REPLACE(*YES) CRTPRXCMD CMD(QGPL/JCLNPF3 ) TGTCMD(NERONI2/JCLNPF3 ) AUT(*USE) + REPLACE(*YES) CRTPRXCMD CMD(QGPL/JCLNPF4 ) TGTCMD(NERONI2/JCLNPF4 ) AUT(*USE) + REPLACE(*YES) CRTPRXCMD CMD(QGPL/JCLNPF5 ) TGTCMD(NERONI2/JCLNPF5 ) AUT(*USE) + REPLACE(*YES) CRTPRXCMD CMD(QGPL/JCLNPF8 ) TGTCMD(NERONI2/JCLNPF8 ) AUT(*USE) + REPLACE(*YES) CRTPRXCMD CMD(QGPL/JCLNPF8I ) TGTCMD(NERONI2/JCLNPF8I ) AUT(*USE) + REPLACE(*YES) CRTPRXCMD CMD(QGPL/JCLNPF8X ) TGTCMD(NERONI2/JCLNPF8X ) AUT(*USE) + REPLACE(*YES) CRTPRXCMD CMD(QGPL/JCLNPF8XI) TGTCMD(NERONI2/JCLNPF8XI) AUT(*USE) + REPLACE(*YES) CRTPRXCMD CMD(QGPL/JCLNPF9 ) TGTCMD(NERONI2/JCLNPF9 ) AUT(*USE) + REPLACE(*YES) CRTPRXCMD CMD(QGPL/JCLNPF9I ) TGTCMD(NERONI2/JCLNPF9I ) AUT(*USE) + REPLACE(*YES) CRTPRXCMD CMD(QGPL/JCLNPF9X ) TGTCMD(NERONI2/JCLNPF9X ) AUT(*USE) + REPLACE(*YES) CRTPRXCMD CMD(QGPL/JCLNPF9XI) TGTCMD(NERONI2/JCLNPF9XI) AUT(*USE) + REPLACE(*YES) /* Crea i programmi. */ CRTBNDCL PGM(NERONI2/JCLNPFC) SRCFILE(JCLN) TGTRLS(*CURRENT) + DBGVIEW(*ALL) CRTBNDCL PGM(NERONI2/JCLNPFCDL) SRCFILE(JCLN) TGTRLS(*CURRENT) + DBGVIEW(*ALL) CRTBNDCL PGM(NERONI2/JCLNPF1C) SRCFILE(JCLN) TGTRLS(*CURRENT) + DBGVIEW(*ALL) CRTBNDRPG PGM(NERONI2/JCLNPF1D) SRCFILE(JCLN) DBGVIEW(*ALL) + TGTRLS(*CURRENT) CRTBNDCL PGM(NERONI2/JCLNPF2C) SRCFILE(JCLN) TGTRLS(*CURRENT) + DBGVIEW(*ALL) CRTBNDRPG PGM(NERONI2/JCLNPF2D) SRCFILE(JCLN) DBGVIEW(*ALL) + TGTRLS(*CURRENT) CRTBNDRPG PGM(NERONI2/JCLNPF2E) SRCFILE(JCLN) DBGVIEW(*ALL) + TGTRLS(*CURRENT) CRTBNDRPG PGM(NERONI2/JCLNPF2F) SRCFILE(JCLN) DBGVIEW(*ALL) + TGTRLS(*CURRENT) CRTBNDCL PGM(NERONI2/JCLNPF3C) SRCFILE(JCLN) TGTRLS(*CURRENT) + DBGVIEW(*ALL) CRTBNDRPG PGM(NERONI2/JCLNPF3D) SRCFILE(JCLN) DBGVIEW(*ALL) + TGTRLS(*CURRENT) CRTBNDRPG PGM(NERONI2/JCLNPF3E) SRCFILE(JCLN) DBGVIEW(*ALL) + TGTRLS(*CURRENT) CRTBNDRPG PGM(NERONI2/JCLNPF3F) SRCFILE(JCLN) DBGVIEW(*ALL) + TGTRLS(*CURRENT) CRTBNDCL PGM(NERONI2/JCLNPF4C) SRCFILE(JCLN) TGTRLS(*CURRENT) + DBGVIEW(*ALL) CRTBNDCL PGM(NERONI2/JCLNPF4D) SRCFILE(JCLN) TGTRLS(*CURRENT) + DBGVIEW(*ALL) CRTBNDCL PGM(NERONI2/JCLNPF5C) SRCFILE(JCLN) TGTRLS(*CURRENT) + DBGVIEW(*ALL) CRTBNDCL PGM(NERONI2/JCLNPF5D) SRCFILE(JCLN) TGTRLS(*CURRENT) + DBGVIEW(*ALL) CRTBNDCL PGM(NERONI2/JCLNPF8C) SRCFILE(JCLN) TGTRLS(*CURRENT) + DBGVIEW(*ALL) CRTBNDCL PGM(NERONI2/JCLNPF8XC) SRCFILE(JCLN) TGTRLS(*CURRENT) + DBGVIEW(*ALL) CRTBNDCL PGM(NERONI2/JCLNPF9C) SRCFILE(JCLN) TGTRLS(*CURRENT) + DBGVIEW(*ALL) CRTBNDCL PGM(NERONI2/JCLNPF9XC) SRCFILE(JCLN) TGTRLS(*CURRENT) + DBGVIEW(*ALL) CRTBNDRPG PGM(NERONI2/JCLNTSTDAT) SRCFILE(JCLN) DBGVIEW(*ALL) + TGTRLS(*CURRENT) /* Crea il file messaggi. */ CRTMSGF MSGF(NERONI2/JCLNPF) TEXT('Cleanings Phy. Msgf') /* Messaggi comuni a pgm di comandi diversi. */ ADDMSGD MSGID(JCL0001) MSGF(NERONI2/JCLNPF) MSG('Esamina il testo + d''aiuto!') SECLVL('Il presente command processing + program esegue un comando creato solo in funzione + dell''Help al quale da'' accesso.') ADDMSGD MSGID(JCL0002) MSGF(NERONI2/JCLNPF) MSG('->Non esiste la + work library: &1') SECLVL('La work library richiesta + "&1" non esiste. La generazione della work library + avviene tramite il comando "JCLNPF1 WRK(&2) ..." + corredato degli opportuni parametri.') FMT((*CHAR 10) + (*CHAR 6)) ADDMSGD MSGID(JCL0003) MSGF(NERONI2/JCLNPF) MSG('->Non esiste la + libreria datrice &1') SECLVL('La libreria "&1" da + analizzare per la pianificazione della pulizia dei + membri non piu'' usati non esiste.') FMT((*CHAR 10)) ADDMSGD MSGID(JCL0004) MSGF(NERONI2/JCLNPF) MSG('->Non esiste la + libreria ricevente &1') SECLVL('La libreria "&1" + destinataria della duplicazione dei membri da + rimuovere non esiste.') FMT((*CHAR 10)) ADDMSGD MSGID(JCL0005) MSGF(NERONI2/JCLNPF) MSG('->Libreria + ricevente &1 gia'' in elaborazione tramite &3') + SECLVL('La libreria "&1" destinataria della + duplicazione dei membri da rimuovere non puo'' essere + trattata dalla libreria di lavoro "&2" perche'' gia'' + in elaborazione tramite la libreria di lavoro "&3".') + FMT((*CHAR 10) (*CHAR 10) (*CHAR 10)) ADDMSGD MSGID(JCL0006) MSGF(NERONI2/JCLNPF) MSG('->Nome libreria + datrice troppo lungo (max 9 car). Libreria: &1') + SECLVL('Il nome automatico della libreria ricevente + viene normalmente ottenuto aggiungendo il carattere + "§" al nome della datrice. Se pero'' il nome della + datrice "&1" e troppo lungo perche'' supera i 9 + caratteri, il nome della ricevente viene ottenuto + sostituendo il decimo carattere della datrice con "§". + Questo mette a rischio l''univocita'' del nome + automatico della libreria ricevente. L''elaborazione + continua ma occorre verificare in fase diagnostica che + il nome della ricevente resti unico quando si eseguono + piu'' processi di pulizia contemporaneamente in modo + tale da evitare l''uso della stessa libreria come + ricevente in processi diversi.') FMT((*CHAR 10)) ADDMSGD MSGID(JCL0099) MSGF(NERONI2/JCLNPF) MSG('->ERRORE SENZA + MESSAGGIO') SECLVL('&1') FMT((*CHAR 1024)) /* Messaggi nei pgm del Cmd 1. */ ADDMSGD MSGID(JCL0101) MSGF(NERONI2/JCLNPF) MSG('->Verifica + esistenza database in WorkLib: &1') SECLVL('Verifica + l''esistenza del database di servizio nella work + library "&1".') FMT((*CHAR 10)) ADDMSGD MSGID(JCL0102) MSGF(NERONI2/JCLNPF) MSG('->Se + MBROPT(*ADD) WorkLib &1 deve preesistere.') SECLVL('Se + si vogliono aggiungere informazioni da un''altra + libreria o lista librerie al database di servizio + nella work library "&1", la work library deve essere + stata creata in precedenza.') FMT((*CHAR 10)) ADDMSGD MSGID(JCL0103) MSGF(NERONI2/JCLNPF) MSG('->Display File + Desc Type Member in corso lib &2') SECLVL('E'' in + corso l''estrazione nella work library "&1" di + informazioni su tutti i membri dei file fisici + contenuti nella libreria "&2".') FMT((*CHAR 10) (*CHAR + 10)) ADDMSGD MSGID(JCL0104) MSGF(NERONI2/JCLNPF) MSG('->Display + Object Desc Type File Detail Full in corso lib &2') + SECLVL('E'' in corso l''estrazione nella work library + "&1" di informazioni con dettaglio full di tutti gli + oggetti di tipo file contenuti nella libreria "&2".') + FMT((*CHAR 10) (*CHAR 10)) ADDMSGD MSGID(JCL0105) MSGF(NERONI2/JCLNPF) MSG('->Tentata + estrazione gia'' eseguita') SECLVL('L''estrazione + corrente e'' gia'' stata eseguita in precedenza. I + dati potrebbero non essere corretti. Ripeti la + creazione della work library &1 dall''inizio.') + FMT((*CHAR 10)) ADDMSGD MSGID(JCL0106) MSGF(NERONI2/JCLNPF) MSG('->Nome libreria + &1 non permesso') SECLVL('Il nome della libreria "&1" + non e'' permesso perche'' lungo 10 caratteri e con il + decimo carattere uguale a "§". Tale carattere nella + presente procedura e'' la lettera finale usata nei + nomi automatici creati per le librerie riceventi dello + spostamento degli oggetti da rimuovere. Sono tollerati + ma sconsigliati nomi piu'' corti di 10 caratteri con + il medesimo carattere terminale.') FMT((*CHAR 10)) ADDMSGD MSGID(JCL0107) MSGF(NERONI2/JCLNPF) MSG('->Sostituzione + info solo per specifica libreria') SECLVL('Se viene + richiesta la sostituzione delle informazioni di una + libreria, il nome libreria non puo'' essere un nome + generico che inizia per "*" come quello fornito "&1". + Cambia nome.') FMT((*CHAR 10)) ADDMSGD MSGID(JCL0110) MSGF(NERONI2/JCLNPF) MSG('->Creata e + riempita WorkLib &1 per pulizia file fisici di &2') + SECLVL('La work library "&1" per la pulizia dei file + fisici e'' stata riempita con le informazioni relative + alla libreria "&2".') FMT((*CHAR 10) (*CHAR 10)) ADDMSGD MSGID(JCL0111) MSGF(NERONI2/JCLNPF) MSG('->Aggiunte info + a WorkLib &1 per pulizia file fisici di &2') + SECLVL('Nella work library "&1" per la pulizia dei + file fisici sono state aggiunte informazioni relative + alla libreria "&2".') FMT((*CHAR 10) (*CHAR 10)) ADDMSGD MSGID(JCL0112) MSGF(NERONI2/JCLNPF) MSG('->Sostituite in + WorkLib &1 info su libreria &2') SECLVL('Nella work + library "&1" per la pulizia dei file fisici sono state + sostituite le informazioni relative alla libreria + "&2".') FMT((*CHAR 10) (*CHAR 10)) /* Messaggi nei pgm del Cmd 2. */ ADDMSGD MSGID(JCL0201) MSGF(NERONI2/JCLNPF) MSG('->Genera elenco + membri candidati a pulizia. WorkLib: &4') SECLVL('Il + corrente comando &P JCLNPF2 WRK(&1) SLTDAT(''&2'') + SLTCNT(&3) &N genera un elenco dei membri candidati a + pulizia dalla work library "&4".') FMT((*CHAR 6) + (*CHAR 7) (*DEC 5 0) (*CHAR 10)) ADDMSGD MSGID(JCL0202) MSGF(NERONI2/JCLNPF) MSG('->Data ultimo uso + &1 formalmente non valida') FMT((*CHAR 7)) ADDMSGD MSGID(JCL0203) MSGF(NERONI2/JCLNPF) MSG('->Data ultima + modifica &1 formalmente non valida') FMT((*CHAR 7)) ADDMSGD MSGID(JCL0204) MSGF(NERONI2/JCLNPF) MSG('->Non esistono run + precedenti che permettano date *PRV') ADDMSGD MSGID(JCL0210) MSGF(NERONI2/JCLNPF) MSG('->Generato + elenco di &2 membri candidati a pulizia. WorkLib: &1') + SECLVL('Nell''elenco dei membri candidati a pulizia + della work library "&1" sono presenti &2 record.') + FMT((*CHAR 10) (*DEC 10 0)) ADDMSGD MSGID(JCL0211) MSGF(NERONI2/JCLNPF) MSG('->Da trasferire + &6 membri. Vedi secondo livello') SECLVL('Analisi + delle ricorrenze dei "Selection Flag": "Initial" + "Forced" "Final". &P Initial off &1 &P Initial on &2 + &P Forced off &3 &P Forced on &4 &P Final off &5 + &P Final on &6 &P Forced off <> Initial &7 &P + Forced off = Initial &8 inutili &P Forced on <> + Initial &9 &P Forced on = Initial &10 inutili') + FMT((*DEC 10 0) (*DEC 10 0) (*DEC 10 0) (*DEC 10 0) + (*DEC 10 0) (*DEC 10 0) (*DEC 10 0) (*DEC 10 0) (*DEC + 10 0) (*DEC 10 0)) /* Messaggi nei pgm del Cmd 3. */ ADDMSGD MSGID(JCL0301) MSGF(NERONI2/JCLNPF) MSG('->Riempie il + file dei flag di forzatura. WorkLib: &1') SECLVL('Il + corrente comando genera lo scheletro sul quale + inserire gli eventuali flag di forzatura nella work + library "&1". La forzatura puo'' essere &P + *off=NonTrasferireMai oppure &P + *on=TrasferisciSempre.') FMT((*CHAR 10)) ADDMSGD MSGID(JCL0310) MSGF(NERONI2/JCLNPF) MSG('->Sostituito + file flag di forzatura &2 record. WorkLib: &1') + SECLVL('L''elenco dei record sui quali scrivere gli + eventuali flag di forzatura e'' stato sostituito nella + work library "&1" e contiene &2 record.') FMT((*CHAR + 10) (*DEC 10 0)) ADDMSGD MSGID(JCL0311) MSGF(NERONI2/JCLNPF) MSG('->Aggiunti &2 + record mancanti a flag di forzatura. WorkLib: &1') + SECLVL('L''elenco dei record sui quali scrivere gli + eventuali flag di forzatura e'' stato completato con + &2 record mancanti nella work library "&1".') + FMT((*CHAR 10) (*DEC 10 0)) ADDMSGD MSGID(JCL0312) MSGF(NERONI2/JCLNPF) MSG('->Presenti &5 + forzature. Vedi secondo livello') SECLVL('Analisi + delle ricorrenze dei "Forced Selection Flag". &P + Record Count &1 &P Forced ON &2 &P Forced OFF + &3 &P Forced NONE &4 &P Forced ON/OFF &5') FMT((*DEC + 10 0) (*DEC 10 0) (*DEC 10 0) (*DEC 10 0) (*DEC 10 0) + (*DEC 10 0) (*DEC 10 0) (*DEC 10 0) (*DEC 10 0) (*DEC + 10 0)) ADDMSGD MSGID(JCL0313) MSGF(NERONI2/JCLNPF) MSG('->Per riportare + i flag da ForcedFlags a Candidates, vedi secondo + livello') SECLVL('Dopo le eventuali modifiche al file + dei flag forzati, per riportare i flag sul file dei + membri candidati alla pulizia, eseguire &P JCLNPF2 + WRK(&1) SLTUSE(*PRV) SLTCHG(*PRV)') FMT((*CHAR 6)) ADDMSGD MSGID(JCL0314) MSGF(NERONI2/JCLNPF) MSG('->Eliminati &2 + record da forzature. Ne restano &3. WorkLib: &1') + SECLVL('Dall''elenco dei flag di forzatura della work + library "&1" sono stati eliminati &2 record + inutilizzati. Ne restano &3 con la forzatura + valorizzata.') FMT((*CHAR 10) (*DEC 10 0) (*DEC 10)) /* Messaggi nei pgm del Cmd 4. */ ADDMSGD MSGID(JCL0401) MSGF(NERONI2/JCLNPF) MSG('->Run &1 + Spostamenti') SECLVL('Il run corrente degli + spostamenti e'' di tipo &1. I tipi possibili sono &P + *DIAG = Diagnostico prima dell''esecuzione &P *EXEC = + Esecutivo') FMT((*CHAR 10)) ADDMSGD MSGID(JCL0402) MSGF(NERONI2/JCLNPF) MSG('->Elabora + duplicazione membri scelti tramite WorkLib &1') + SECLVL('Il comando corrente elabora le richieste di + duplicazione relative alla pulizia delle librerie + esaminate tramite la work library "&1".') FMT((*CHAR 10)) ADDMSGD MSGID(JCL0403) MSGF(NERONI2/JCLNPF) MSG('->Legge elenco + membri da spostare. WorkLib: &1') SECLVL('E'' in corso + la lettura dell''elenco dei membri da spostare + contenuto nella work library "&1".') FMT((*CHAR 10)) ADDMSGD MSGID(JCL0405) MSGF(NERONI2/JCLNPF) MSG('&1&2') + SECLVL('Libreria datrice "&3" "&4". Libreria ricevente + "&5" "&6". &P "0"=NON ESISTE "1"=ESISTE') FMT((*CHAR + 34) (*CHAR 34) (*CHAR 10) (*CHAR 1) (*CHAR 10) (*CHAR 1)) ADDMSGD MSGID(JCL0406) MSGF(NERONI2/JCLNPF) MSG('->ERRORE: + Libreria datrice &1 uguale a libreria ricevente') + SECLVL('Il nome della libreria datrice "&1" e'' uguale + al nome della libreria ricevente "&2". La presente + attivita'' sara'' possibile solo cambiando nome alla + libreria datrice. Il decimo carattere del nome della + datrice non puo'' essere per nessuna ragione il + carattere "§", riservato alla corrente procedura.') + FMT((*CHAR 10) (*CHAR 10)) ADDMSGD MSGID(JCL0407) MSGF(NERONI2/JCLNPF) MSG('->Creata + libreria ricevente &1') SECLVL('La libreria "&1" + ricevente degli spostamenti di oggetti e'' stata + creata prima dell''uso.') FMT((*CHAR 10)) ADDMSGD MSGID(JCL0410) MSGF(NERONI2/JCLNPF) MSG('->Esaminato + elenco membri da spostare. WorkLib: &1') SECLVL('E'' + stato esaminato l''elenco dei membri da spostare + contenuto nella work library "&1".') FMT((*CHAR 10)) ADDMSGD MSGID(JCL0411) MSGF(NERONI2/JCLNPF) MSG('->NESSUNA + LIBRERIA DA PULIRE') SECLVL('Nella work library "&1" + non esistono richieste di pulizia per nessuna + libreria. Rivedi la sequenza dei comandi JCLNPF1-2-3 + eseguiti per la work library "&1" che precedono la + presente esecuzione di JCLNPF4.') FMT((*CHAR 10)) ADDMSGD MSGID(JCL0412) MSGF(NERONI2/JCLNPF) MSG('->ERRORE + IMPREVISTO SU Lib:&1 File:&2 Mbr:&3') SECLVL('Durante + il controllo degli spostamenti da eseguire dalle + librerie datrici alle librerie riceventi, si e'' + verificato un errore imprevisto durante l''esame del + membro "&3" del file "&2" nella libreria "&1". Per + valutare quale sia l''errore, esaminare la joblog del + lavoro subito prima del presente messaggio.') + FMT((*CHAR 10) (*CHAR 10) (*CHAR 10)) ADDMSGD MSGID(JCL0413) MSGF(NERONI2/JCLNPF) MSG('->Wrk:&1 Obj:&2 + ToMov:&3 Desap:&4 Chg:&5 Err:&6 Alrd:&7 Dup:&8 Siz:&9 + Fre:&10') SECLVL('L''esame della work library "&1" + segnala la presenza nelle librerie dati di &2 oggetti + dei quali &3 da muovere nelle librerie riceventi a + scopo di salvataggio prima della pulizia. Si segnalano + tuttavia &4 oggetti spariti e &5 oggetti con una + situazione di aggiornamento o uso cambiata dopo + l''esame originale. Si sono verificati &6 errori di + duplicazione. &7 oggetti esistono gia''. Eseguite &8 + duplicazioni. In base alle segnalazioni del presente + run, valutare se passare all''esecuzione dei + trasferimenti. Spazio occupato &9. Spazio liberabile + &10.') FMT((*CHAR 10) (*DEC 9 0) (*DEC 9 0) (*DEC 9 0) + (*DEC 9 0) (*DEC 9 0) (*DEC 9 0) (*DEC 9 0) (*DEC 15 + 0) (*DEC 15 0)) ADDMSGD MSGID(JCL0414) MSGF(NERONI2/JCLNPF) MSG('->Lib:&1 Obj:&2 + ToMov:&3 Desap:&4 Chg:&5 Err:&6 Alrd:&7 Dup:&8 Siz:&9 + Fre:&10') SECLVL('Nella libreria dati "&1" sono + presenti &2 oggetti dei quali &3 da muovere nella + libreria ricevente a scopo di salvataggio prima della + pulizia. Si segnalano tuttavia &4 oggetti spariti e &5 + oggetti con una situazione di aggiornamento o uso + cambiata dopo l''esame originale. Si sono verificati + &6 errori di duplicazione. &7 oggetti esistono gia''. + Eseguite &8 duplicazioni. Spazio occupato &9. Spazio + liberabile &10.') FMT((*CHAR 10) (*DEC 9 0) (*DEC 9 0) + (*DEC 9 0) (*DEC 9 0) (*DEC 9 0) (*DEC 9 0) (*DEC 9 0) + (*DEC 15 0) (*DEC 15 0)) ADDMSGD MSGID(JCL0421) MSGF(NERONI2/JCLNPF) MSG('->Run &1. + Spostamenti diagnosticati: esamina i messaggi.') + SECLVL('Run di tipo "&1" per la work library "&2". + Esamina i messaggi diagnostici dello spostamento. Se + la diagnosi e'' soddisfacente, si puo'' procedere + all''esecuzione tramite il parametro RUN(*EXEC) in + luogo di RUN(*DIAG).') FMT((*CHAR 10) (*CHAR 10)) ADDMSGD MSGID(JCL0422) MSGF(NERONI2/JCLNPF) MSG('->Run &1. + Duplicazione eseguita: esamina i messaggi.') + SECLVL('Run di tipo "&1" per la work library "&2". + Esamina i messaggi esecutivi della duplicazione. Le + duplicazioni mancanti vengono ritentate ad ogni run + del comando di tipo *EXEC. Per completare lo + spostamento, occorre ancora eliminare gli originali + che sono stati duplicati tramite il comando + "JCLNPF5".') FMT((*CHAR 10) (*CHAR 10)) ADDMSGD MSGID(JCL0424) MSGF(NERONI2/JCLNPF) MSG('->Run &1. + ERRORE: TIPO DI RUN IMPREVISTO.') SECLVL('IL PARAMETRO + "TIPO DI RUN" HA UN VALORE IMPREVISTO. IL PGM + SEGNALANTE VA INVOCATO TRAMITE L''APPOSITO COMANDO + "JCLNPF4" CHE FILTRA IL VALORE DEI PARAMETRI') + FMT((*CHAR 10) (*CHAR 10)) /* Messaggi nei pgm del Cmd 5. */ ADDMSGD MSGID(JCL0501) MSGF(NERONI2/JCLNPF) MSG('->Run &1 + Cancellazioni') SECLVL('Il run corrente delle + cancellazioni e'' di tipo &1. I tipi possibili sono &P + *DIAG = Diagnostico prima dell''esecuzione &P *EXEC = + Esecutivo') FMT((*CHAR 10)) ADDMSGD MSGID(JCL0502) MSGF(NERONI2/JCLNPF) MSG('->Elabora + cancellazione membri scelti tramite WorkLib &1') + SECLVL('Il comando corrente elabora le richieste di + cancellazione finale relative alla pulizia delle + librerie esaminate tramite la work library "&1".') + FMT((*CHAR 10)) ADDMSGD MSGID(JCL0503) MSGF(NERONI2/JCLNPF) MSG('->Legge elenco + membri da cancellare. WorkLib: &1') SECLVL('E'' in + corso la lettura dell''elenco dei membri da cancellare + contenuto nella work library "&1".') FMT((*CHAR 10)) ADDMSGD MSGID(JCL0505) MSGF(NERONI2/JCLNPF) MSG('Lib datrice &1. + Lib ricevente &2.') SECLVL('Libreria datrice "&1". + Libreria ricevente "&2".') FMT((*CHAR 10) (*CHAR 10)) ADDMSGD MSGID(JCL0506) MSGF(NERONI2/JCLNPF) MSG('->ERRORE: + Libreria datrice &1 uguale a libreria ricevente') + SECLVL('Errore terminale, gia'' segnalato nelle fasi + precedenti. La presente attivita'' non puo'' essere + svolta.') FMT((*CHAR 10)) ADDMSGD MSGID(JCL0510) MSGF(NERONI2/JCLNPF) MSG('->Esaminato + elenco membri da cancellare. WorkLib: &1') SECLVL('E'' + stato esaminato l''elenco dei membri da cancellare + contenuto nella work library "&1".') FMT((*CHAR 10)) ADDMSGD MSGID(JCL0512) MSGF(NERONI2/JCLNPF) MSG('->ERRORE + IMPREVISTO SU Lib:&1 File:&2 Mbr:&3') SECLVL('Durante + il controllo o l''esecuzione delle cancellazioni nelle + librerie datrici alle librerie riceventi, si e'' + verificato un errore imprevisto durante l''esame del + membro "&3" del file "&2" nella libreria "&1". Per + valutare quale sia l''errore, esaminare la joblog del + lavoro subito prima del presente messaggio.') + FMT((*CHAR 10) (*CHAR 10) (*CHAR 10)) ADDMSGD MSGID(JCL0513) MSGF(NERONI2/JCLNPF) MSG('->Obj:&2 + ToMov:&3 InOri:&5 InSav:&6 NoSav:&4 Err:&7 Chg:&8 + Dlt:&9') SECLVL('L''esame della work library "&1" + segnala la presenza nelle librerie dati di &2 oggetti + dei quali &3 da muovere nelle librerie riceventi a + scopo di salvataggio prima della pulizia. Si segnalano + &5 oggetti ancora esistenti nelle librerie originali; + &6 presenti nel salvataggio; &4 mancanti nel + salvataggio; &7 in errore; &8 modificati dopo la + duplicazione; &9 cancellati in questo run dagli + originali.') FMT((*CHAR 10) (*DEC 9 0) (*DEC 9 0) + (*DEC 9 0) (*DEC 9 0) (*DEC 9 0) (*DEC 9 0) (*DEC 9 0) + (*DEC 9 0)) ADDMSGD MSGID(JCL0514) MSGF(NERONI2/JCLNPF) MSG('->Lib:&1 Obj:&2 + ToMov:&3 InOri:&5 InSav:&6 NoSav:&4 Err:&7 Chg:&8 + Dlt:&9') SECLVL('Nella libreria dati "&1" sono + presenti &2 oggetti dei quali &3 da muovere nella + libreria ricevente a scopo di salvataggio prima della + pulizia. Si segnalano &5 oggetti ancora esistenti + nella libreria originale; &6 presenti nel salvataggio; + &4 mancanti nel salvataggio; &7 in errore; &8 + modificati dopo la duplicazione; &9 cancellati in + questo run dagli originali.') FMT((*CHAR 10) (*DEC 9 + 0) (*DEC 9 0) (*DEC 9 0) (*DEC 9 0) (*DEC 9 0) (*DEC 9 + 0) (*DEC 9 0) (*DEC 9 0)) ADDMSGD MSGID(JCL0521) MSGF(NERONI2/JCLNPF) MSG('->Run &1. + Cancellazioni diagnosticate: esamina i messaggi.') + SECLVL('Run di tipo "&1" per la work library "&2". + Esamina i messaggi diagnostici della cancellazione. Se + la diagnosi e'' soddisfacente, si puo'' procedere + all''esecuzione tramite il parametro RUN(*EXEC) in + luogo di RUN(*DIAG).') FMT((*CHAR 10) (*CHAR 10)) ADDMSGD MSGID(JCL0522) MSGF(NERONI2/JCLNPF) MSG('->Run &1. + Cancellazioni eseguite: esamina i messaggi.') + SECLVL('Run di tipo "&1" per la work library "&2". + Esamina i messaggi esecutivi della cancellazione. Le + cancellazioni mancanti vengono ritentate ad ogni run + del comando di tipo *EXEC. Con questa attivitā si + conclude la presente procedura. Occorre ancora salvare + fuori linea le librerie dei duplicati.') FMT((*CHAR + 10) (*CHAR 10)) ADDMSGD MSGID(JCL0523) MSGF(NERONI2/JCLNPF) MSG('->Run &1. + Spostamenti controllati:esamina i messaggi.') + SECLVL('Run di tipo "&1" per la work library "&2". + Esamina i messaggi di controllo dello spostamento.') + FMT((*CHAR 10) (*CHAR 10)) ADDMSGD MSGID(JCL0524) MSGF(NERONI2/JCLNPF) MSG('->Run &1. + ERRORE: TIPO DI RUN IMPREVISTO.') SECLVL('IL PARAMETRO + "TIPO DI RUN" HA UN VALORE IMPREVISTO. IL PGM + SEGNALANTE VA INVOCATO TRAMITE L''APPOSITO COMANDO + "JCLNPF5" CHE FILTRA IL VALORE DEI PARAMETRI') + FMT((*CHAR 10) (*CHAR 10)) /* Messaggi nei pgm del Cmd 8. */ ADDMSGD MSGID(JCL0810) MSGF(NERONI2/JCLNPF) MSG('->ERRORE + IMPREVISTO SU Lib:&1 File:&2 Mbr:&3') SECLVL('Si e'' + verificato un errore imprevisto durante la + duplicazione del membro "&3" del file "&2" dalla + libreria datrice "&1" alla libreria ricevente "&4".') + FMT((*CHAR 10) (*CHAR 10) (*CHAR 10) (*CHAR 10)) /* Messaggi nei pgm del Cmd 8X. */ ADDMSGD MSGID(JCL0820) MSGF(NERONI2/JCLNPF) MSG('->ERRORE + IMPREVISTO SU Lib:&1 File:&2 Mbr:&3') SECLVL('Si e'' + verificato un errore imprevisto durante la + cancellazione del membro "&3" del file "&2" dalla + libreria datrice "&1". Libreria ricevente "&4".') + FMT((*CHAR 10) (*CHAR 10) (*CHAR 10) (*CHAR 10)) ADDMSGD MSGID(JCL0821) MSGF(NERONI2/JCLNPF) MSG('ChkDlt &1/&2-&3 + Err&5 Frm&6 To&7 Neq&8 Dlt&9') SECLVL('Esito del + controllo sulla cancellazione del membro "&3" del file + "&2" dalla libreria datrice "&1". &P Libreria + ricevente "&4". &P Error:"&5" &P ExistFrom:"&6" &P + ExistTo:"&7" &P NotEqual:"&8" &P DeletedFrom:"&9"') + FMT((*CHAR 10) (*CHAR 10) (*CHAR 10) (*CHAR 10) (*CHAR + 1) (*CHAR 1) (*CHAR 1) (*CHAR 1) (*CHAR 1)) /* Messaggi nei pgm del Cmd 9. */ ADDMSGD MSGID(JCL0910) MSGF(NERONI2/JCLNPF) MSG('->ERRORE + IMPREVISTO SU Lib:&1 File:&2') SECLVL('Si e'' + verificato un errore imprevisto durante la + duplicazione del file "&2" dalla libreria datrice "&1" + alla libreria ricevente "&3".') FMT((*CHAR 10) (*CHAR + 10) (*CHAR 10)) /* Messaggi nei pgm del Cmd 9X. */ ADDMSGD MSGID(JCL0920) MSGF(NERONI2/JCLNPF) MSG('->ERRORE + IMPREVISTO SU Lib:&1 File:&2') SECLVL('Si e'' + verificato un errore imprevisto durante la + cancellazione del file "&2" dalla libreria datrice + "&1". Libreria ricevente "&3".') FMT((*CHAR 10) (*CHAR + 10) (*CHAR 10)) ADDMSGD MSGID(JCL0921) MSGF(NERONI2/JCLNPF) MSG('ChkDlt &1/&2 + Err&4 Frm&5 To&6 Neq&7 Dlt&8') SECLVL('Esito del + controllo sulla cancellazione del file "&2" dalla + libreria datrice "&1". &P Libreria ricevente "&3". &P + Error:"&4" &P ExistFrom:"&5" &P ExistTo:"&6" &P + NotEqual:"&7" &P DeletedFrom:"&8"') FMT((*CHAR 10) + (*CHAR 10) (*CHAR 10) (*CHAR 1) (*CHAR 1) (*CHAR 1) + (*CHAR 1) (*CHAR 1)) /* Messaggi dei Cmd. */ ADDMSGD MSGID(JCL1001) MSGF(NERONI2/JCLNPF) MSG('NESTLOC permesso + solo se UPDTYPE eguale a *NEST o *BOTH.') /* Duplica il file messaggi in QGPL. */ DLTMSGF MSGF(QGPL/JCLNPF) CRTDUPOBJ OBJ(JCLNPF) FROMLIB(NERONI2) OBJTYPE(*MSGF) TOLIB(QGPL) /* Crea i testi d'aiuto. */ CRTPNLGRP PNLGRP(NERONI2/JCLNPF1P) SRCFILE(JCLN) CRTPNLGRP PNLGRP(NERONI2/JCLNPF2P) SRCFILE(JCLN) CRTPNLGRP PNLGRP(NERONI2/JCLNPF3P) SRCFILE(JCLN) CRTPNLGRP PNLGRP(NERONI2/JCLNPF4P) SRCFILE(JCLN) CRTPNLGRP PNLGRP(NERONI2/JCLNPF5P) SRCFILE(JCLN) CRTPNLGRP PNLGRP(NERONI2/JCLNPF8P) SRCFILE(JCLN) CRTPNLGRP PNLGRP(NERONI2/JCLNPF8XP) SRCFILE(JCLN) CRTPNLGRP PNLGRP(NERONI2/JCLNPF9P) SRCFILE(JCLN) CRTPNLGRP PNLGRP(NERONI2/JCLNPF9XP) SRCFILE(JCLN) CRTPNLGRP PNLGRP(NERONI2/JCLNPFP) SRCFILE(JCLN) //ENDBCHJOB //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPFC) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 03-05-2016 Creato. */ /* Programma vuoto per permettere Help di procedura. */ /* */ PGM SNDPGMMSG MSGID(JCL0001) MSGF(JCLNPF) ENDPGM //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPFCA) FILETYPE(*SRC) ENDCHAR('//ENDSRC') * Claudio Neroni 10-09-2015 Creato. * Cleanings. Physical. Candidates * Candidate members to cleaning. * Membri candidati alla pulizia. * Claudio Neroni 11-12-2015 Modificato. * Aggiunta dimensione totale. A R CMR A TEXT('Candidate members + A to cleaning.') A CMINFG 1 A COLHDG('Initial' + A 'selection' + A 'flag' ) A VALUES('0' '1') A CMFRFG 1 A COLHDG('Forced' + A 'selection' + A 'flag' ) A VALUES(' ' '0' '1') A CMFIFG 1 A COLHDG('Final' + A 'selection' + A 'flag' ) A VALUES(' ' '0' '1') A CMSYSN 8 A COLHDG('System') A CMLIB 10 A COLHDG('Library') A CMFILE 10 A COLHDG('File') A CMNAME 10 A COLHDG('Member') A CMUDAT L A COLHDG('Last use' + A 'member' + A 'date' ) A CMUCNT 5S 0 A COLHDG('Use' + A 'member' + A 'days' ) A CMCDAT L A COLHDG('Creation' + A 'member' + A 'date' ) A CMCTIM T A COLHDG('Creation' + A 'member' + A 'time' ) A CMGDAT L A COLHDG('Change' + A 'member' + A 'date' ) A CMGTIM T A COLHDG('Change' + A 'member' + A 'time' ) A CMFCDT L A COLHDG('Creation' + A 'file' + A 'date' ) A CMDTAT 1 A COLHDG('Dta' + A 'Src' ) A CMNOMB 5S 0 A COLHDG('Number' + A 'of' + A 'members' ) A CMMTXT 50 A COLHDG('Member' + A 'text' ) A CMTXT 50 A COLHDG('File' + A 'text' ) A CMXDAT L A COLHDG('Last use' + A 'file' + A 'date' ) A CMXCNT 5S 0 A COLHDG('Use' + A 'file' + A 'days' ) A CMFDAT L A COLHDG('Change' + A 'file' + A 'date' ) A CMFTIM T A COLHDG('Change' + A 'file' + A 'time' ) A CMNRCD 10S 0 A COLHDG('Current' + A 'number of' + A 'records' ) A CMNDTR 10S 0 A COLHDG('Number of' + A 'deleted' + A 'records' ) A CMTSIZ 15S 0 A COLHDG('Total' + A 'size' ) //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPFCDL) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 09-05-2016 Creato. */ /* Cleanings Phy. ChkDupLib */ /* Pulizie Fisici. Controlla librerie duplicate. */ /* Controlla l'appartenenza alla work library delle librerie riceventi */ /* menzionate nell'elenco dei membri candidati allo spostamento. */ /* */ PGM PARM(&WRKLIB &REFPGM &RTNERR) /* Riceve Work library. */ DCL VAR(&WRKLIB) TYPE(*CHAR) LEN(10) /* Riceve Programma di riferimento per i messaggi. */ DCL VAR(&REFPGM) TYPE(*CHAR) LEN(10) /* Ritorna Flag di errore. */ DCL VAR(&RTNERR) TYPE(*LGL) /* Riceve l'elenco dei membri da muovere. */ DCLF FILE(JCLNPFCA) /* Libreria datrice precedente. */ DCL VAR(&PRELIB) TYPE(*CHAR) LEN(10) /* Libreria ricevente. */ DCL VAR(&CMLIB§) TYPE(*CHAR) LEN(10) /* Testo della libreria ricevente preeesistente. */ DCL VAR(&LIBTEXT) TYPE(*CHAR) LEN(50) DCL VAR(&LIBTEXT10) TYPE(*CHAR) LEN(10) /* File messaggi. */ DCL VAR(&MSGF) TYPE(*CHAR) LEN(10) VALUE(JCLNPF) /* To message queue. */ DCL VAR(&TOMSGQ) TYPE(*CHAR) LEN(10) VALUE(JCLNPF) DCL VAR(&TOMSGQTXT) TYPE(*CHAR) LEN(50) + VALUE('Cleanings Physical Files') /* Intercetta gli errori imprevisti. */ MONMSG MSGID(CPF0000 MCH0000 CEE0000) EXEC(GOTO + CMDLBL(FINE)) /* Pulisce i parametri di ritorno. */ CHGVAR VAR(&RTNERR) VALUE('0') /* Controlla l'esistenza della work library. */ CHKOBJ OBJ(&WRKLIB) OBJTYPE(*LIB) /* Se la work library non esiste, restituisce errore al chiamante. */ MONMSG MSGID(CPF0000) EXEC(DO) CHGVAR VAR(&RTNERR) VALUE('1') SNDPGMMSG MSGID(JCL0002) MSGF(JCLNPF) MSGDTA(&CMLIB + *CAT %SST(&CMLIB 5 6)) TOPGMQ(*PRV + (&REFPGM)) MSGTYPE(*DIAG) GOTO CMDLBL(FINE) ENDDO /* Reindirizza il file da leggere. */ OVRDBF FILE(JCLNPFCA) TOFILE(&WRKLIB/JCLNPFCA) /*----------------------------------------------------------------------------*/ /* Cicla lettura record. */ DOWHILE COND(1 = 1) /* Legge un record membro candidato a pulizia. */ RCVF /* Se non ce ne sono altri, abbandona. */ MONMSG MSGID(CPF0864) EXEC(LEAVE) /* Se il candidato e' da conservare, ricicla. */ IF COND(&CMFIFG *NE '1') THEN(ITERATE) /* Se la libreria e' diversa dalla precedente. */ IF COND(&CMLIB *NE &PRELIB) THEN(DO) /* Accantona la libreria precedente. */ CHGVAR VAR(&PRELIB) VALUE(&CMLIB) /* Se il decimo carattere del nome libreria datrice non e' blank, */ /* messaggia "Nome troppo lungo" ma continua. */ IF COND(%SST(&CMLIB 10 1) *NE ' ') THEN(DO) JSNDMSG MSGID(JCL0006) MSGF(&MSGF) MSGDTA(&CMLIB) + MSGTYPE(*DIAG) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) ENDDO /* Compone il nome della libreria ricevente. */ CHGVAR VAR(&CMLIB§) VALUE(%SST(&CMLIB 1 9) *TCAT §) /* Controlla l'esistenza della libreria ricevente. */ CHKOBJ OBJ(&CMLIB§) OBJTYPE(*LIB) /* Se la libreria ricevente non esiste, ricicla. */ MONMSG MSGID(CPF0000) EXEC(DO) RCVMSG MSGTYPE(*EXCP) WAIT(1) RMV(*YES) ITERATE ENDDO /* Recupera il testo della libreria ricevente. */ RTVLIBD LIB(&CMLIB§) TEXT(&LIBTEXT) CHGVAR VAR(&LIBTEXT10) VALUE(&LIBTEXT) /* Se la libreria ricevente ha un testo diverso dal nome */ /* dal nome della work library, segnala. */ IF COND(&LIBTEXT *NE &WRKLIB) THEN(DO) CHGVAR VAR(&RTNERR) VALUE('1') JSNDMSG MSGID(JCL0005) MSGF(&MSGF) MSGDTA(&CMLIB§ + *CAT &WRKLIB *CAT &LIBTEXT10) + MSGTYPE(*DIAG) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) ENDDO /* Se la libreria e' diversa dalla precedente. */ ENDDO /* Cicla lettura record. */ ENDDO /*----------------------------------------------------------------------------*/ FINE: ENDPGM //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPFFF) FILETYPE(*SRC) ENDCHAR('//ENDSRC') * Claudio Neroni 16-09-2015 Creato. * Cleanings. Physical. ForcedFlags A UNIQUE A R FFR A TEXT('Forced flags + A to cleaning.') A FFFRFG 1 A COLHDG('Forced' + A 'selection' + A 'flag' ) A VALUES(' ' '0' '1') A FFSYSN 8 A COLHDG('System') A FFLIB 10 A COLHDG('Library') A FFFILE 10 A COLHDG('File') A FFNAME 10 A COLHDG('Member') A K FFSYSN A K FFLIB A K FFFILE A K FFNAME //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPFFFQ) FILETYPE(*SRC) ENDCHAR('//ENDSRC') SELECT * FROM &LIB/JCLNPFFF FF INNER JOIN &LIB/JCLNPFCA CA ON FF.FFSYSN = CA.CMSYSN AND FF.FFLIB = CA.CMLIB AND FF.FFFILE = CA.CMFILE AND FF.FFNAME = CA.CMNAME //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPFFFQI) FILETYPE(*SRC) ENDCHAR('//ENDSRC') ADDLIBLE LIB(JCLNTST) POSITION(*LAST) STRQMQRY QMQRY(JCLNPFFFQM) SETVAR((LIB JCLNTST)) //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPFMB) FILETYPE(*SRC) ENDCHAR('//ENDSRC') * Claudio Neroni 09-09-2015 Creato. * Cleanings. Physical. Mbr * Output File for DSPFD TYPE(*MBR) A R QWHFDMBR FORMAT(QAFDMBR) //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPFMB1) FILETYPE(*SRC) ENDCHAR('//ENDSRC') * Claudio Neroni 09-09-2015 Creato. * Cleanings. Physical. Mbr * Output File for DSPFD TYPE(*MBR) * Key Sistema, Libreria, File, Membro. A UNIQUE A R QWHFDMBR A PFILE(JCLNPFMB) A K MBSYSN A K MBLIB A K MBFILE A K MBNAME //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPFOD) FILETYPE(*SRC) ENDCHAR('//ENDSRC') * Claudio Neroni 11-09-2015 Creato. * Cleanings. Physical. ObjD * Output File for DSPOBJD OBJTYPE(*FILE) DETAIL(*FULL) A R QLIDOBJD FORMAT(QADSPOBJ) //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPFOD1) FILETYPE(*SRC) ENDCHAR('//ENDSRC') * Claudio Neroni 11-09-2015 Creato. * Cleanings. Physical. ObjD * Output File for DSPOBJD OBJTYPE(*FILE) DETAIL(*FULL) * Key Sistema, Libreria, File. A UNIQUE A R QLIDOBJD PFILE(JCLNPFOD) A K ODOBSY A K ODLBNM A K ODOBNM A S ODOBTP COMP(EQ '*FILE') A ODOBAT COMP(EQ 'PF') //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPFP) FILETYPE(*SRC) ENDCHAR('//ENDSRC') :PNLGRP. .*------------------------------------------------------------------------------ :HELP NAME=CMD. :H3.Procedura JCLNPF :H2.Cleanings Physical Files :P.La procedura si occupa della pulizia dei membri inutilizzati presenti nelle librerie dati scelte. :P.La procedura va eseguita con l'opportuna autorita' sui dati. File non visibili o non agibili al profilo che esegue la procedura portano equivoci e disguidi che vanificano la procedura intera. :P.La procedura e' composta da un gruppo di comandi che, chiamati secondo necessita', ne realizzano lo scopo. Il primo comando :HP2.JCLNPF:EHP2. e' fittizio ma serve a supportare il presente help di procedura. :DL COMPACT. :DT.JCLNPF :DD.Cleanings Physical Files Help :DT.JCLNPF1 :DD.Extracts work DB to clean PF :DT.JCLNPF2 :DD.Select candidates to clean PF :DT.JCLNPF3 :DD.Manage Forced Flags :DT.JCLNPF4 :DD.Duplicate Members :DT.JCLNPF5 :DD.Delete Original Members :EDL. :P.Ciascuno dei comandi e' dotato di un proprio help. :P.Tramite il comando iniziale opportunamente parametrizzato :HP2.JCLNPF1:EHP2. e' possibile scegliere se esaminare una sola libreria o una lista di librerie. Con esecuzioni consecutive del comando :HP2.JCLNPF1:EHP2. e' anche possibile aggiungere una libreria dati alla volta per raggruppare piu' librerie senza preimpostare una lista librerie. :P.Si consiglia comunque una sola libreria alla volta per semplificare l'attivita' di verifica dei risultati della procedura. In questo caso una libreria di lavoro gestisce una sola libreria dati e una sola libreria duplicata. Altrimenti una libreria di lavoro gestisce piu' librerie dati e altrettante librerie duplicate. :P.I membri, se sgombrati, lo sono integralmente senza alcun intervento sui singoli record contenuti nei membri, sia superstiti che sgombrati. :P.Per :HP3."sgombrare":EHP3. si intende: :P.A) Con :HP2.JCLNPF1 JCLNPF2 JCLNPF3:EHP2. scegliere file e membri da eliminare. :P.B) Con :HP2.JCLNPF4:EHP2. copiarli in librerie parallele alle originali. :P.C) Con :HP2.JCLNPF5:EHP2. rimuovere gli originali dei file e dei membri copiati nelle librerie parallele. :P.D) Con :HP2.SAVLIB:EHP2. salvare le librerie parallele. :P.E) Con :HP2.DLTLIB:EHP2. cancellare le librerie parallele. :P.Per libreria :HP3."parallela":EHP3. si intende una libreria generata dalla procedura con lo stesso nome dell'originale ma con l'aggiunta in coda del carattere "§". :P.Si osserva che l'analisi dei dati tramite la procedura corrente va eseguita rigorosamente su librerie attive e non su duplicati estemporanei in quanto ogni specie di duplicazione (copiatura o salataggio-ripristino) comporta la perdita delle informazioni d'uso e di modifica sulle quali si basa la procedura. :P.La procedura tocca i dati originali solo quando si usa il comando :HP2.JCLNPF5:EHP2. e solo se si fa uso del parametro :HP2.RUN(*EXEC):EHP2. e agisce quindi senza modificare i dati originali fino all'ultimo passo escluso. :P.Se i dati evolvono durante l'esame, e' possibile continuare egualmente la sequenza avviata in quanto gli oggetti toccati da uso o modifica si autoescludono dalle duplicazioni e dalle pulizie successive. :P.Oppure, se non ancora eseguito :HP2.JCLNPF5 RUN(*EXEC):EHP2., e' possibile riavviare la procedura dall'inizio senza perdere le forzature gia' memorizzate. :P.Si possono eseguire contemporaneamente pulizie diverse facendo uso di librerie di lavoro diverse. E' cura dell'utente includere una libreria da pulire in una sola libreria di lavoro. :P.Per evitare doppie elaborazioni, il testo di ogni libreria duplicata riporta in nome della libreria di lavoro che la genera e nessun altra libreria di lavoro puo' utilizzarla. Il controllo non agisce sul comando :HP2.JCLNPF1:EHP2. ma agisce invece sui comandi :HP2.JCLNPF2 JCLNPF3:EHP2. e sui comandi :HP2.JCLNPF4 RUN(*DIAG):EHP2. e :HP2.JCLNPF5 RUN(*DIAG):EHP2. che terminano in errore ma solo dopo la normale esecuzione. Lo stesso controllo agisce sui comandi :HP2.JCLNPF4 RUN(*EXEC):EHP2. e :HP2.JCLNPF5 RUN(*EXEC):EHP2. che terminano in errore prima di tentare la normale esecuzione. :EHELP. .*------------------------------------------------------------------------------ :HELP NAME='CMD/COMMAND/EXAMPLES'. .*------------------ :XH3.Esempio d'uso della procedura. :P.Scelta per gli esempi seguenti una sola libreria da pulire :HP2.UFNERONI:EHP2. e un suffisso :HP2.UFNERO:EHP2. per la libreria di lavoro che genera un nome per la libreria stessa :HP2.JCLNUFNERO:EHP2., si eseguono i passi seguenti per ottenere al termine la libreria da salvare :HP2.UFNERONI§:EHP2. contenente i file e i membri tolti dalla libreria da pulire. :P.Si inizia preparando la libreria di lavoro tramite il comando :HP2.JCLNPF1:EHP2. che raccoglie le informazioni necessarie per le attivita' successive. :P.I membri da pulire sono decisi mediante i tre parametri di scelta del comando :HP2.JCLNPF2:EHP2. e si possono correggere le scelte sui singoli membri tramite un dfu sul file dei flag di forzatura generato dal comando :HP2.JCLNPF3:EHP2.. :P.Al termine dell'elaborazione dei comandi di duplicazione e di rimozione, la libreria di lavoro :HP2.JCLNUFNERO:EHP2. va salvata insieme alla libreria duplicata ma conviene che resti anche in linea fino a quando sara' necessario giustificare le azioni svolte. :P.La libreria di lavoro contiene i seguenti file fisici di servizio: :DL COMPACT. :DT.JCLNPFMB :DD.Cleanings Phy. Mbr :DT.JCLNPFOD :DD.Cleanings Phy. ObjD :DT.JCLNPFCA :DD.Cleanings Phy. Candidates :DT.JCLNPFFF :DD.Cleanings Phy. ForcedFlags :DT.JCLNPFQ :DD.Retrieve Messages Queue. OutFile :DT.JLOGJCLNPF :DD.Archives Log. Outfile :EDL. :P.La libreria di lavoro contiene anche la coda messaggi: :DL COMPACT. :DT.JCLNPF :DD.Cleanings Physical Files :EDL. :P.I file fisici di servizio, all'esecuzione del comando :HP2.JCLNPF4:EHP2. in versione :HP2.RUN(*EXEC):EHP2., vengono copiati anche nelle librerie duplicate a scopo di documentazione qualora in futuro una libreria duplicata venga ripristinata dal salvataggio finale senza piu' disporre contemporaneamente della corrispondente libreria di lavoro. :P.Il file :HP2.JCLNPFMB:EHP2. contiene l'elenco membri dei file fisici presenti nella libreria da pulire creato dal comando :HP2.JCLNPF1:EHP2.. :P.Il file :HP2.JCLNPFOD:EHP2. contiene l'elenco dei file presenti nella libreria da pulire creato dal comando :HP2.JCLNPF1:EHP2.. :P.Il file :HP2.JCLNPFCA:EHP2. contiene l'elenco dei membri candidabili allo sgombero con i flag che determinano il comportamento della procedura. :P.Il file :HP2.JCLNPFFF:EHP2. contiene i flag che permettono di forzare il destino di ogni singolo membro. I record di forzatura che portano un effettivo flag di forzatura vengono rimossi dalla procedura solo con l'esecuzione del comando :HP2.JCLNPF3:EHP2. con il parametro :HP2.MBROPT(*REPLACE):EHP2. quindi sopravvivono all'eventuale riesecuzione della raccolta dati eseguita con il comando :HP2.JCLNPF1:EHP2. con il parametro :HP2.MBROPT(*REPLACE):EHP2.. :P.Il file :HP2.JCLNPFQ:EHP2. contiene la fotografia della coda messaggi :HP2.JCLNPF:EHP2. nella quale si ritrova una copia di tutti i messaggi emessi dai comandi della procedura e indirizzati al programma chiamante dei comandi (QCMD, se si sono seguiti i consigli esposti qui di seguito). Si ricorda che il contenuto di una coda messaggi non puo' essere salvato. Si osserva che il file contiene campi carattere non direttamente visibili da dfu e query: usare DSPPFM. :P.Il file :HP2.JLOGJCLNPF:EHP2. contiene la fotografia integrale del log nella forma di stampa generato dai comandi :HP2.JCLNPF4:EHP2. e :HP2.JCLNPF5:EHP2. in versione :HP2.RUN(*EXEC):EHP2.. Il file e' agibile con la scansione del :HP2.DSPPFM:EHP2. per eventuali necessita'. .*------------------ :P.Si riporta un esempio completo di sequenza d'uso dei comandi che compongono la procedura. I passi vanno da :HP2.A1:EHP2. ad :HP2.A11:EHP2. e prevedono l'utilizzo e il riutilizzo dei cinque comandi che compongono la procedura nonche' l'utilizzo di svariati comandi di sistema maneggiati da un utente non solo :HP3.esperto di database:EHP3. ma anche con :HP3.accesso a pratiche e competenze sistemistiche:EHP3.. :P.I comandi non generano stampe di controllo ma restituiscono le eccezioni e le informazioni necessarie sotto forma di messaggi in joblog. E' percio' necessario che i comandi vengano eseguiti dal video comandi fornito dal programma di sistema :HP2.QCMD:EHP2.. :P.Ogni comando genera un log di cui si riporta l'immagine, correttamente visibile solo se il comando viene eseguito da :HP2.QCMD:EHP2.. :P.Si osservino i messaggi informativi e i comandi promemoria duplicabili per esaminare i dati della libreria di lavoro o per eseguire i passi successivi della procedura. :P.Si osservi inoltre l'esplosione a volte riportata del secondo livello di alcuni messaggi segnati in queste immagini con "**" lungo il log. .*------------------ :P.:HP2.Passo A1: Creazione della libreria di lavoro:EHP2. :XMP. > JCLNPF1 WRK(UFNERO) LIB(UFNERONI) ->Verifica esistenza database in WorkLib: JCLNUFNERO ->Display File Desc Type Member in corso lib UFNERONI ->Display Object Desc Type File Detail Full in corso lib UFNERONI ->Creata e riempita WorkLib JCLNUFNERO per pulizia file fisici di UFNERONI > /**/RUNQRY QRYFILE((JCLNUFNERO/JCLNPFMB)) RCDSLT(*YES) > /**/RUNQRY QRYFILE((JCLNUFNERO/JCLNPFOD)) RCDSLT(*YES) > /**/JCLNPF2 WRK(UFNERO) SLTUSE(CYYMMDD) SLTCNT(2) SLTCHG(CYYMMDD) :EXMP. .*------------------ :P.:HP2.Passo A2: Riempimento file candidati allo sgombero:EHP2. :XMP. > JCLNPF2 WRK(UFNERO) SLTUSE(1141231) ->Genera elenco membri candidati a pulizia. WorkLib: JCLNUFNERO ->Da trasferire 74 membri. Vedi secondo livello ->Generato elenco di 3532 membri candidati a pulizia. WorkLib: JCLNUFNERO > /**/RUNQRY QRYFILE((JCLNUFNERO/JCLNPFCA)) RCDSLT(*YES) > /**/JCLNPF3 WRK(UFNERO) :EXMP. .*------------------ :P.:HP2.Passo A3: Riempimento file forzature:EHP2. :XMP. > JCLNPF3 WRK(UFNERO) ->Riempie il file dei flag di forzatura. WorkLib: JCLNUFNERO ->Presenti 0 forzature. Vedi secondo livello ->Aggiunti 3532 record mancanti a flag di forzatura. WorkLib: JCLNUFNERO > /**/RUNQRY QRYFILE((JCLNUFNERO/JCLNPFFF)) RCDSLT(*YES) > /**/UPDDTA FILE(JCLNUFNERO/JCLNPFFF) > /**/JCLNPF2 WRK(UFNERO) SLTUSE(*PRV) SLTCHG(*PRV) > /**/JCLNPF4 WRK(UFNERO) RUN(*DIAG) ->Per riportare i flag da ForcedFlags a Candidates, vedi secondo livello :EXMP. .*------------------ :P.:HP2.Passo A4: Dfu su file forzature per aggiungere membri allo sgombero:EHP2. :XMP. > UPDDTA FILE(JCLNUFNERO/JCLNPFFF) :EXMP. .*------------------ :P.:HP2.Passo A5: Riporta flag di forzatura su file candidati:EHP2. :XMP. > JCLNPF2 WRK(UFNERO) SLTUSE(*PRV) SLTCHG(*PRV) ->Genera elenco membri candidati a pulizia. WorkLib: JCLNUFNERO **->Da trasferire 76 membri. Vedi secondo livello ->Generato elenco di 3532 membri candidati a pulizia. WorkLib: JCLNUFNERO > /**/RUNQRY QRYFILE((JCLNUFNERO/JCLNPFCA)) RCDSLT(*YES) > /**/JCLNPF3 WRK(UFNERO) ** Secondo livello Analisi delle ricorrenze dei "Selection Flag": "Initial" "Forced" "Final". Initial off 3458 Initial on 74 Forced off 0 Forced on 3 Final off 3456 Final on 76 Forced off <> Initial 0 Forced off = Initial 0 inutili Forced on <> Initial 2 Forced on = Initial 1 inutili :EXMP. .*------------------ :P.:HP2.Passo A6: Diagnosi ante duplicazione:EHP2. :XMP. > JCLNPF4 WRK(UFNERO) RUN(*DIAG) ->Run *DIAG Spostamenti ->Elabora duplicazione membri scelti tramite WorkLib JCLNUFNERO ->Legge elenco membri da spostare. WorkLib: JCLNUFNERO ->Datrice UFNERONI esiste. - Ricevente UFNERONI§ NON esiste. **->Lib:UFNERONI Obj:3533 ToMov:76 Desap:0 Chg:0 Err:0 Alrd:0 Dup:0 Siz:1366798336 Fre:178802688 ->Esaminato elenco membri da spostare. WorkLib: JCLNUFNERO ->Wrk:JCLNUFNERO Obj:3533 ToMov:76 Desap:0 Chg:0 Err:0 Alrd:0 Dup:0 Siz:1366798336 Fre:178802688 ->Run *DIAG. Spostamenti diagnosticati: esamina i messaggi. ** Secondo livello L'esame della work library "JCLNUFNERO" segnala la presenza nelle librerie dati di 3533 oggetti dei quali 76 da muovere nelle librerie riceventi a scopo di salvataggio prima della pulizia. Si segnalano tuttavia 0 oggetti spariti e 0 oggetti con una situazione di aggiornamento o uso cambiata dopo l'esame originale. Si sono verificati 0 errori di duplicazione. 0 oggetti esistono gia'. Eseguite 0 duplicazioni. In base alle segnalazioni del presente run, valutare se passare all'esecuzione dei trasferimenti. Spazio occupato 1366798336. Spazio liberabile 178802688. :EXMP. .*------------------ :P.:HP2.Passo A6V: Diagnosi ante duplicazione con oggetti originali variati:EHP2. :P.Si riporta una variazione al passo :HP2.A6:EHP2. che si presenta se tra la creazione della libreria di lavoro e la diagnosi degli spostamenti si riscontrano variazioni a file e membri da spostare. :XMP. > JCLNPF4 WRK(UFNERO) RUN(*DIAG) ->Run *DIAG Spostamenti ->Elabora duplicazione membri scelti tramite WorkLib JCLNUFNERO ->Legge elenco membri da spostare. WorkLib: JCLNUFNERO ->Datrice UFNERONI esiste. - Ricevente UFNERONI§ NON esiste. ->r UFNERONI /BELLA -BELLA "2014-01-30" "16.52.47" "2014-03-07" ->m UFNERONI /BELLA -BELLA "2016-05-05" "17.59.48" "2016-05-05" ->r UFNERONI /F186 -F186 file del membro non esiste piu' **->Lib:UFNERONI Obj:3533 ToMov:76 Desap:1 Chg:1 Err:0 Alrd:0 Dup:0 Siz:1366798336 Fre:178802688 ->Esaminato elenco membri da spostare. WorkLib: JCLNUFNERO ->Wrk:JCLNUFNERO Obj:3533 ToMov:76 Desap:1 Chg:1 Err:0 Alrd:0 Dup:0 Siz:1366798336 Fre:178802688 ->Run *DIAG. Spostamenti diagnosticati: esamina i messaggi. ** Secondo livello Nella libreria dati "UFNERONI" sono presenti 3533 oggetti dei quali 76 da muovere nelle librerie ricevente a scopo di salvataggio prima della pulizia. Si segnalano tuttavia 1 oggetti spariti e 1 oggetti con una situazione di aggiornamento o uso cambiata dopo l'esame originale. Si sono verificati 0 errori di duplicazione. 0 oggetti esistono gia'. Eseguite 0 duplicazioni. Spazio occupato 1366798336. Spazio liberabile 178802688. :EXMP. :P.Si osservi la riga "->r" che indica le caratteristiche originali del file o membro e la successiva riga "->m" che rileva le caratteristiche attuali dello stesso soggetto. :P.Gli errori possono essere corretti e il comando corrente puo' essere riproposto per verificarne la scomparsa Tuttavia, anche se gli errori non vengono corretti, si puo' passare all'esecuzione della duplicazione che non coivolgera' i soggetti in errore. .*------------------ :P.:HP2.Passo A7: Creazione duplicati:EHP2. :XMP. > JCLNPF4 WRK(UFNERO) RUN(*EXEC) ->Run *EXEC Spostamenti ->Elabora duplicazione membri scelti tramite WorkLib JCLNUFNERO ->Legge elenco membri da spostare. WorkLib: JCLNUFNERO ->Datrice UFNERONI esiste. - Ricevente UFNERONI§ NON esiste. ->Creata libreria ricevente UFNERONI§ ->Esaminato elenco membri da spostare. WorkLib: JCLNUFNERO ->Legge elenco membri da spostare. WorkLib: JCLNUFNERO ->Datrice UFNERONI esiste. - Ricevente UFNERONI§ esiste. **->Lib:UFNERONI Obj:3533 ToMov:76 Desap:0 Chg:0 Err:0 Alrd:0 Dup:76 Siz:1366798336 Fre:178802688 ->Esaminato elenco membri da spostare. WorkLib: JCLNUFNERO ->Wrk:JCLNUFNERO Obj:3533 ToMov:76 Desap:0 Chg:0 Err:0 Alrd:0 Dup:76 Siz:1366798336 Fre:178802688 ->Run *EXEC. Duplicazione eseguita: esamina i messaggi. > /**/DSPPFM FILE(JCLNUFNERO/JLOGJCLNPF) ** Secondo livello Nella libreria dati "UFNERONI" sono presenti 3533 oggetti dei quali 76 da muovere nella libreria ricevente a scopo di salvataggio prima della pulizia. Si segnalano tuttavia 0 oggetti spariti e 0 oggetti con una situazione di aggiornamento o uso cambiata dopo l'esame originale. Si sono verificati 0 errori di duplicazione. 0 oggetti esistono gia'. Eseguite 76 duplicazioni. Spazio occupato 1366798336. Spazio liberabile 178802688. :EXMP. .*------------------ :P.:HP2.Passo A8: Diagnosi ante cancellazione:EHP2. :XMP. > JCLNPF5 WRK(UFNERO) ->Run *DIAG Cancellazioni ->Elabora cancellazione membri scelti tramite WorkLib JCLNUFNERO ->Legge elenco membri da cancellare. WorkLib: JCLNUFNERO Lib datrice UFNERONI. Lib ricevente UFNERONI§. ->r UFNERONI /F186 - F186 manca membro ricevente **->Lib:UFNERONI Obj:3533 ToMov:76 InOri:75 InSav:75 NoSav:1 Err:0 Chg:0 Dlt:0 ->Esaminato elenco membri da cancellare. WorkLib: JCLNUFNERO ->Obj:3533 ToMov:76 InOri:75 InSav:75 NoSav:1 Err:0 Chg:0 Dlt:0 ->Run *DIAG. Cancellazioni diagnosticate: esamina i messaggi. ** Secondo livello Nella libreria dati "UFNERONI" sono presenti 3533 oggetti dei quali 76 da muovere nella libreria ricevente a scopo di salvataggio prima della pulizia. Si segnalano 75 oggetti ancora esistenti nella libreria originale; 75 presenti nel salvataggio; 1 mancanti nel salvataggio; 0 in errore; 0 modificati dopo la duplicazione; 0 cancellati in questo run dagli originali. :EXMP. .*------------------ :P.:HP2.Passo A9: Cancellazione file e membri originali da sgombrare:EHP2. :P.Quest'ultimo passo di procedura e' stato eseguito su una libreria da pulire diversa da quella considerata in tutti gli altri passi. Non ho voluto assassinare con questa azione la libreria piu' vissuta presa di mira negli altri passi. Contentati! :XMP. > JCLNPF5 WRK(TST) RUN(*EXEC) ->Run *EXEC Cancellazioni ->Elabora cancellazione membri scelti tramite WorkLib JCLNTST ->Legge elenco membri da cancellare. WorkLib: JCLNTST Lib datrice NERONITST. Lib ricevente NERONITST§. **->Lib:NERONITST Obj:512 ToMov:485 InOri:0 InSav:0 NoSav:0 Err:0 Chg:0 Dlt:482 ->Esaminato elenco membri da cancellare. WorkLib: JCLNTST ->Obj:512 ToMov:485 InOri:0 InSav:0 NoSav:0 Err:0 Chg:0 Dlt:482 ->Run *EXEC. Cancellazioni eseguite: esamina i messaggi. > /**/DSPPFM FILE(JCLNTST/JLOGJCLNPF) ** Secondo livello Nella libreria dati "NERONITST" sono presenti 512 oggetti dei quali 485 da muovere nella libreria ricevente a scopo di salvataggio prima della pulizia. Si segnalano 0 oggetti ancora esistenti nella libreria originale; 0 presenti nel salvataggio; 0 mancanti nel salvataggio; 0 in errore; 0 modificati dopo la duplicazione; 482 cancellati in questo run dagli originali. :EXMP. .*------------------ :P.:HP2.Passo A10: Salva libreria duplicata contenente file e membri sgombrati:EHP2. :P.Non ritengo utile raccontare comandi standard che lascio alla competenza dell'utente. Raccomando solo che il salvataggio sia secondo gli standard indigeni e ricordo che da qui si ripescheranno i dati erroneamente eliminati. :XMP. > SAVLIB UFNERONI§ :EXMP. .*------------------ :P.:HP2.Passo A11: Cancella libreria duplicata:EHP2. :P.Anche questo passo e' lasciato alla competenza dell'utente e va eseguito con cautela e con la certezza che tutti i passi precedenti siano stati eseguiti correttamente. :XMP. > DLTLIB UFNERONI§ :EXMP. .*------------------ :EHELP. .*------------------------------------------------------------------------------ :EPNLGRP. //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF1) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 09-09-2015 Creato. */ /* Cleanings. Physical. Create & Fill Work Library. Cmd */ /* Pulizie. Fisici. Crea e riempie la Libreria di lavoro. Comando */ /* */ CMD PROMPT('Extracts work DB to clean PF') PARM KWD(WRK) TYPE(*NAME) LEN(6) MIN(1) + PROMPT('Cleaning work library suffix') PARM KWD(LIB) TYPE(*NAME) LEN(10) DFT(*USRLIBL) + SPCVAL((*LIBL) (*USRLIBL) (*ALLUSR) + (*ALL)) PROMPT('Library or Library list') PARM KWD(MBROPT) TYPE(*CHAR) LEN(10) RSTD(*YES) + DFT(*REPLACE) VALUES(*REPLACE *ADD + *RPLLIB) PROMPT('Replace/Add/ReplaceLib + info') PARM KWD(TEXT) TYPE(*CHAR) LEN(38) DFT(*SAME) + SPCVAL((*SAME) (*LIB) (*LIBADD)) + PROMPT('Short text of Work library') PARM KWD(REFPGM) TYPE(*NAME) LEN(10) DFT(*CPP) + SPCVAL((*CPP)) PROMPT('Reference program + for messages') //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF1C) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 09-09-2015 Creato. */ /* Cleanings. Physical. Create & Fill Work Library. Cpp */ /* Pulizie. Fisici. Crea e riempie la Libreria di lavoro. Cpp */ /* Crea e riempie la libreria di lavoro per la pulizia dei file fisici. */ /* */ PGM PARM(&WRK &LIB &MBROPT &TEXT &REFPGM) /* Riceve Cleaning work library suffix. */ DCL VAR(&WRK) TYPE(*CHAR) LEN(6) /* Cleaning work library. */ DCL VAR(&WRKLIB) TYPE(*CHAR) LEN(10) /* Riceve Libreria o Lista librerie da esaminare. */ DCL VAR(&LIB) TYPE(*CHAR) LEN(10) /* Riceve Sostituzione/Aggiunta record. */ DCL VAR(&MBROPT) TYPE(*CHAR) LEN(10) DCL VAR(&MBROPTX) TYPE(*CHAR) LEN(10) /* Riceve Testo breve libreria dati. */ DCL VAR(&TEXT) TYPE(*CHAR) LEN(38) /* Riceve Programma di riferimento per i messaggi. */ DCL VAR(&REFPGM) TYPE(*CHAR) LEN(10) /* Indirizzario equivalente alla work library. */ DCL VAR(&WRKLIBDIR) TYPE(*CHAR) LEN(100) /* Testo work library da imporre. */ DCL VAR(&WRKLIBTXT) TYPE(*CHAR) LEN(50) /* Testo work library recuperato. */ DCL VAR(&RTVTXT) TYPE(*CHAR) LEN(50) /* Messaggio. */ DCL VAR(&MSGDTA) TYPE(*CHAR) LEN(512) /* File messaggi. */ DCL VAR(&MSGF) TYPE(*CHAR) LEN(10) VALUE(JCLNPF) /* To message queue. */ DCL VAR(&TOMSGQ) TYPE(*CHAR) LEN(10) VALUE(JCLNPF) DCL VAR(&TOMSGQTXT) TYPE(*CHAR) LEN(50) + VALUE('Cleanings Physical Files') /* Prenotazione del CPF0001. */ DCL VAR(&CPF0001) TYPE(*LGL) /* Intercetta gli errori imprevisti. */ MONMSG MSGID(CPF0000 MCH0000 CEE0000) EXEC(GOTO + CMDLBL(ERRORE)) /* Compone il nome della Cleaning work library. */ CHGVAR VAR(&WRKLIB) VALUE(JCLN *CAT &WRK) /* Se corre sostituzione. */ IF COND(&MBROPT *EQ *REPLACE) THEN(DO) /* Controlla l'esistenza della work library. */ CHKOBJ OBJ(&WRKLIB) OBJTYPE(*LIB) /* Se la work library non esiste, la crea. */ MONMSG MSGID(CPF0000) EXEC(DO) CHGVAR VAR(&WRKLIBDIR) VALUE('/qsys.lib/' *TCAT + &WRKLIB *TCAT '.lib') MKDIR DIR(&WRKLIBDIR) CHGLIB LIB(&WRKLIB) TYPE(*TEST) ENDDO /* Se corre sostituzione. */ ENDDO /* Se richiesto *CPP (Command Processing Program) come programma */ /* di riferimento dei messaggi, assume il nome del programma corrente. */ IF COND(&REFPGM *EQ *CPP) THEN(DO) JCALLER CALLER(&REFPGM) KINSHIP(*FATHER) ENDDO /* Trascrive il parametro Sostituzione/Aggiunta record. */ CHGVAR VAR(&MBROPTX) VALUE(&MBROPT) IF COND(&MBROPT *EQ *RPLLIB) THEN(CHGVAR + VAR(&MBROPTX) VALUE(*ADD)) /* Avvia coda messaggi. */ JSNDMSG MSGDTA(JCLNPF1) MSGTYPE(*INFO) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) + TOMSGQTXT(&TOMSGQTXT) SEQ(*FIRST) /* Se il nome libreria ha il decimo carattere uguale a "§", */ /* messaggia "Nome libreria non permesso" e abbandona. */ IF COND(%SST(&LIB 10 1) *EQ §) THEN(DO) CHGVAR VAR(&MSGDTA) VALUE(&LIB) JSNDMSG MSGID(JCL0106) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*DIAG) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) GOTO CMDLBL(CPF0001) ENDDO /* Se richiesta una specifica libreria che non esiste, */ /* messaggia "Libreria inesistente" e abbandona. */ IF COND(%SST(&LIB 1 1) *NE '*') THEN(DO) CHKOBJ OBJ(&LIB) OBJTYPE(*LIB) MONMSG MSGID(CPF0000) EXEC(DO) CHGVAR VAR(&MSGDTA) VALUE(&LIB) JSNDMSG MSGID(JCL0003) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*DIAG) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) GOTO CMDLBL(CPF0001) ENDDO ENDDO /* Se richiesta la sostituzione delle info di una specifica libreria */ /* e non viene indicata la specifica libreria, */ /* messaggia "Sostituzione info libreria senza libreria" e abbandona. */ IF COND((&MBROPT *EQ *RPLLIB) *AND (%SST(&LIB 1 + 1) *EQ '*')) THEN(DO) CHGVAR VAR(&MSGDTA) VALUE(&LIB) JSNDMSG MSGID(JCL0107) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*DIAG) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) GOTO CMDLBL(CPF0001) ENDDO /* Messaggia "Verifica database". */ CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB) JSNDMSG MSGID(JCL0101) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Controlla l'esistenza della work library. */ CHKOBJ OBJ(&WRKLIB) OBJTYPE(*LIB) /* Se la work library non esiste. */ MONMSG MSGID(CPF0000) EXEC(DO) /* Se corre aggiunta. */ IF COND(&MBROPT *EQ *ADD) THEN(DO) /* Segnala "WrkLib mancante" e abbandona. */ CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB) JSNDMSG MSGID(JCL0102) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*DIAG) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) GOTO CMDLBL(CPF0001) /* Se corre aggiunta. */ ENDDO /* Se la work library non esiste. */ ENDDO /* Compone il testo della work library. */ SELECT WHEN COND((&TEXT *EQ *SAME) *AND (&MBROPT *EQ + *REPLACE)) THEN(CHGVAR VAR(&WRKLIBTXT) + VALUE('Clean Work:' *BCAT &LIB)) WHEN COND((&TEXT *EQ *LIBADD) *AND (&MBROPT *EQ + *ADD)) THEN(DO) RTVLIBD LIB(&WRKLIB) TEXT(&RTVTXT) CHGVAR VAR(&WRKLIBTXT) VALUE(&RTVTXT *TCAT '-' + *TCAT &LIB) ENDDO WHEN COND(&TEXT *EQ *SAME) THEN(CHGVAR + VAR(&WRKLIBTXT) VALUE(*SAME)) WHEN COND(&TEXT *EQ *LIB) THEN(CHGVAR + VAR(&WRKLIBTXT) VALUE('Clean Work:' *BCAT + &LIB)) OTHERWISE CMD(CHGVAR VAR(&WRKLIBTXT) VALUE('Clean + Work:' *BCAT &TEXT)) ENDSELECT /* Impone un testo alla work library. */ CHGLIB LIB(&WRKLIB) TEXT(&WRKLIBTXT) /* Controlla l'esistenza del file ForcedFlags. */ CHKOBJ OBJ(&WRKLIB/JCLNPFFF) OBJTYPE(*FILE) + MBR(*FIRST) /* Se manca. */ MONMSG MSGID(CPF0000 MCH0000) EXEC(DO) /* Crea il file ForcedFlags. */ JCPYCLR FROMFILE(JCLNPFFF) TOFILE(&WRKLIB/*FROMFILE) /* Se manca. */ ENDDO /* Se richiesta sostituzione record. */ IF COND(&MBROPT *EQ *REPLACE) THEN(DO) /* Cancella i file logici PhysicalCleaning. */ DLTF FILE(&WRKLIB/JCLNPFMB1) MONMSG MSGID(CPF0000 MCH0000) DLTF FILE(&WRKLIB/JCLNPFOD1) MONMSG MSGID(CPF0000 MCH0000) /* Cancella i file fisici PhysicalCleaning. */ DLTF FILE(&WRKLIB/JCLNPFMB) MONMSG MSGID(CPF0000 MCH0000) DLTF FILE(&WRKLIB/JCLNPFOD) MONMSG MSGID(CPF0000 MCH0000) DLTF FILE(&WRKLIB/JCLNPFCA) MONMSG MSGID(CPF0000 MCH0000) /* Crea i file fisici PhysicalCleaning. */ JCPYCLR FROMFILE(JCLNPFMB) TOFILE(&WRKLIB/*FROMFILE) JCPYCLR FROMFILE(JCLNPFOD) TOFILE(&WRKLIB/*FROMFILE) JCPYCLR FROMFILE(JCLNPFCA) TOFILE(&WRKLIB/*FROMFILE) /* Crea i file logici PhysicalCleaning. */ CRTDUPOBJ OBJ(JCLNPFMB1) FROMLIB(*LIBL) OBJTYPE(*FILE) + TOLIB(&WRKLIB) CRTDUPOBJ OBJ(JCLNPFOD1) FROMLIB(*LIBL) OBJTYPE(*FILE) + TOLIB(&WRKLIB) /* Se richiesta sostituzione record. */ ENDDO /* Se richiesta sostituzione informazioni su una libreria. */ IF COND(&MBROPT *EQ *RPLLIB) THEN(DO) /* Cancella le vecchie informazioni sulla libreria. */ OVRDBF FILE(JCLNPFMB) TOFILE(&WRKLIB/JCLNPFMB) OVRDBF FILE(JCLNPFOD) TOFILE(&WRKLIB/JCLNPFOD) OVRDBF FILE(JCLNPFCA) TOFILE(&WRKLIB/JCLNPFCA) OVRDBF FILE(JCLNPFFF) TOFILE(&WRKLIB/JCLNPFFF) CALL PGM(JCLNPF1D) PARM(&LIB) DLTOVR FILE(*ALL) /* Riorganizza i file sui quali ha cancellato i record. */ RGZPFM FILE(&WRKLIB/JCLNPFMB) RGZPFM FILE(&WRKLIB/JCLNPFOD) RGZPFM FILE(&WRKLIB/JCLNPFCA) RGZPFM FILE(&WRKLIB/JCLNPFFF) /* Se richiesta sostituzione informazioni su una libreria. */ ENDDO /* Messaggia "DSPFD in corso". */ CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB *CAT &LIB) JSNDMSG MSGID(JCL0103) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Estrae il Display File Description Type Member. */ DSPFD FILE(&LIB/*ALL) TYPE(*MBR) OUTPUT(*OUTFILE) + FILEATR(*PF) OUTFILE(&WRKLIB/JCLNPFMB) + OUTMBR(*FIRST &MBROPTX) /* Se rileva doppioni, segnala "Chiavi doppie" e abbandona. */ MONMSG MSGID(CPF3068) EXEC(DO) CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB) JSNDMSG MSGID(JCL0105) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*DIAG) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) GOTO CMDLBL(CPF0001) ENDDO /* Messaggia "DSPOBJD in corso". */ CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB *CAT &LIB) JSNDMSG MSGID(JCL0104) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Estrae il Display Object Description File Full. */ DSPOBJD OBJ(&LIB/*ALL) OBJTYPE(*FILE) DETAIL(*FULL) + OUTPUT(*OUTFILE) + OUTFILE(&WRKLIB/JCLNPFOD) OUTMBR(*FIRST + &MBROPTX) /* Messaggia "Riempita Work Library". */ IF COND(&MBROPT *EQ *REPLACE) THEN(DO) CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB *CAT &LIB) JSNDMSG MSGID(JCL0110) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*COMP) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) ENDDO /* Messaggia "Aggiunte a Work Library". */ IF COND(&MBROPT *EQ *ADD) THEN(DO) CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB *CAT &LIB) JSNDMSG MSGID(JCL0111) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*COMP) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) ENDDO /* Messaggia "Sostituite info libreria". */ IF COND(&MBROPT *EQ *RPLLIB) THEN(DO) CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB *CAT &LIB) JSNDMSG MSGID(JCL0112) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*COMP) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) ENDDO /* Prepara la chiamata di un query per esplorare il risultato. */ JRQT CMD(RUNQRY QRYFILE((&WRKLIB/JCLNPFMB)) + RCDSLT(*YES)) REFPGM(&REFPGM) JRQT CMD(RUNQRY QRYFILE((&WRKLIB/JCLNPFOD)) + RCDSLT(*YES)) REFPGM(&REFPGM) /* Prepara la chiamata del comando successivo della procedura. */ JRQT CMD(JCLNPF2 WRK(&WRK) SLTUSE(CYYMMDD) + SLTCNT(2) SLTCHG(CYYMMDD)) REFPGM(&REFPGM) /* Label di esecuzione delle attivitā finali. */ RCLRSC: /* Dealloca ... */ /* Riacquisisce le risorse. */ RCLRSC MONMSG MSGID(CPF0000 MCH0000) /* Se richiesto, rilascia il CPF0001. */ IF COND(&CPF0001) THEN(DO) JSNDMSG MSGID(CPF0001) MSGF(QCPFMSG) MSGDTA(JCLNPF1) + MSGTYPE(*MSGQ) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) MONMSG MSGID(CPF0000 MCH0000) SNDPGMMSG MSGID(CPF0001) MSGF(QCPFMSG) MSGDTA(JCLNPF1) + MSGTYPE(*ESCAPE) MONMSG MSGID(CPF0000 MCH0000) ENDDO /* Ritorna. */ RETURN /* Label di errore. */ ERRORE: /* Restituisce i messaggi al chiamante, */ /* trasformando eventuali escape in diagnostici. */ JRSNMSG MONMSG MSGID(CPF0000 MCH0000) /* Label di prenotazione del CPF0001. */ CPF0001: /* Prenota il CPF0001. */ CHGVAR VAR(&CPF0001) VALUE('1') MONMSG MSGID(CPF0000 MCH0000) /* Salta alle attivitā finali. */ GOTO CMDLBL(RCLRSC) ENDPGM //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF1D) FILETYPE(*SRC) ENDCHAR('//ENDSRC') * Claudio Neroni 22-10-2015 Creato. * Cleanings. Physical. Create & Fill Work Library. DltLibInfo * Pulizie. Fisici. Crea e riempie la Libreria di lavoro. * Cancella Informazioni su una Libreria * Se richiesta la sostituzione di una libreria gia' esaminata, * cancella le vecchie informazioni dai file della work library. * *--------------------------------------------------------------------------------------------- * Cleanings. Physical. Mbr Fjclnpfmb up e disk * Cleanings. Physical. ObjD Fjclnpfod us e disk * Cleanings. Physical. Candidates Fjclnpfca us e disk * Cleanings. Physical. ForcedFlags Fjclnpfff us e disk *--------------------------------------------------------------------------------------------- * Identifica i record nei file. IQWHFDMBR 01 IQLIDOBJD 02 ICMR 03 IFFR 04 *--------------------------------------------------------------------------------------------- C TAG TAG *--------------------------------------------------------------------------------------------- * Se corre Mbr. C if *in01 * Se la libreria e' quella ricevuta nei parametri. C if MBLIB = PPLIB * Cancella il record. C delete QWHFDMBR * Se la libreria e' diversa da quella ricevuta nei parametri. C else * Rilascia il record. C unlock jclnpfmb * End. C endif * Se corre Mbr. C endif *--------------------------------------------------------------------------------------------- * Se corre Objd. C if *in02 * Se la libreria e' quella ricevuta nei parametri. C if ODLBNM = PPLIB * Cancella il record. C delete QLIDOBJD * Se la libreria e' diversa da quella ricevuta nei parametri. C else * Rilascia il record. C unlock jclnpfod * End. C endif * Se corre Objd. C endif *--------------------------------------------------------------------------------------------- * Se corre Candidates. C if *in03 * Se la libreria e' quella ricevuta nei parametri. C if CMLIB = PPLIB * Cancella il record. C delete CMR * Se la libreria e' diversa da quella ricevuta nei parametri. C else * Rilascia il record. C unlock jclnpfca * End. C endif * Se corre Candidates. C endif *--------------------------------------------------------------------------------------------- * Se corre ForcedFlags. C if *in04 * Se la libreria e' quella ricevuta nei parametri * e se il record non porta forzatura. C if FFLIB = PPLIB C and FFFRFG = *blank * Cancella il record. C delete FFR * Se la libreria e' diversa da quella ricevuta nei parametri * o se il record porta forzatura. C else * Rilascia il record. C unlock jclnpfff * End. C endif * Se corre ForcedFlags. C endif *--------------------------------------------------------------------------------------------- * Inizializza. C *inzsr begsr * Scambia parametri. C *entry plist C parm PPLIB 10 I Library C endsr *--------------------------------------------------------------------------------------------- //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF1P) FILETYPE(*SRC) ENDCHAR('//ENDSRC') :PNLGRP. :IMPORT NAME='*' PNLGRP=JPNL. .*------------------------------------------------------------------------------ :HELP NAME=CMD. .*------------------ :H3.Procedura JCLNPF :H2.Cleanings Physical Files :P.La procedura e' composta dai comandi :HP2.JCLNPF1 JCLNPF2 JCLNPF3 JCLNPF4 JCLNPF5:EHP2. documentati nei rispettivi help mentre la documentazione della procedura risiede nell'help del comando fittizio :HP2.JCLNPF:EHP2. .*------------------ :H3.Comando JCLNPF1 :H2.Extracts work DB to clean PF :P.Crea e riempie la libreria di lavoro per la pulizia dei file fisici. .*------------------ :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/wrk'. :H3.Cleaning work library suffix (WRK) :P.La procedura utilizza un gruppo di file con prefisso "JCLN" che vengono creati, riempiti e gestiti in una "Work Library" il cui nome viene composto facendo uso dello stesso prefisso "JCLN" e del suffisso indicato in questo parametro. :P.Il suffisso e' il primo parametro in tutti i comandi della procedura ed identifica in modo elementare ed univoco l'operazione di pulizia intrapresa con il primo comando della serie (JCLNPF1). :P.Valori permessi: :PARML. :PT.Nome di 6 caratteri :PD.Il valore č obbligatorio. :EPARML. :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/lib'. :H3.Library or Library list (LIB) :P.Nome della libreria da pulire. :P.Valori permessi: :PARML. :PT.Nome Libreria :PD.La libreria da cui estrarre le info necessarie alla pulizia. :EPARML. :P.Valori speciali: :PARML. :PT.:PK DEF.*USRLIBL:EPK. :PD.Le librerie da cui estrarre le info necessarie alla pulizia sono tutte quelle presenti nella parte utente della lista librerie corrente. :PT.*LIBL :PD.Le librerie da cui estrarre le info necessarie alla pulizia sono tutte quelle presenti nella lista librerie corrente. :PT.*ALLUSR :PD.Le librerie da cui estrarre le info necessarie alla pulizia sono tutte le librerie utente. :PT.*ALL :PD.Le librerie da cui estrarre le info necessarie alla pulizia sono tutte quelle presenti sul sistema. :EPARML. :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/mbropt'. :H3.Replace/Add/ReplaceLib info (MBROPT) :P.Opzione di Sostituzione/Aggiunta/SostituzioneParziale delle informazioni. :P.Valori permessi: :PARML. :PT.:PK DEF.*REPLACE:EPK. :PD.Sostituisce tutte le informazioni presenti nella Clean Work Library con le info ricavate dalle librerie esaminate nel run corrente. Fanno eccezione solo i dati contenuti nel file ForcedFlags che possono essere rimossi solo intenzionalmente con il comando JCLNPF3 con il parametro MBROPT(*REPLACE). :PT.*ADD :PD.Aggiunge le info ricavate dalle librerie esaminate nel run corrente alle informazioni gia' presenti nella Clean Work Library. :PT.*RPLLIB :PD.Sostituisce nella Clean Work Library le info relative alle sole librerie esaminate nel run corrente. :EPARML. :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/text'. :H3.Short text of Work library (TEXT) :P.Testo della Clean Work Library. :P.Valori permessi: :PARML. :PT.Testo descrittivo :PD.Un testo a piacere da attribuire alla Clean Work Library per identificare l'attivita' di pulizia in corso per un massimo di 38 caratteri. :EPARML. :P.Valori speciali: :PARML. :PT.:PK DEF.*SAME:EPK. - *LIB - *LIBADD :PD.L'attribuzione del testo avviene valutando le condizioni qui sotto specificate nell'ordine in cui sono elencate: :P.Se corrono MBROPT(*REPLACE) e TEXT(*SAME), compone per la Clean Work Library un testo di 50 caratteri riunendo la costante "Clean Work: " con il contenuto del parametro LIB. :P.Se corrono MBROPT(*ADD) e TEXT(*LIBADD), accoda al testo gia' attribuito alla Clean Work Library un trattino seguito dal contenuto del parametro LIB. :P.Se corre TEXT(*SAME), lascia inalterato il testo gia' attribuito alla Clean Work Library. :P.Se corre TEXT(*LIB), compone per la Clean Work Library un testo di 50 caratteri riunendo la costante "Clean Work: " con il contenuto del parametro LIB. :P.In tutti gli altri casi, compone per la Clean Work Library un testo di 50 caratteri riunendo la costante "Clean Work: " con il contenuto del parametro TEXT. :EPARML. :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/refpgm'. :IMHELP NAME='refpgm'. :EHELP. .*------------------------------------------------------------------------------ :HELP NAME='CMD/COMMAND/EXAMPLES'. :XH3.Esempi d'uso del comando :P.:HP2.Esempio 1: Avvia l'esame di una libreria da pulire.:EHP2. :XMP. Con i soli parametri necessari: JCLNPF1 WRK(NERO) LIB(NERONI2) Anche con i parametri di default: JCLNPF1 WRK(NERO) LIB(NERONI2) MBROPT(*REPLACE) TEXT(*SAME) REFPGM(*CPP) :EXMP. :P.Questo comando avvia l'esame della libreria NERONI2 creando e utilizzando la libreria di work JCLNNERO. Il comando genera un log di cui si riporta esempio. :XMP. > JCLNPF1 WRK(NERO) LIB(NERONI2) ->Verifica esistenza database in WorkLib: JCLNNERO ->Display File Desc Type Member in corso lib NERONI2 ->Display Object Desc Type File Detail Full in corso lib NERONI2 ->Creata e riempita WorkLib JCLNNERO per pulizia file fisici di NERONI2 > /**/RUNQRY QRYFILE((JCLNNERO/JCLNPFMB)) RCDSLT(*YES) > /**/RUNQRY QRYFILE((JCLNNERO/JCLNPFOD)) RCDSLT(*YES) > /**/JCLNPF2 WRK(NERO) SLTUSE(CYYMMDD) SLTCNT(2) SLTCHG(CYYMMDD) :EXMP. :P.Si osservino i messaggi informativi e i comandi promemoria duplicabili per indagare o per eseguire i passi successivi della procedura. :EHELP. .*------------------------------------------------------------------------------ :HELP NAME='CMD/ERROR/MESSAGES'. .*------------------ :XH3.Messaggi informativi e di completamento :P.:HP3.Messaggi *INFO e *COMP:EHP3. :DL COMPACT. :DT.JCL0101 :DD.&MSG(JCL0101,JCLNPF,*LIBL,nosub). :DT.JCL0103 :DD.&MSG(JCL0103,JCLNPF,*LIBL,nosub). :DT.JCL0104 :DD.&MSG(JCL0104,JCLNPF,*LIBL,nosub). :DT.JCL0110 :DD.&MSG(JCL0110,JCLNPF,*LIBL,nosub). :DT.JCL0111 :DD.&MSG(JCL0111,JCLNPF,*LIBL,nosub). :DT.JCL0112 :DD.&MSG(JCL0112,JCLNPF,*LIBL,nosub). :EDL. .*--------------------- :XH3.Messaggi di errore :P.:HP3.Messaggi *DIAG seguiti da *ESCAPE CPF0001:EHP3. :DL COMPACT. :DT.JCL0106 :DD.&MSG(JCL0106,JCLNPF,*LIBL,nosub). :DT.JCL0003 :DD.&MSG(JCL0003,JCLNPF,*LIBL,nosub). :DT.JCL0107 :DD.&MSG(JCL0107,JCLNPF,*LIBL,nosub). :DT.JCL0102 :DD.&MSG(JCL0102,JCLNPF,*LIBL,nosub). :DT.JCL0105 :DD.&MSG(JCL0105,JCLNPF,*LIBL,nosub). :EDL. .*------------------ :EHELP. .*------------------------------------------------------------------------------ :EPNLGRP. //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF2) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 10-09-2015 Creato. */ /* Cleanings. Physical. Select Candidates. Cmd */ /* Pulizie. Fisici. Sceglie i membri candidati alla pulizia. Comando */ /* */ CMD PROMPT('Select candidates to clean PF') PARM KWD(WRK) TYPE(*NAME) LEN(6) MIN(1) + PROMPT('Cleaning work library suffix') PARM KWD(SLTUSE) TYPE(*CHAR) LEN(7) + SPCVAL((*NONE) (*PRV)) MIN(1) + PROMPT('Select last use date CYYMMDD') PARM KWD(SLTCNT) TYPE(*DEC) LEN(5) DFT(2) + PROMPT('Select use count') PARM KWD(SLTCHG) TYPE(*CHAR) LEN(7) DFT(*SLTUSE) + SPCVAL((*SLTUSE) (*NONE) (*PRV)) + PROMPT('Select last chg date CYYMMDD') PARM KWD(REFPGM) TYPE(*NAME) LEN(10) DFT(*CPP) + SPCVAL((*CPP)) PROMPT('Reference program + for messages') //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF2C) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 10-09-2015 Creato. */ /* Cleanings. Physical. Select Candidates. Cpp */ /* Pulizie. Fisici. Sceglie i membri candidati alla pulizia. Cpp */ /* Trascrive in un tracciato ridotto e dotato di flag */ /* i nomi dei membri candidati alla pulizia. */ /* */ PGM PARM(&WRK &SLTUSE &SLTCNT &SLTCHG &REFPGM) /* Riceve Cleaning work library suffix. */ DCL VAR(&WRK) TYPE(*CHAR) LEN(6) /* Cleaning work library. */ DCL VAR(&WRKLIB) TYPE(*CHAR) LEN(10) /* Riceve Data ultimo uso per scelta record. */ DCL VAR(&SLTUSE) TYPE(*CHAR) LEN(7) DCL VAR(&SLTUSEPRV) TYPE(*CHAR) LEN(7) /* Riceve Conteggio uso per scelta record. */ DCL VAR(&SLTCNT) TYPE(*DEC) LEN(5) DCL VAR(&SLTCNTC) TYPE(*CHAR) LEN(3) DCL VAR(&SLTCNTPRV) TYPE(*DEC) LEN(5) /* Riceve Data ultima modifica per scelta record. */ DCL VAR(&SLTCHG) TYPE(*CHAR) LEN(7) DCL VAR(&SLTCHGPRV) TYPE(*CHAR) LEN(7) /* Riceve Programma di riferimento per i messaggi. */ DCL VAR(&REFPGM) TYPE(*CHAR) LEN(10) /* Flag di errore. */ DCL VAR(&ERR) TYPE(*LGL) /* Numero di record nell'elenco. */ DCL VAR(&NCR) TYPE(*DEC) LEN(10 0) DCL VAR(&NCRC) TYPE(*CHAR) LEN(6) /* Messaggio. */ DCL VAR(&MSGDTA) TYPE(*CHAR) LEN(512) /* Struttura dati di dieci contatori impaccati (10,0 Signed = 6 Char pack). */ /* Palleggiati tra rpg e messaggio senza dettagliarli nel presente cl. */ DCL VAR(&DS10PAK) TYPE(*CHAR) LEN(60) /* File messaggi. */ DCL VAR(&MSGF) TYPE(*CHAR) LEN(10) VALUE(JCLNPF) /* To message queue. */ DCL VAR(&TOMSGQ) TYPE(*CHAR) LEN(10) VALUE(JCLNPF) DCL VAR(&TOMSGQTXT) TYPE(*CHAR) LEN(50) + VALUE('Cleanings Physical Files') /* Prenotazione del CPF0001. */ DCL VAR(&CPF0001) TYPE(*LGL) /* Intercetta gli errori imprevisti. */ MONMSG MSGID(CPF0000 MCH0000 CEE0000) EXEC(GOTO + CMDLBL(ERRORE)) /* Se richiesto *CPP (Command Processing Program) come programma */ /* di riferimento dei messaggi, assume il nome del programma corrente. */ IF COND(&REFPGM *EQ *CPP) THEN(DO) JCALLER CALLER(&REFPGM) KINSHIP(*FATHER) ENDDO /* Compone il nome della Cleaning work library. */ CHGVAR VAR(&WRKLIB) VALUE(JCLN *CAT &WRK) /* Controlla l'esistenza della work library. */ CHKOBJ OBJ(&WRKLIB) OBJTYPE(*LIB) /* Se la work library non esiste, segnala. */ MONMSG MSGID(CPF0000) EXEC(DO) CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB *CAT &WRK) SNDPGMMSG MSGID(JCL0002) MSGF(&MSGF) MSGDTA(&MSGDTA) + TOPGMQ(*PRV (&REFPGM)) MSGTYPE(*DIAG) GOTO CMDLBL(CPF0001) ENDDO /* Avvia coda messaggi. */ JSNDMSG MSGDTA(JCLNPF2) MSGTYPE(*INFO) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) + TOMSGQTXT(&TOMSGQTXT) SEQ(*FIRST) /* Controlla la validita' della data ultimo uso. */ IF COND(&SLTUSE *NE *NONE *AND &SLTUSE *NE + *PRV) THEN(DO) CALL PGM(JCLNTSTDAT) PARM(&SLTUSE &ERR) /* Se la data non e' valida, segnala e abbandona. */ IF COND(&ERR) THEN(DO) JSNDMSG MSGID(JCL0202) MSGF(&MSGF) MSGDTA(&SLTUSE) + MSGTYPE(*DIAG) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) GOTO CMDLBL(CPF0001) ENDDO ENDDO /* Se la data ultima modifica deve essere uguale alla data ultimo uso, */ /* la assume. */ IF COND(&SLTCHG *EQ *SLTUSE) THEN(DO) CHGVAR VAR(&SLTCHG) VALUE(&SLTUSE) ENDDO /* Controlla la validita' della data ultima modifica. */ IF COND(&SLTCHG *NE *NONE *AND &SLTCHG *NE + *PRV) THEN(DO) CALL PGM(JCLNTSTDAT) PARM(&SLTCHG &ERR) /* Se la data non e' valida, segnala e abbandona. */ IF COND(&ERR) THEN(DO) JSNDMSG MSGID(JCL0203) MSGF(&MSGF) MSGDTA(&SLTCHG) + MSGTYPE(*DIAG) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) GOTO CMDLBL(CPF0001) ENDDO ENDDO /* Se richiesti i parametri del run precedente. */ IF COND(&SLTUSE *EQ *PRV *OR &SLTCHG *EQ *PRV) + THEN(DO) /* Recupera i parametri dal record "Fotografia Parametri" */ /* presente nel file elenco dei membri candidati alla pulizia. */ OVRDBF FILE(JCLNPFCA) TOFILE(&WRKLIB/JCLNPFCA) CALL PGM(JCLNPF2F) PARM(&SLTUSEPRV &SLTCNTPRV + &SLTCHGPRV) DLTOVR FILE(*ALL) /* Se non trova il record "Fotografia Parametri", segnala e abbandona. */ IF COND(&SLTUSEPRV *EQ *NFOUND) THEN(DO) JSNDMSG MSGID(JCL0204) MSGF(&MSGF) MSGTYPE(*DIAG) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) GOTO CMDLBL(CPF0001) ENDDO /* Se richiesti i parametri del run precedente. */ ENDDO /* Se richiesta data ultimo uso precedente, la assume con la conta. */ IF COND(&SLTUSE *EQ *PRV) THEN(DO) CHGVAR VAR(&SLTUSE) VALUE(&SLTUSEPRV) CHGVAR VAR(&SLTCNT) VALUE(&SLTCNTPRV) ENDDO /* Se richiesta data ultima modifica precedente, la assume. */ IF COND(&SLTCHG *EQ *PRV) THEN(DO) CHGVAR VAR(&SLTCHG) VALUE(&SLTCHGPRV) ENDDO /* Messaggia "Genera elenco". */ JDECCHA FROMDEC(&SLTCNT) TOCHAR3(&SLTCNTC) CHGVAR VAR(&MSGDTA) VALUE(&WRK *CAT &SLTUSE *CAT + &SLTCNTC *CAT &WRKLIB) JSNDMSG MSGID(JCL0201) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Pulisce l'elenco candidati. */ CLRPFM FILE(&WRKLIB/JCLNPFCA) /* Trascrive in emissione l'elenco dei membri candidati alla pulizia. */ OVRDBF FILE(JCLNPFMB1) TOFILE(&WRKLIB/JCLNPFMB1) OVRDBF FILE(JCLNPFOD1) TOFILE(&WRKLIB/JCLNPFOD1) OVRDBF FILE(JCLNPFFF) TOFILE(&WRKLIB/JCLNPFFF) OVRDBF FILE(JCLNPFCA) TOFILE(&WRKLIB/JCLNPFCA) CALL PGM(JCLNPF2D) PARM(&SLTUSE &SLTCNT &SLTCHG) DLTOVR FILE(*ALL) /* Analizza il contenuto dell'elenco dei membri candidati alla pulizia. */ OVRDBF FILE(JCLNPFCA) TOFILE(&WRKLIB/JCLNPFCA) CALL PGM(JCLNPF2E) PARM(&DS10PAK) DLTOVR FILE(*ALL) /* Recupera il numero di record nell'elenco. */ /* Toglie 1 per record foto parametri. */ RTVMBRD FILE(&WRKLIB/JCLNPFCA) NBRCURRCD(&NCR) CHGVAR VAR(&NCR) VALUE(&NCR - 1) JDECCHA FROMDEC(&NCR) TOCHAR6(&NCRC) /* Messaggia "Analisi flag". */ CHGVAR VAR(&MSGDTA) VALUE(&DS10PAK) JSNDMSG MSGID(JCL0211) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*COMP) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Messaggia "Generato elenco". */ CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB *CAT &NCRC) JSNDMSG MSGID(JCL0210) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*COMP) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Prepara la chiamata di un query per esplorare il risultato. */ JRQT CMD(RUNQRY QRYFILE((&WRKLIB/JCLNPFCA)) + RCDSLT(*YES)) REFPGM(&REFPGM) /* Prepara la chiamata del comando successivo della procedura. */ JRQT CMD(JCLNPF3 WRK(&WRK)) REFPGM(&REFPGM) /* Chiama il controllo che le librerie duplicate, se esistenti, */ /* appartengano alla work library corrente. */ OVRDBF FILE(JCLNPFCA) TOFILE(&WRKLIB/JCLNPFCA) CALL PGM(JCLNPFCDL) PARM(&WRKLIB &REFPGM &ERR) DLTOVR FILE(*ALL) /* Se errore, rilascia. */ IF COND(&ERR) THEN(GOTO CMDLBL(CPF0001)) /* Label di esecuzione delle attivitā finali. */ RCLRSC: /* Dealloca ... */ /* Riacquisisce le risorse. */ RCLRSC MONMSG MSGID(CPF0000 MCH0000) /* Se richiesto, rilascia il CPF0001. */ IF COND(&CPF0001) THEN(DO) JSNDMSG MSGID(CPF0001) MSGF(QCPFMSG) MSGDTA(JCLNPF2) + MSGTYPE(*MSGQ) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) MONMSG MSGID(CPF0000 MCH0000) SNDPGMMSG MSGID(CPF0001) MSGF(QCPFMSG) MSGDTA(JCLNPF2) + MSGTYPE(*ESCAPE) MONMSG MSGID(CPF0000 MCH0000) ENDDO /* Ritorna. */ RETURN /* Label di errore. */ ERRORE: /* Restituisce i messaggi al chiamante, */ /* trasformando eventuali escape in diagnostici. */ JRSNMSG MONMSG MSGID(CPF0000 MCH0000) /* Label di prenotazione del CPF0001. */ CPF0001: /* Prenota il CPF0001. */ CHGVAR VAR(&CPF0001) VALUE('1') MONMSG MSGID(CPF0000 MCH0000) /* Salta alle attivitā finali. */ GOTO CMDLBL(RCLRSC) RETURN /*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/ ENDPGM //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF2D) FILETYPE(*SRC) ENDCHAR('//ENDSRC') * Claudio Neroni 10-09-2015 Creato. * Cleanings. Physical. Select Candidates. Wri * Pulizie. Fisici. Sceglie i membri candidati alla pulizia. Scrive * Trascrive in un tracciato ridotto e dotato di flag * i nomi dei membri candidati alla pulizia. CN01 * Claudio Neroni 11-12-2015 Modificato. CN01 * Aggiunto "Totale spazio", somma di spazio dati e spazio indice. CN02 * Claudio Neroni 01-05-2016 Modificato. CN02 * Aggiunto parametro data di ultima modifica del membro. * *--------------------------------------------------------------------------------------------- * Cleanings. Physical. Mbr Fjclnpfmb1 ip e k disk * Cleanings. Physical. ObjD Fjclnpfod1 if e k disk * Cleanings. Physical. ForcedFlags Fjclnpfff if e k disk * Cleanings. Physical. Candidates Fjclnpfca o e disk *--------------------------------------------------------------------------------------------- * Definisce parametri. CN02 * Select Date for last use CYYMMDD / CCYY-MM-DD. CN02 D sltuse s 7 CN02 D sltused s d CN02 * Select Date for last change CYYMMDD / CCYY-MM-DD. CN02 D sltchg s 7 CN02 D sltchgd s d * Select Count. D sltcnt s 5 0 *--------------------------------------------------------------------------------------------- C TAG TAG *--------------------------------------------------------------------------------------------- * Pulisce il tracciato di emissione. C clear cmr * Trascrive dati da record membro a record candidato. C eval CMSYSN = MBSYSN C eval CMLIB = MBLIB C eval CMFILE = MBFILE C eval CMNAME = MBNAME C eval CMUCNT = MBUCNT C eval CMDTAT = MBDTAT C eval CMNOMB = MBNOMB C eval CMMTXT = MBMTXT C eval CMTXT = MBTXT C eval CMNRCD = MBNRCD C eval CMNDTR = MBNDTR CN01 * Somma MBDSZ2 "Dimensione spazio dati in byte" CN01 * e MBISZ2 "Dimensione indice in byte" CN01 * in CMTSIZ "Total size" CN01 C eval CMTSIZ = MBDSZ2 + MBISZ2 * Trascrive date da record membro a record candidato. C if MBUDAT <> *blank C eval CMUDAT = %date((MBUCEN + MBUDAT):*CYMD0) C endif C if MBCDAT <> *blank C eval CMCDAT = %date((MBCCEN + MBCDAT):*CYMD0) C endif C if MBFCDT <> *blank C eval CMFCDT = %date((MBFCCN + MBFCDT):*CYMD0) C endif C if MBCHGD <> *blank C eval CMGDAT = %date((MBCHGC + MBCHGD):*CYMD0) C endif * Trascrive time da record membro a record candidato. C if MBCTIM <> *blank C eval CMCTIM = %time(MBCTIM:*ISO0) C endif C if MBCHGT <> *blank C eval CMGTIM = %time(MBCHGT:*ISO0) C endif *---------- * Definisce chiave per ObjD. C KOD klist C kfld MBSYSN C kfld MBLIB C kfld MBFILE * Cerca ObjD. C KOD chain QLIDOBJD * Se trova ObjD. C if %found(jclnpfod1) * Trascrive dati da record ObjD a record candidato. C eval CMXCNT = ODUCNT * Trascrive date da record ObjD a record candidato. C if ODUDAT <> *blank C eval CMXDAT = %date((ODUCEN + ODUDAT):*CMDY0) C endif C if ODLDAT <> *blank C eval CMFDAT = %date((ODLCEN + ODLDAT):*CMDY0) C endif * Trascrive time da record ObjD a record candidato. C if ODLTIM <> *blank C eval CMFTIM = %time(ODLTIM:*ISO0) C endif * Se trova ObjD. C endif *---------- * Definisce chiave per ForcedFlags. C KFF klist C kfld MBSYSN C kfld MBLIB C kfld MBFILE C kfld MBNAME * Cerca ForcedFlags. C KFF chain FFR * Se trova ForcedFlags. C if %found(jclnpfff) * Trascrive flag da record ForcedFlags a record candidato. C eval CMFRFG = FFFRFG * Se trova ForcedFlags. C endif *---------- CN02 * Logica ante cambio nome SLTDAT->SLTUSE e introduzione di SLTCHG CN02- * Assume Flag scelta iniziale *off=Conserva. CN02-C* eval CMINFG = *off CN02- * Sceglie. CN02-C* select CN02- * Se la data di ultimo uso membro č maggiore della data scelta CN02- * e il numero giorni uso membro č maggiore della conta scelta, conserva. CN02-C* when CMUDAT > SLTDAT and CMUCNT > SLTCNT CN02- * Se la data di creazione membro č maggiore della data scelta, conserva. CN02-C* when CMCDAT > SLTDAT CN02- * Negli altri casi. CN02-C* other CN02- * Assume Flag scelta iniziale *on=Rimuovi. CN02-C* eval CMINFG = *on CN02- * Sceglie. CN02-C* endsl CN02- * *---------- CN02 * Assume Flag scelta iniziale *on=Rimuovi. CN02 C eval CMINFG = *on CN02 * Se richiesta una data ultimo uso non valida, CN02 * se richiesta una data ultima modifica non valida, CN02 * conserva. CN02 C if sltused = d'1901-01-02' CN02 C and sltchgd = d'1901-01-02' CN02 C eval CMINFG = *off CN02 C endif CN02 * Se richiesta una data ultimo uso valida, CN02 * se la data di ultimo uso membro e' maggiore della data scelta, CN02 * se il numero giorni uso membro e' maggiore della conta scelta, CN02 * conserva. CN02 C if sltused <> d'1901-01-02' CN02 C and CMUDAT > sltused CN02 C and CMUCNT > SLTCNT CN02 C eval CMINFG = *off CN02 C endif CN02 * Se richiesta una data ultima modifica valida, CN02 * se la data di ultima modifica membro e' maggiore della data scelta, CN02 * conserva. CN02 C if sltchgd <> d'1901-01-02' CN02 C and CMGDAT > sltchgd CN02 C eval CMINFG = *off CN02 C endif CN02 * Se richiesta una data ultimo uso valida, CN02 * se la data di creazione membro e' maggiore della data scelta, CN02 * conserva. CN02 C if sltused <> d'1901-01-02' CN02 C and CMCDAT > sltused CN02 C eval CMINFG = *off CN02 C endif CN02 * Se richiesta una data ultima modifica valida, CN02 * se la data di creazione membro e' maggiore della data scelta, CN02 * conserva. CN02 C if sltchgd <> d'1901-01-02' CN02 C and CMCDAT > sltchgd CN02 C eval CMINFG = *off CN02 C endif *---------- * Decide il flag finale. * Trascrive iniziale nel finale. C eval CMFIFG = CMINFG * Se forzato uguale a "0" o a "1", trascrive forzato nel finale. C if CMFRFG = '0' or CMFRFG = '1' C eval CMFIFG = CMFRFG C endif *---------- * Scrive per il membro il record di candidatura all'eliminazione. C write CMR *--------------------------------------------------------------------------------------------- * Inizializza. C *inzsr begsr * Scambia parametri. C *entry plist CN02 C parm sltuse I Slt Date Last Use C parm sltcnt I Select Count CN02 C parm sltchg I Slt Date Last Chg CN02 * Converte la data last use. CN02 C if sltuse='*NONE' CN02 C eval sltused=%date('0010102':*cymd0) CN02 C else CN02 C eval sltused=%date(sltuse:*cymd0) CN02 C endif CN02 * Converte la data last change. CN02 C if sltchg='*NONE' CN02 C eval sltchgd=%date('0010102':*cymd0) CN02 C else CN02 C eval sltchgd=%date(sltchg:*cymd0) CN02 C endif * Pulisce il tracciato di emissione. C clear cmr * Fotografa i parametri nel file di emissione. C eval CMLIB = 'Fotografia' C eval CMFILE = 'Parametri ' * Conta uso. C eval CMUCNT = sltcnt CN02 * Data ultimo uso. CN02 C eval CMUDAT = sltused CN02 * Data ultima modifica. CN02 C eval CMGDAT = sltchgd * Scrive la fotografia parametri. C write CMR C endsr *--------------------------------------------------------------------------------------------- //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF2E) FILETYPE(*SRC) ENDCHAR('//ENDSRC') * Claudio Neroni 15-10-2015 Creato. * Cleanings. Physical. Select Candidates. Analysis * Pulizie. Fisici. Sceglie i membri candidati alla pulizia. Analisi * Analizza il contenuto dei flag di scelta * dei membri candidati alla pulizia. * * Cleanings. Physical. Candidates Fjclnpfca ip e disk *--------------------------------------------------------------------------------------------- * Definisce parametri. * Struttura dati di dieci contatori impaccati (10,0 Signed = 6 Char pack). D DS10PAK ds D cnt 1 60p 0 dim(10) *--------------------------------------------------------------------------------------------- C TAG TAG *--------------------------------------------------------------------------------------------- * Conta gli stati del flag Initial. C if CMINFG = *off C eval cnt(01) += 1 C endif C if CMINFG = *on C eval cnt(02) += 1 C endif * Conta gli stati del flag Forced. C if CMFRFG = *off C eval cnt(03) += 1 C endif C if CMFRFG = *on C eval cnt(04) += 1 C endif * Conta gli stati del flag Final. C if CMFIFG = *off C eval cnt(05) += 1 C endif C if CMFIFG = *on C eval cnt(06) += 1 C endif * Conta le combinazioni del flag Forced off con il flag Initial. C if CMFRFG = *off C if CMINFG = *on C eval cnt(07) += 1 C endif C if CMINFG = *off C eval cnt(08) += 1 C endif C endif * Conta le combinazioni del flag Forced on con il flag Initial. C if CMFRFG = *on C if CMINFG = *off C eval cnt(09) += 1 C endif C if CMINFG = *on C eval cnt(10) += 1 C endif C endif *--------------------------------------------------------------------------------------------- * Inizializza. C *inzsr begsr * Scambia parametri. C *entry plist C parm DS10PAK 60 O DS 10 packed 10,0 * Pulisce i contatori. C clear cnt C endsr *--------------------------------------------------------------------------------------------- //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF2F) FILETYPE(*SRC) ENDCHAR('//ENDSRC') * Claudio Neroni 16-10-2015 Creato. * Cleanings. Physical. Select Candidates. ReadPrvParm * Pulizie. Fisici. Sceglie i membri candidati alla pulizia. * Legge i parametri del run precedente * Recupera i parametri utilizzati durante il run precedente * e fotografati nel primo record dei Candidates. * *--------------------------------------------------------------------------------------------- * Cleanings. Physical. Candidates Fjclnpfca ip e disk *--------------------------------------------------------------------------------------------- C TAG TAG *--------------------------------------------------------------------------------------------- * Se corre fotografia parametri. C if CMLIB = 'Fotografia' or C CMFILE = 'Parametri ' * Restituisce i parametri cercati C eval PPSLTUSE = %char(CMUDAT:*cymd0) C eval PPSLTCNT = CMUCNT C eval PPSLTCHG = %char(CMGDAT:*cymd0) * Predispone chiusura. C seton lr * Se corre fotografia parametri. C endif *--------------------------------------------------------------------------------------------- * Inizializza. C *inzsr begsr * Scambia parametri. C *entry plist C parm PPSLTUSE 7 O Prv Slt Lst UseDat C parm PPSLTCNT O Prv Select Count C parm PPSLTCHG 7 O Prv Slt Lst ChgDat * Definisce parametri. C *like define CMUCNT PPSLTCNT * Assume record fotografia non trovato. C eval PPSLTUSE = '*NFOUND' C endsr *--------------------------------------------------------------------------------------------- //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF2P) FILETYPE(*SRC) ENDCHAR('//ENDSRC') :PNLGRP. :IMPORT NAME='*' PNLGRP=JPNL. .*------------------------------------------------------------------------------ :HELP NAME=CMD. .*------------------ :H3.Procedura JCLNPF :H2.Cleanings Physical Files :P.La procedura e' composta dai comandi :HP2.JCLNPF1 JCLNPF2 JCLNPF3 JCLNPF4 JCLNPF5:EHP2. documentati nei rispettivi help mentre la documentazione della procedura risiede nell'help del comando fittizio :HP2.JCLNPF:EHP2. .*------------------ :H3.Comando JCLNPF2 :H2.Select candidates to clean PF :P.Sceglie i membri dei file fisici candidati alla pulizia. :P.Trascrive in un tracciato ridotto e dotato di flag i nomi dei membri candidati alla pulizia. :P.Utilizza i parametri SLT... per confezionare la prima proposta di membri candidati alla pulizia che potra' essere corretta apponendo un flag di scelta sui record dell'apposito file generato dal comando corrente nella libreria di work. :P.Il comando emette un messaggio finale che nel secondo livello espone l'analisi quantitativa dei candidati e dei flag di scelta, sia quelli predisposti dal run corrente che quelli predisposti precedentemente dall'operatore modificando i flag sul file. :P.La logica di candidatura di un membro alla rimozione e' la seguente. :XMP. Dati i parametri data ultimo uso, data ultima modifica, conta: 1) Assume Flag scelta iniziale "Rimuovi". 2) Se richiesta una data ultimo uso non valida, se richiesta una data ultima modifica non valida, annota flag scelta iniziale "Conserva". 3) Se richiesta una data ultimo uso valida, se la data di ultimo uso membro e' maggiore del parametro data ultimo uso, se la conta uso membro e' maggiore del parametro conta. annota flag scelta iniziale "Conserva". 4) Se richiesta una data ultima modifica valida, se la data di ultima modifica membro e' maggiore del parametro data ultima modifica, annota flag scelta iniziale "Conserva". 5) Se richiesta una data ultimo uso valida, se la data di creazione membro e' maggiore del parametro data ultimo uso, annota flag scelta iniziale "Conserva". 6) Se richiesta una data ultima modifica valida, se la data di creazione membro e' maggiore del parametro data ultima modifica, annota flag scelta iniziale "Conserva". :EXMP. .*------------------ :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/wrk'. :H3.Cleaning work library suffix (WRK) :P.La procedura utilizza un gruppo di file con prefisso "JCLN" che vengono creati, riempiti e gestiti in una "Work Library" il cui nome viene composto facendo uso dello stesso prefisso "JCLN" e del suffisso indicato in questo parametro. :P.Il suffisso e' il primo parametro in tutti i comandi della procedura ed identifica in modo elementare ed univoco l'operazione di pulizia intrapresa con il primo comando della serie (JCLNPF1). :P.Valori permessi: :PARML. :PT.Nome di 6 caratteri :PD.Il valore č obbligatorio. :EPARML. :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/sltuse'. :H3.Select last use date CYYMMDD (SLTUSE) :P.Data obbligatoria da confrontare con l'ultimo utilizzo. :P.Condizione necessaria perche' un membro sia scelto per la pulizia, e' che la sua data di ultimo utilizzo sia piu' vecchia della data indicata nel presente parametro. :P.Valori permessi: :PARML. :PT.Data nella forma del job. :PD.Data da confrontare con la data di ultimo utilizzo del membro. :EPARML. :P.Valori speciali: :PARML. :PT.*NONE :PD.Il parametro non e' usato per la scelta dei membri. :PT.*PRV :PD.La data scelta corrisponde all'ultima usata in questa libreria di lavoro da questo stesso comando. :EPARML. :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/sltcnt'. :H3.Select use count (SLTCNT) :P.Numero di giorni da confrontare con il numero di giorni di utilizzo. :P.Condizione necessaria perche' un membro sia scelto per la pulizia, e' che il numero di giorni di utilizzo sia piu' grande del numero indicato nel presente parametro. :P.Valori permessi: :PARML. :PT.:PK DEF.2:EPK. :PD.Due giorni. :PT.Numero di giorni. :PD.Numero di giorni da confrontare con il numero di giorni di utilizzo del membro. :EPARML. :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/sltchg'. :H3.Select last chg date CYYMMDD (SLTCHG) :P.Data facoltativa da confrontare con l'ultima modifica. :P.Condizione necessaria perche' un membro sia scelto per la pulizia, e' che la sua data di ultima modifica sia piu' vecchia della data indicata nel presente parametro. :P.Valori permessi: :PARML. :PT.Data nella forma del job. :PD.Data da confrontare con la data di ultimo utilizzo del membro. :EPARML. :P.Valori speciali: :PARML. :PT.:PK DEF.*NONE:EPK. :PD.Il parametro non e' usato per la scelta dei membri. :PT.*PRV :PD.La data scelta corrisponde all'ultima usata in questa libreria di lavoro da questo stesso comando. :EPARML. :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/refpgm'. :IMHELP NAME='refpgm'. :EHELP. .*------------------------------------------------------------------------------ :HELP NAME='CMD/COMMAND/EXAMPLES'. :XH3.Esempi d'uso del comando :P.:HP2.Esempio 1: Genera il file delle candidature alla pulizia.:EHP2. :XMP. Con i soli parametri necessari: JCLNPF2 WRK(NERO) SLTUSE(1160418) Anche con i parametri di default: JCLNPF2 WRK(NERO) SLTUSE(1160418) SLTCNT(2) SLTCHG(*NONE) REFPGM(*CPP) :EXMP. :P.Questo comando esamina i dati gia' raccolti nella libreria di work JCLNBUM e genera un elenco di membri candidati alla pulizia con una data di ultimo utilizzo piu' vecchia del 18-04-2016. Il comando genera un log di cui si riporta esempio. :XMP. > JCLNPF2 WRK(NERO) SLTUSE(1160418) SLTCNT(2) SLTCHG(*NONE) REFPGM(*CPP) ->Genera elenco membri candidati a pulizia. WorkLib: JCLNNERO ->Da trasferire 123 membri. Vedi secondo livello ->Generato elenco di 689 membri candidati a pulizia. WorkLib: JCLNNERO > /**/RUNQRY QRYFILE((JCLNNERO/JCLNPFCA)) RCDSLT(*YES) > /**/JCLNPF3 WRK(NERO) :EXMP. :P.Si osservino i messaggi informativi e i comandi promemoria duplicabili per indagare o per eseguire i passi successivi della procedura. :P.Si osservi in particolare il secondo livello del messaggio JCL0211 qui riportato perche' contiene una analisi dei flag di scelta. :XMP. Messaggio: ->Da trasferire 123 membri. Vedi secondo livello Analisi delle ricorrenze dei "Selection Flag": "Initial" "Forced" "Final". Initial off 566 Initial on 123 Forced off 0 Forced on 0 Final off 566 Final on 123 Forced off <> Initial 0 Forced off = Initial 0 inutili Forced on <> Initial 0 Forced on = Initial 0 inutili :EXMP. :EHELP. .*------------------------------------------------------------------------------ :HELP NAME='CMD/ERROR/MESSAGES'. :XH3.Messaggi informativi e di completamento :P.:HP3.Messaggi *INFO e *COMP:EHP3. :DL COMPACT. :DT.JCL0201 :DD.&MSG(JCL0201,JCLNPF,*LIBL,nosub). :DT.JCL0211 :DD.&MSG(JCL0211,JCLNPF,*LIBL,nosub). :DT.JCL0210 :DD.&MSG(JCL0210,JCLNPF,*LIBL,nosub). :EDL. :XH3.Messaggi di errore :P.:HP3.Messaggi *DIAG seguiti da *ESCAPE CPF0001:EHP3. :DL COMPACT. :DT.JCL0202 :DD.&MSG(JCL0202,JCLNPF,*LIBL,nosub). :DT.JCL0203 :DD.&MSG(JCL0203,JCLNPF,*LIBL,nosub). :DT.JCL0204 :DD.&MSG(JCL0204,JCLNPF,*LIBL,nosub). :DT.JCL0002 :DD.&MSG(JCL0002,JCLNPF,*LIBL,nosub). :EDL. :EHELP. .*------------------------------------------------------------------------------ :EPNLGRP. //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF3) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 19-09-2015 Creato. */ /* Cleanings. Physical. MngForcedFlags. Cmd */ /* Pulizie. Fisici. Gestisce flag di forzatura. Comando */ /* */ CMD PROMPT('Manage Forced Flags') PARM KWD(WRK) TYPE(*NAME) LEN(6) MIN(1) + PROMPT('Cleaning work library suffix') PARM KWD(MBROPT) TYPE(*CHAR) LEN(10) RSTD(*YES) + DFT(*ADD) VALUES(*ADD *REPLACE *CLRNUL) + PROMPT('Add/Replace/ClrNull flags rcds') PARM KWD(REFPGM) TYPE(*NAME) LEN(10) DFT(*CPP) + SPCVAL((*CPP)) PROMPT('Reference program + for messages') //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF3C) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 19-09-2015 Creato. */ /* Cleanings. Physical. MngForcedFlags. Cpp */ /* Pulizie. Fisici. Gestisce flag di forzatura. Cpp */ /* Gestisce il file di forzatura dei flag. */ /* */ PGM PARM(&WRK &MBROPT &REFPGM) /* Riceve Cleaning work library suffix. */ DCL VAR(&WRK) TYPE(*CHAR) LEN(6) /* Cleaning work library. */ DCL VAR(&WRKLIB) TYPE(*CHAR) LEN(10) /* Riceve Richiesta di aggiunta /sostituzione. */ DCL VAR(&MBROPT) TYPE(*CHAR) LEN(10) /* Riceve Programma di riferimento per i messaggi. */ DCL VAR(&REFPGM) TYPE(*CHAR) LEN(10) /* Flag di errore. */ DCL VAR(&ERR) TYPE(*LGL) /* Messaggio. */ DCL VAR(&MSGDTA) TYPE(*CHAR) LEN(512) /* Numero di record nell'elenco. */ DCL VAR(&NCRANTE) TYPE(*DEC) LEN(10 0) DCL VAR(&NCRPOST) TYPE(*DEC) LEN(10 0) DCL VAR(&NCRPOSTC) TYPE(*CHAR) LEN(6) DCL VAR(&DELTA) TYPE(*DEC) LEN(10 0) DCL VAR(&DELTAC) TYPE(*CHAR) LEN(6) /* Struttura dati di dieci contatori impaccati (10,0 Signed = 6 Char pack). */ /* Palleggiati tra rpg e messaggio senza dettagliarli nel presente cl. */ DCL VAR(&DS10PAK) TYPE(*CHAR) LEN(60) /* File messaggi. */ DCL VAR(&MSGF) TYPE(*CHAR) LEN(10) VALUE(JCLNPF) /* To message queue. */ DCL VAR(&TOMSGQ) TYPE(*CHAR) LEN(10) VALUE(JCLNPF) DCL VAR(&TOMSGQTXT) TYPE(*CHAR) LEN(50) + VALUE('Cleanings Physical Files') /* Prenotazione del CPF0001. */ DCL VAR(&CPF0001) TYPE(*LGL) /* Intercetta gli errori imprevisti. */ MONMSG MSGID(CPF0000 MCH0000 CEE0000) EXEC(GOTO + CMDLBL(ERRORE)) /* Se richiesto *CPP (Command Processing Program) come programma */ /* di riferimento dei messaggi, assume il nome del programma corrente. */ IF COND(&REFPGM *EQ *CPP) THEN(DO) JCALLER CALLER(&REFPGM) KINSHIP(*FATHER) ENDDO /* Compone il nome della Cleaning work library. */ CHGVAR VAR(&WRKLIB) VALUE(JCLN *CAT &WRK) /* Controlla l'esistenza della work library. */ CHKOBJ OBJ(&WRKLIB) OBJTYPE(*LIB) /* Se la work library non esiste, segnala. */ MONMSG MSGID(CPF0000) EXEC(DO) CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB *CAT &WRK) SNDPGMMSG MSGID(JCL0002) MSGF(&MSGF) MSGDTA(&MSGDTA) + TOPGMQ(*PRV (&REFPGM)) MSGTYPE(*DIAG) GOTO CMDLBL(CPF0001) ENDDO /* Avvia coda messaggi. */ JSNDMSG MSGDTA(JCLNPF3) MSGTYPE(*INFO) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) + TOMSGQTXT(&TOMSGQTXT) SEQ(*FIRST) /* Messaggia "Crea scheletro per forzature". */ CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB) JSNDMSG MSGID(JCL0301) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Se richiesto, pulisce l'elenco forzature. */ IF COND(&MBROPT *EQ *REPLACE) THEN(DO) CLRPFM FILE(&WRKLIB/JCLNPFFF) ENDDO /* Recupera il numero di record nell'elenco. */ RTVMBRD FILE(&WRKLIB/JCLNPFFF) NBRCURRCD(&NCRANTE) /* Se richiesta sostituzione o aggiunta. */ IF COND((&MBROPT *EQ *REPLACE) *OR (&MBROPT *EQ + *ADD)) THEN(DO) /* Aggiunge al file delle forzature i record mancanti */ /* senza ricalcare i record giā esistenti. */ OVRDBF FILE(JCLNPFCA) TOFILE(&WRKLIB/JCLNPFCA) OVRDBF FILE(JCLNPFFF) TOFILE(&WRKLIB/JCLNPFFF) CALL PGM(JCLNPF3D) DLTOVR FILE(*ALL) /* Se richiesta sostituzione o aggiunta. */ ENDDO /* Se richiesta cancellazione dei record senza flag di forzatura. */ IF COND(&MBROPT *EQ *CLRNUL) THEN(DO) /* Cancella dal file i record inutili. */ OVRDBF FILE(JCLNPFFF) TOFILE(&WRKLIB/JCLNPFFF) CALL PGM(JCLNPF3F) DLTOVR FILE(*ALL) /* Riorganizza il file sul quale ha cancellato i record. */ RGZPFM FILE(&WRKLIB/JCLNPFFF) /* Se richiesta cancellazione dei record senza flag di forzatura. */ ENDDO /* Analizza il contenuto del file delle forzature. */ OVRDBF FILE(JCLNPFFF) TOFILE(&WRKLIB/JCLNPFFF) CALL PGM(JCLNPF3E) PARM(&DS10PAK) DLTOVR FILE(*ALL) /* Recupera il numero di record nell'elenco. */ RTVMBRD FILE(&WRKLIB/JCLNPFFF) NBRCURRCD(&NCRPOST) /* Calcola il delta e lo prepara per il messaggio. */ CHGVAR VAR(&DELTA) VALUE(&NCRPOST - &NCRANTE) JDECCHA FROMDEC(&DELTA) TOCHAR6(&DELTAC) /* Messaggia "Analisi flag". */ CHGVAR VAR(&MSGDTA) VALUE(&DS10PAK) JSNDMSG MSGID(JCL0312) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*COMP) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Messaggia "Sostituito scheletro forzature". */ IF COND(&MBROPT *EQ *REPLACE) THEN(DO) CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB *CAT &DELTAC) JSNDMSG MSGID(JCL0310) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*COMP) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) ENDDO /* Messaggia "Aggiunte a scheletro forzature". */ IF COND(&MBROPT *EQ *ADD) THEN(DO) CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB *CAT &DELTAC) JSNDMSG MSGID(JCL0311) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*COMP) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) ENDDO /* Messaggia "Pulito scheletro forzature". */ IF COND(&MBROPT *EQ *CLRNUL) THEN(DO) CHGVAR VAR(&DELTA) VALUE(0 - &DELTA) JDECCHA FROMDEC(&DELTA) TOCHAR6(&DELTAC) JDECCHA FROMDEC(&NCRPOST) TOCHAR6(&NCRPOSTC) CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB *CAT &DELTAC *CAT + &NCRPOSTC) JSNDMSG MSGID(JCL0314) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*COMP) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) ENDDO /* Prepara la chiamata di un query per esplorare il risultato. */ JRQT CMD(RUNQRY QRYFILE((&WRKLIB/JCLNPFFF)) + RCDSLT(*YES)) REFPGM(&REFPGM) /* Prepara la chiamata di un dfu per i flag di scelta. */ JRQT CMD(UPDDTA FILE(&WRKLIB/JCLNPFFF)) + REFPGM(&REFPGM) /* Prepara la chiamata dei comandi successivi della procedura. */ JRQT CMD(JCLNPF2 WRK(&WRK) SLTUSE(*PRV) + SLTCHG(*PRV)) REFPGM(&REFPGM) JRQT CMD(JCLNPF4 WRK(&WRK) RUN(*DIAG)) + REFPGM(&REFPGM) /* Messaggia "Eseguire JCLNPF2". */ CHGVAR VAR(&MSGDTA) VALUE(&WRK) JSNDMSG MSGID(JCL0313) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Chiama il controllo che le librerie duplicate, se esistenti, */ /* appartengano alla work library corrente. */ OVRDBF FILE(JCLNPFCA) TOFILE(&WRKLIB/JCLNPFCA) CALL PGM(JCLNPFCDL) PARM(&WRKLIB &REFPGM &ERR) DLTOVR FILE(*ALL) /* Se errore, rilascia. */ IF COND(&ERR) THEN(GOTO CMDLBL(CPF0001)) /* Label di esecuzione delle attivitā finali. */ RCLRSC: /* Dealloca ... */ /* Riacquisisce le risorse. */ RCLRSC MONMSG MSGID(CPF0000 MCH0000) /* Se richiesto, rilascia il CPF0001. */ IF COND(&CPF0001) THEN(DO) JSNDMSG MSGID(CPF0001) MSGF(QCPFMSG) MSGDTA(JCLNPF3) + MSGTYPE(*MSGQ) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) MONMSG MSGID(CPF0000 MCH0000) SNDPGMMSG MSGID(CPF0001) MSGF(QCPFMSG) MSGDTA(JCLNPF3) + MSGTYPE(*ESCAPE) MONMSG MSGID(CPF0000 MCH0000) ENDDO /* Ritorna. */ RETURN /* Label di errore. */ ERRORE: /* Restituisce i messaggi al chiamante, */ /* trasformando eventuali escape in diagnostici. */ JRSNMSG MONMSG MSGID(CPF0000 MCH0000) /* Label di prenotazione del CPF0001. */ CPF0001: /* Prenota il CPF0001. */ CHGVAR VAR(&CPF0001) VALUE('1') MONMSG MSGID(CPF0000 MCH0000) /* Salta alle attivitā finali. */ GOTO CMDLBL(RCLRSC) ENDPGM //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF3D) FILETYPE(*SRC) ENDCHAR('//ENDSRC') * Claudio Neroni 16-09-2015 Creato. * Cleanings. Physical. MngForcedFlags. Wri * Pulizie. Fisici. Gestisce flag di forzatura. Scrive * Riempie il file di forzatura dei flag * aggiungendo a ForcedFlags i record con chiavi * presenti in Candidates ma ancora assenti in ForcedFlags. * * Cleanings. Physical. Candidates Fjclnpfca ip e disk * Cleanings. Physical. ForcedFlags Fjclnpfff if a e k disk *--------------------------------------------------------------------------------------------- C TAG TAG *--------------------------------------------------------------------------------------------- * Elabora il record Candidates. C do * Se corre fotografia parametri, abbandona. C if CMLIB = 'Fotografia' or C CMFILE = 'Parametri ' C leave C endif * Definisce chiave per ForcedFlags. C KFF klist C kfld CMSYSN C kfld CMLIB C kfld CMFILE C kfld CMNAME * Cerca ForcedFlags. C KFF chain FFR * Se non trova ForcedFlags. C if not %found(jclnpfff) * Pulisce il tracciato di emissione. C clear ffr * Trascrive da record Candidates a record ForcedFlags. C eval FFSYSN = CMSYSN C eval FFLIB = CMLIB C eval FFFILE = CMFILE C eval FFNAME = CMNAME C write FFR * Se non trova ForcedFlags. C endif * Elabora il record Candidates. C enddo *--------------------------------------------------------------------------------------------- //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF3E) FILETYPE(*SRC) ENDCHAR('//ENDSRC') * Claudio Neroni 15-10-2015 Creato. * Cleanings. Physical. MngForcedFlags. Analysis * Pulizie. Fisici. Gestisce flag di forzatura. Analisi * Analizza il contenuto dei flag * del file flag di forzatura. * * Cleanings. Physical. ForcedFlags Fjclnpfff ip e disk *--------------------------------------------------------------------------------------------- * Definisce parametri. * Struttura dati di dieci contatori impaccati (10,0 Signed = 6 Char pack). D DS10PAK ds D cnt 1 60p 0 dim(10) *--------------------------------------------------------------------------------------------- C TAG TAG *--------------------------------------------------------------------------------------------- * Conta i record ForcedFlags. C eval cnt(01) += 1 * Conta gli stati del Forced selection flag. C if FFFRFG = *on C eval cnt(02) += 1 C eval cnt(05) += 1 C endif C if FFFRFG = *off C eval cnt(03) += 1 C eval cnt(05) += 1 C endif C if FFFRFG = *blank C eval cnt(04) += 1 C endif *--------------------------------------------------------------------------------------------- * Inizializza. C *inzsr begsr * Scambia parametri. C *entry plist C parm DS10PAK 60 O DS 10 packed 10,0 * Pulisce i contatori. C clear cnt C endsr *--------------------------------------------------------------------------------------------- //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF3F) FILETYPE(*SRC) ENDCHAR('//ENDSRC') * Cleanings. Physical. MngForcedFlags. ClrNull * Pulizie. Fisici. Gestisce flag di forzatura. Pulisce record nulli * Claudio Neroni 23-10-2015 Creato. * Cancella i record dei flag di forzatura senza forzature. * *--------------------------------------------------------------------------------------------- * Cleanings. Physical. ForcedFlags Fjclnpfff up e disk *--------------------------------------------------------------------------------------------- * Identifica i record nei file. IFFR 04 *--------------------------------------------------------------------------------------------- C TAG TAG *--------------------------------------------------------------------------------------------- * Se corre ForcedFlags. C if *in04 * Se il record non porta forzatura. C if FFFRFG = *blank * Cancella il record. C delete FFR * Se il record porta forzatura. C else * Rilascia il record. C unlock jclnpfff * End. C endif * Se corre ForcedFlags. C endif *--------------------------------------------------------------------------------------------- //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF3P) FILETYPE(*SRC) ENDCHAR('//ENDSRC') :PNLGRP. :IMPORT NAME='*' PNLGRP=JPNL. .*------------------------------------------------------------------------------ :HELP NAME=CMD. .*------------------ :H3.Procedura JCLNPF :H2.Cleanings Physical Files :P.La procedura e' composta dai comandi :HP2.JCLNPF1 JCLNPF2 JCLNPF3 JCLNPF4 JCLNPF5:EHP2. documentati nei rispettivi help mentre la documentazione della procedura risiede nell'help del comando fittizio :HP2.JCLNPF:EHP2. .*------------------ :H3.Comando JCLNPF3 :H2.Manage Forced Flags :P.Genera, integra e pulisce il contenuto del file Forced Flags. :P.Il comando :HP2.JCLNPF2:EHP2. determina autonomamente quali membri saranno sgombrati dal sistema dalla procedura corrente impostando un flag iniziale sul file candidati. :P.Per forzare la procedura di pulizia a fare diversamente da quanto deciso automaticamente occorre apporre un flag di forzatura nel file Forced Flags che viene preparato dal comando corrente. :P.I flag devono essere apposti non direttamente sul file Candidates ma sul citato Forced Flags. Qui si propagano al Candidates eseguendo un run supplementare del solito comando :HP2.JCLNPF2:EHP2.. .*------------------ :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/wrk'. :H3.Cleaning work library suffix (WRK) :P.La procedura utilizza un gruppo di file con prefisso "JCLN" che vengono creati, riempiti e gestiti in una "Work Library" il cui nome viene composto facendo uso dello stesso prefisso "JCLN" e del suffisso indicato in questo parametro. :P.Il suffisso e' il primo parametro in tutti i comandi della procedura ed identifica in modo elementare ed univoco l'operazione di pulizia intrapresa con il primo comando della serie (JCLNPF1). :P.Valori permessi: :PARML. :PT.Nome di 6 caratteri :PD.Il valore č obbligatorio. :EPARML. :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/mbropt'. :H3.Add/Replace/ClrNull flags rcds (MBROPT) :P.Opzione di Aggiunta/Sostituzione/PuliziaInutili dei record flag di forzatura. :P.Valori permessi: :PARML. :PT.:PK DEF.*ADD:EPK. :PD.Aggiunge i record eventualmente mancanti nel file Forced Flags destinati a memorizzare i flag di forzatura. :PT.*REPLACE :PD.Sostituisce tutti i record del file Forced Flags perdendo quindi l'eventuale precedente contenuto. Solo in questo caso si svuota il file delle forzature che invece sopravvive alla riesecuzione degli altri comandi della procedura. :PT.*CLRNUL :PD.Elimina dal file Forced Flags tutti i record che non portano un flag di forzatura. Tali record possono essere sgombrati se non si prevede di apporre altri flag. Gli stessi record, in caso di ripensamento, possono essere rigenerati per l'uso da un run *ADD. :EPARML. :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/refpgm'. :IMHELP NAME='refpgm'. :EHELP. .*------------------------------------------------------------------------------ :HELP NAME='CMD/COMMAND/EXAMPLES'. :XH3.Esempi d'uso del comando :P.:HP2.Esempio 1: Riempie il file dei flag di forzatura.:EHP2. :XMP. Con i soli parametri necessari: JCLNPF3 WRK(NERO) Anche con i parametri di default: JCLNPF3 WRK(NERO) MBROPT(*ADD) REFPGM(*CPP) :EXMP. :P.Questo comando esamina i dati gia' raccolti nella libreria di work JCLNNERO e trascrive i candidati nel file destinato a raccogliere e conservare i flag di forzatura. Il comando genera un log di cui si riporta esempio. :XMP. > JCLNPF3 WRK(NERO) ->Riempie il file dei flag di forzatura. WorkLib: JCLNNERO ->Presenti 0 forzature. Vedi secondo livello ->Aggiunti 703 record mancanti a flag di forzatura. WorkLib: JCLNNERO > /**/RUNQRY QRYFILE((JCLNNERO/JCLNPFFF)) RCDSLT(*YES) > /**/UPDDTA FILE(JCLNNERO/JCLNPFFF) > /**/JCLNPF2 WRK(NERO) SLTUSE(*PRV) SLTCHG(*PRV) > /**/JCLNPF4 WRK(NERO) RUN(*DIAG) ->Per riportare i flag da ForcedFlags a Candidates, vedi secondo livello :EXMP. :P.Si osservino i messaggi informativi e i comandi promemoria duplicabili per indagare o per eseguire i passi successivi della procedura. :EHELP. .*------------------------------------------------------------------------------ :HELP NAME='CMD/ERROR/MESSAGES'. .*------------------ :XH3.Messaggi informativi e di completamento :P.:HP3.Messaggi *INFO e *COMP:EHP3. :DL COMPACT. :DT.JCL0301 :DD.&MSG(JCL0301,JCLNPF,*LIBL,nosub). :DT.JCL0312 :DD.&MSG(JCL0312,JCLNPF,*LIBL,nosub). :DT.JCL0310 :DD.&MSG(JCL0310,JCLNPF,*LIBL,nosub). :DT.JCL0311 :DD.&MSG(JCL0311,JCLNPF,*LIBL,nosub). :DT.JCL0314 :DD.&MSG(JCL0314,JCLNPF,*LIBL,nosub). :DT.JCL0313 :DD.&MSG(JCL0313,JCLNPF,*LIBL,nosub). :EDL. .*------------------ :XH3.Messaggi di errore :P.:HP3.Messaggi *DIAG seguiti da *ESCAPE CPF0001:EHP3. :DL COMPACT. :DT.JCL0002 :DD.&MSG(JCL0002,JCLNPF,*LIBL,nosub). :EDL. .*------------------ :EHELP. .*------------------------------------------------------------------------------ :EPNLGRP. //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF4) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 17-09-2015 Creato. */ /* Cleanings. Physical. Dup. Cmd */ /* Pulizie. Fisici. Duplica. Comando */ /* */ CMD PROMPT('Duplicate Members') PARM KWD(WRK) TYPE(*NAME) LEN(6) MIN(1) + PROMPT('Cleaning work library suffix') PARM KWD(RUN) TYPE(*CHAR) LEN(10) RSTD(*YES) + DFT(*DIAG) VALUES(*DIAG *EXEC) + PROMPT('Diagnostic/executive run') PARM KWD(REFPGM) TYPE(*NAME) LEN(10) DFT(*CPP) + SPCVAL((*CPP)) PROMPT('Reference program + for messages') //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF4C) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 18-09-2015 Creato. */ /* Cleanings. Physical. Dup. Cpp */ /* Pulizie. Fisici. Duplica. Cpp */ /* Duplica i membri dalle librerie originali a quelle di destinazione. */ /* */ PGM PARM(&WRK &RUN &REFPGM) /* Riceve Cleaning work library suffix. */ DCL VAR(&WRK) TYPE(*CHAR) LEN(6) /* Riceve Run Type: diagnostic, executive or check. */ /* *DIAG = Diagnostica prima di eseguire. */ /* *EXEC = Esegue */ /* Il parametro viene passato anche al modulo sottostante JCLNPF4D ma, */ /* se richiesto *EXEC, il modulo JCLNPF4D viene chiamato due volte. */ /* La prima sostituendo *DIAGCRT a *EXEC. La seconda passando *EXEC. */ /* *DIAGCRT = Diagnostica e crea librerie riceventi. */ DCL VAR(&RUN) TYPE(*CHAR) LEN(10) /* Riceve Programma di riferimento per i messaggi. */ DCL VAR(&REFPGM) TYPE(*CHAR) LEN(10) /* Cleaning work library. */ DCL VAR(&WRKLIB) TYPE(*CHAR) LEN(10) /* Messaggio. */ DCL VAR(&MSGID) TYPE(*CHAR) LEN(7) DCL VAR(&MSGDTA) TYPE(*CHAR) LEN(512) /* Flag di errore. */ DCL VAR(&ERR) TYPE(*LGL) /* Conta delle librerie esaminate. */ DCL VAR(&LIBEXA) TYPE(*DEC) LEN(9 0) /* Conta delle librerie create. */ DCL VAR(&LIBCRT) TYPE(*DEC) LEN(9 0) /* Member Option di JLOG "Archives Log". */ DCL VAR(&JLOGMBROPT) TYPE(*CHAR) LEN(10) + VALUE(*ADD) /* File messaggi. */ DCL VAR(&MSGF) TYPE(*CHAR) LEN(10) VALUE(JCLNPF) /* To message queue. */ DCL VAR(&TOMSGQ) TYPE(*CHAR) LEN(10) VALUE(JCLNPF) DCL VAR(&TOMSGQTXT) TYPE(*CHAR) LEN(50) + VALUE('Cleanings Physical Files') /* Prenotazione del CPF0001. */ DCL VAR(&CPF0001) TYPE(*LGL) /* Intercetta gli errori imprevisti. */ MONMSG MSGID(CPF0000 MCH0000 CEE0000) EXEC(GOTO + CMDLBL(ERRORE)) /* Se richiesto *CPP (Command Processing Program) come programma */ /* di riferimento dei messaggi, assume il nome del programma corrente. */ IF COND(&REFPGM *EQ *CPP) THEN(DO) JCALLER CALLER(&REFPGM) KINSHIP(*FATHER) ENDDO /* Segnala inizio log. */ SNDPGMMSG MSG(DUPBEG) TOPGMQ(*SAME) /* Compone il nome della Cleaning work library. */ CHGVAR VAR(&WRKLIB) VALUE(JCLN *CAT &WRK) /* Controlla l'esistenza della work library. */ CHKOBJ OBJ(&WRKLIB) OBJTYPE(*LIB) /* Se la work library non esiste, messaggia "Manca libreria" e abbandona. */ MONMSG MSGID(CPF0000) EXEC(DO) CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB *CAT &WRK) SNDPGMMSG MSGID(JCL0002) MSGF(&MSGF) MSGDTA(&MSGDTA) + TOPGMQ(*PRV (&REFPGM)) MSGTYPE(*DIAG) GOTO CMDLBL(CPF0001) ENDDO /* Avvia coda messaggi. */ JSNDMSG MSGDTA(JCLNPF4) MSGTYPE(*INFO) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) + TOMSGQTXT(&TOMSGQTXT) SEQ(*FIRST) /* Messaggia "Run Type" */ CHGVAR VAR(&MSGDTA) VALUE(&RUN) JSNDMSG MSGID(JCL0401) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Messaggia "Elabora" */ CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB) JSNDMSG MSGID(JCL0402) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Se run diagnostico. */ IF COND(&RUN *EQ *DIAG) THEN(DO) /* Chiama controllo librerie e membri datori e riceventi. */ CALL PGM(JCLNPF4D) PARM(&WRKLIB &RUN &MSGID + &MSGDTA &ERR &LIBEXA &LIBCRT &REFPGM) /* Se errore, messaggia e abbandona. */ IF COND(&ERR) THEN(DO) JSNDMSG MSGID(&MSGID) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*DIAG) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) GOTO CMDLBL(CPF0001) ENDDO /* Se richiesto messaggio informativo, messaggia. */ IF COND(&MSGID *NE ' ') THEN(DO) JSNDMSG MSGID(&MSGID) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) ENDDO /* Se run diagnostico. */ ENDDO /* Se run esecutivo. */ IF COND(&RUN *EQ *EXEC) THEN(DO) /* Chiama il controllo che le librerie duplicate, se esistenti, */ /* appartengano alla work library corrente. */ OVRDBF FILE(JCLNPFCA) TOFILE(&WRKLIB/JCLNPFCA) CALL PGM(JCLNPFCDL) PARM(&WRKLIB &REFPGM &ERR) DLTOVR FILE(*ALL) /* Se errore, rilascia. */ IF COND(&ERR) THEN(GOTO CMDLBL(CPF0001)) /* Chiama creazione librerie destinatarie. */ CALL PGM(JCLNPF4D) PARM(&WRKLIB *DIAGCRT &MSGID + &MSGDTA &ERR &LIBEXA &LIBCRT &REFPGM) /* Se errore, messaggia e abbandona. */ IF COND(&ERR) THEN(DO) JSNDMSG MSGID(&MSGID) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*DIAG) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) GOTO CMDLBL(CPF0001) ENDDO /* Se tutte le librerie destinatarie non preesistevano, */ /* prenota la sostituzione della fotografia del log. */ IF COND(&LIBEXA *EQ &LIBCRT) THEN(DO) CHGVAR VAR(&JLOGMBROPT) VALUE(*REPLACE) ENDDO /* Se richiesto messaggio informativo, messaggia. */ IF COND(&MSGID *NE ' ') THEN(DO) JSNDMSG MSGID(&MSGID) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) ENDDO /* Chiama esecuzione spostamenti. */ CALL PGM(JCLNPF4D) PARM(&WRKLIB &RUN &MSGID + &MSGDTA &ERR &LIBEXA &LIBCRT &REFPGM) /* Se errore, messaggia e abbandona. */ IF COND(&ERR) THEN(DO) JSNDMSG MSGID(&MSGID) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*DIAG) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) GOTO CMDLBL(CPF0001) ENDDO /* Se richiesto messaggio informativo, messaggia. */ IF COND(&MSGID *NE ' ') THEN(DO) JSNDMSG MSGID(&MSGID) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) ENDDO /* Se run esecutivo. */ ENDDO /* Messaggia "Spostamenti possibili/eseguiti". */ SELECT WHEN COND(&RUN *EQ *DIAG) THEN(CHGVAR VAR(&MSGID) + VALUE(JCL0421)) WHEN COND(&RUN *EQ *EXEC) THEN(CHGVAR VAR(&MSGID) + VALUE(JCL0422)) OTHERWISE CMD(CHGVAR VAR(&MSGID) VALUE(JCL0424)) ENDSELECT CHGVAR VAR(&MSGDTA) VALUE(&RUN *CAT &WRKLIB) JSNDMSG MSGID(&MSGID) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Se run diagnostico. */ IF COND(&RUN *EQ *DIAG) THEN(DO) /* Chiama il controllo che le librerie duplicate, se esistenti, */ /* appartengano alla work library corrente. */ OVRDBF FILE(JCLNPFCA) TOFILE(&WRKLIB/JCLNPFCA) CALL PGM(JCLNPFCDL) PARM(&WRKLIB &REFPGM &ERR) DLTOVR FILE(*ALL) /* Se errore, rilascia. */ IF COND(&ERR) THEN(GOTO CMDLBL(CPF0001)) /* Se run diagnostico. */ ENDDO /* Label di esecuzione delle attivitā finali. */ RCLRSC: /* Dealloca ... */ /* Se run esecutivo, scarica joblog su file fisico. */ IF COND(&RUN *EQ *EXEC) THEN(DO) JLOG FROMTAG(DUPBEG) OUTFILE(&WRKLIB/JLOGJCLNPF) + MBROPT(&JLOGMBROPT) TOPGMQ(*PRVPRV) MONMSG MSGID(CPF0000 MCH0000) ENDDO /* Riacquisisce le risorse. */ RCLRSC MONMSG MSGID(CPF0000 MCH0000) /* Se richiesto, rilascia il CPF0001. */ IF COND(&CPF0001) THEN(DO) JSNDMSG MSGID(CPF0001) MSGF(QCPFMSG) MSGDTA(JCLNPF4) + MSGTYPE(*MSGQ) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) MONMSG MSGID(CPF0000 MCH0000) SNDPGMMSG MSGID(CPF0001) MSGF(QCPFMSG) MSGDTA(JCLNPF4) + MSGTYPE(*ESCAPE) MONMSG MSGID(CPF0000 MCH0000) ENDDO /* Ritorna. */ RETURN /* Label di errore. */ ERRORE: /* Restituisce i messaggi al chiamante, */ /* trasformando eventuali escape in diagnostici. */ JRSNMSG MONMSG MSGID(CPF0000 MCH0000) /* Label di prenotazione del CPF0001. */ CPF0001: /* Prenota il CPF0001. */ CHGVAR VAR(&CPF0001) VALUE('1') MONMSG MSGID(CPF0000 MCH0000) /* Salta alle attivitā finali. */ GOTO CMDLBL(RCLRSC) ENDPGM //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF4D) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 17-09-2015 Creato. */ /* Cleanings. Physical. Dup. Chk&Dup */ /* Pulizie. Fisici. Duplica. Controlla e duplica. */ /* Controlla l'esistenza delle librerie riceventi */ /* menzionate nell'elenco dei membri da spostare. */ /* Controlla l'esistenza e le caratteristiche dei membri */ /* menzionati nell'elenco dei membri da spostare. */ /* Duplica le librerie. */ /* Duplica i membri. */ /* */ PGM PARM(&WRKLIB &RUN &RTNID &RTNDTA &RTNERR + &RTNLIBEXA &RTNLIBCRT &REFPGM) /* Riceve Work library. */ DCL VAR(&WRKLIB) TYPE(*CHAR) LEN(10) /* Riceve Tipo run diagnostico/esecutivo/controllo. */ /* *DIAG = Diagnostica prima di eseguire. */ /* *EXEC = Esegue */ /* *DIAGCRT = Diagnostica e crea librerie riceventi. */ DCL VAR(&RUN) TYPE(*CHAR) LEN(10) /* Ritorna Messaggio. */ DCL VAR(&RTNID) TYPE(*CHAR) LEN(7) DCL VAR(&RTNDTA) TYPE(*CHAR) LEN(256) /* Ritorna Flag di errore. */ DCL VAR(&RTNERR) TYPE(*LGL) /* Ritorna Conta delle librerie esaminate. */ DCL VAR(&RTNLIBEXA) TYPE(*DEC) LEN(9 0) /* Ritorna Conta delle librerie create. */ DCL VAR(&RTNLIBCRT) TYPE(*DEC) LEN(9 0) /* Riceve Programma di riferimento per i messaggi. */ DCL VAR(&REFPGM) TYPE(*CHAR) LEN(10) /* Libreria datrice precedente. */ DCL VAR(&PRELIB) TYPE(*CHAR) LEN(10) /* Libreria ricevente precedente. */ DCL VAR(&PRELIB§) TYPE(*CHAR) LEN(10) /* Libreria ricevente. */ DCL VAR(&CMLIB§) TYPE(*CHAR) LEN(10) /* Flag di esistenza della Libreria datrice. */ DCL VAR(&ESIDTR) TYPE(*LGL) DCL VAR(&ESIDTRC) TYPE(*CHAR) LEN(1) /* Flag di esistenza della Libreria ricevente. */ DCL VAR(&ESIRIC) TYPE(*LGL) DCL VAR(&ESIRICC) TYPE(*CHAR) LEN(1) /* Flag di segnalazione membro datore. */ DCL VAR(&SIGDTR) TYPE(*LGL) /* Flag di segnalazione membro ricevente. */ DCL VAR(&SIGRIC) TYPE(*LGL) /* Dati messaggio. */ DCL VAR(&MSGDTA) TYPE(*CHAR) LEN(512) /* Mezzi messaggi librerie. */ DCL VAR(&MMLDTR) TYPE(*CHAR) LEN(34) DCL VAR(&MMLRIC) TYPE(*CHAR) LEN(34) /* Conta dei record. */ DCL VAR(&TOTCNTRCD) TYPE(*DEC) LEN(9 0) DCL VAR(&TOTCNTRCDC) TYPE(*CHAR) LEN(5) DCL VAR(&LIBCNTRCD) TYPE(*DEC) LEN(9 0) DCL VAR(&LIBCNTRCDC) TYPE(*CHAR) LEN(5) /* Conta dei membri da muovere. */ DCL VAR(&TOTCNTTOM) TYPE(*DEC) LEN(9 0) DCL VAR(&TOTCNTTOMC) TYPE(*CHAR) LEN(5) DCL VAR(&LIBCNTTOM) TYPE(*DEC) LEN(9 0) DCL VAR(&LIBCNTTOMC) TYPE(*CHAR) LEN(5) /* Conta dei membri da muovere ma spariti. */ DCL VAR(&TOTCNTDSR) TYPE(*DEC) LEN(9 0) DCL VAR(&TOTCNTDSRC) TYPE(*CHAR) LEN(5) DCL VAR(&LIBCNTDSR) TYPE(*DEC) LEN(9 0) DCL VAR(&LIBCNTDSRC) TYPE(*CHAR) LEN(5) /* Conta dei membri da muovere ma cambiati. */ DCL VAR(&TOTCNTCHG) TYPE(*DEC) LEN(9 0) DCL VAR(&TOTCNTCHGC) TYPE(*CHAR) LEN(5) DCL VAR(&LIBCNTCHG) TYPE(*DEC) LEN(9 0) DCL VAR(&LIBCNTCHGC) TYPE(*CHAR) LEN(5) /* Conta dei membri da muovere ma con duplicazione in errore. */ DCL VAR(&TOTCNTERR) TYPE(*DEC) LEN(9 0) DCL VAR(&TOTCNTERRC) TYPE(*CHAR) LEN(5) DCL VAR(&LIBCNTERR) TYPE(*DEC) LEN(9 0) DCL VAR(&LIBCNTERRC) TYPE(*CHAR) LEN(5) /* Conta dei membri da muovere ma gia' duplicati. */ DCL VAR(&TOTCNTALR) TYPE(*DEC) LEN(9 0) DCL VAR(&TOTCNTALRC) TYPE(*CHAR) LEN(5) DCL VAR(&LIBCNTALR) TYPE(*DEC) LEN(9 0) DCL VAR(&LIBCNTALRC) TYPE(*CHAR) LEN(5) /* Conta dei membri mossi nel run corrente. */ DCL VAR(&TOTCNTDUP) TYPE(*DEC) LEN(9 0) DCL VAR(&TOTCNTDUPC) TYPE(*CHAR) LEN(5) DCL VAR(&LIBCNTDUP) TYPE(*DEC) LEN(9 0) DCL VAR(&LIBCNTDUPC) TYPE(*CHAR) LEN(5) /* Somma dello spazio occupato. */ DCL VAR(&TOTSIZALL) TYPE(*DEC) LEN(15 0) DCL VAR(&TOTSIZALLC) TYPE(*CHAR) LEN(8) DCL VAR(&LIBSIZALL) TYPE(*DEC) LEN(15 0) DCL VAR(&LIBSIZALLC) TYPE(*CHAR) LEN(8) /* Somma dello spazio occupato liberabile. */ DCL VAR(&TOTSIZFRE) TYPE(*DEC) LEN(15 0) DCL VAR(&TOTSIZFREC) TYPE(*CHAR) LEN(8) DCL VAR(&LIBSIZFRE) TYPE(*DEC) LEN(15 0) DCL VAR(&LIBSIZFREC) TYPE(*CHAR) LEN(8) /* Campi di Retrieve Member Description. */ DCL VAR(&NBRCURRCD) TYPE(*DEC) LEN(10 0) DCL VAR(&CHGDATE) TYPE(*CHAR) LEN(13) DCL VAR(&CHGDATED) TYPE(*CHAR) LEN(10) DCL VAR(&CHGDATET) TYPE(*CHAR) LEN(8) DCL VAR(&USEDATE) TYPE(*CHAR) LEN(7) DCL VAR(&USEDATED) TYPE(*CHAR) LEN(10) DCL VAR(&USECOUNT) TYPE(*DEC) LEN(5 0) /* Caratteristiche libreria datrice. */ DCL VAR(&LIBTYPE) TYPE(*CHAR) LEN(10) DCL VAR(&LIBTEXT) TYPE(*CHAR) LEN(50) /* Indirizzario equivalente alla libreria di destinazione. */ DCL VAR(&CMLIB§DIR) TYPE(*CHAR) LEN(100) /* Messaggio ed errore di risposta della duplicazione membro. */ DCL VAR(&DUPMSGID) TYPE(*CHAR) LEN(7) DCL VAR(&DUPMSGDTA) TYPE(*CHAR) LEN(256) /* Errore in duplicazione. */ DCL VAR(&DUPERR) TYPE(*LGL) /* Preesiste duplicato. */ DCL VAR(&DUPEXIST) TYPE(*LGL) /* Eseguito duplicato. */ DCL VAR(&DUPDUP) TYPE(*LGL) /* File messaggi. */ DCL VAR(&MSGF) TYPE(*CHAR) LEN(10) VALUE(JCLNPF) /* To message queue. */ DCL VAR(&TOMSGQ) TYPE(*CHAR) LEN(10) VALUE(JCLNPF) DCL VAR(&TOMSGQTXT) TYPE(*CHAR) LEN(50) + VALUE('Cleanings Physical Files') /* Elenco dei membri da muovere. */ DCLF FILE(JCLNPFCA) /* Intercetta gli errori imprevisti. */ MONMSG MSGID(CPF0000 MCH0000 CEE0000) EXEC(GOTO + CMDLBL(ERRORE)) /* Pulisce i parametri di ritorno. */ CHGVAR VAR(&RTNID) VALUE(' ') CHGVAR VAR(&RTNDTA) VALUE(' ') CHGVAR VAR(&RTNERR) VALUE('0') CHGVAR VAR(&RTNLIBEXA) VALUE(0) CHGVAR VAR(&RTNLIBCRT) VALUE(0) /* Controlla l'esistenza della work library. */ CHKOBJ OBJ(&WRKLIB) OBJTYPE(*LIB) /* Se la work library non esiste, restituisce errore al chiamante. */ MONMSG MSGID(CPF0000) EXEC(DO) CHGVAR VAR(&RTNID) VALUE(JCL0002) CHGVAR VAR(&RTNDTA) VALUE(&WRKLIB) GOTO CMDLBL(ERRORE) ENDDO /* Messaggia "Lettura elenco membri in corso". */ CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB) JSNDMSG MSGID(JCL0403) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Reindirizza il file da leggere. */ OVRDBF FILE(JCLNPFCA) TOFILE(&WRKLIB/JCLNPFCA) /*----------------------------------------------------------------------------*/ /* Cicla lettura record. */ DOWHILE COND(1 = 1) /* Legge un record membro candidato a pulizia. */ RCVF /* Se non ce ne sono altri, abbandona. */ MONMSG MSGID(CPF0864) EXEC(LEAVE) /* Conta record. */ CHGVAR VAR(&TOTCNTRCD) VALUE(&TOTCNTRCD + 1) CHGVAR VAR(&LIBCNTRCD) VALUE(&LIBCNTRCD + 1) /* Somma spazio occupato. */ CHGVAR VAR(&TOTSIZALL) VALUE(&TOTSIZALL + &CMTSIZ) CHGVAR VAR(&LIBSIZALL) VALUE(&LIBSIZALL + &CMTSIZ) /* Se il candidato e' da conservare, ricicla. */ IF COND(&CMFIFG *NE '1') THEN(ITERATE) /* Se la libreria e' diversa dalla precedente. */ IF COND(&CMLIB *NE &PRELIB) THEN(DO) /* Emette il messaggio totali libreria precedente e li azzera. */ CALLSUBR SUBR(MSGPRELIB) /* Assume esistenti librerie datrice e ricevente. */ CHGVAR VAR(&ESIDTR) VALUE('1') CHGVAR VAR(&ESIRIC) VALUE('1') /* Accantona la libreria precedente. */ CHGVAR VAR(&PRELIB) VALUE(&CMLIB) /* Se il decimo carattere del nome libreria datrice non e' blank, */ /* messaggia "Nome troppo lungo" ma continua. */ IF COND(%SST(&CMLIB 10 1) *NE ' ') THEN(DO) CHGVAR VAR(&MSGDTA) VALUE(&CMLIB) JSNDMSG MSGID(JCL0006) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*DIAG) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) ENDDO /* Controlla l'esistenza della libreria datrice. */ CHKOBJ OBJ(&CMLIB) OBJTYPE(*LIB) /* Se la libreria datrice non esiste, annota. */ MONMSG MSGID(CPF0000) EXEC(CHGVAR VAR(&ESIDTR) + VALUE('0')) /* Compone il nome della libreria ricevente. */ CHGVAR VAR(&CMLIB§) VALUE(%SST(&CMLIB 1 9) *TCAT §) /* Compone il nome della libreria ricevente come indirizzario IFS. */ CHGVAR VAR(&CMLIB§DIR) VALUE('/qsys.lib/' *TCAT + (%SST(&CMLIB 1 9) *TCAT '@') *TCAT '.lib') /* Se datrice e ricevente coincidono, restituisce errore al chiamante. */ IF COND(&CMLIB *EQ &CMLIB§) THEN(DO) CHGVAR VAR(&RTNID) VALUE(JCL0406) CHGVAR VAR(&RTNDTA) VALUE(&CMLIB *CAT &CMLIB§) GOTO CMDLBL(ERRORE) ENDDO /* Controlla l'esistenza della libreria ricevente. */ CHKOBJ OBJ(&CMLIB§) OBJTYPE(*LIB) /* Se la libreria ricevente non esiste, annota. */ MONMSG MSGID(CPF0000) EXEC(CHGVAR VAR(&ESIRIC) + VALUE('0')) /* Compone il mezzo messaggio "datrice esiste/NON esiste". */ IF COND(&ESIDTR) THEN(CHGVAR VAR(&MMLDTR) + VALUE('->Datrice' *BCAT &CMLIB *CAT ' + esiste.')) ELSE CMD(CHGVAR VAR(&MMLDTR) VALUE('->Datrice' + *BCAT &CMLIB *CAT ' NON esiste.')) CHGVAR VAR(%SST(&MMLDTR 34 1)) VALUE('-') /* Compone il mezzo messaggio "ricevente esiste/NON esiste". */ IF COND(&ESIRIC) THEN(CHGVAR VAR(&MMLRIC) + VALUE('Ricevente' *BCAT &CMLIB§ *CAT ' + esiste.')) ELSE CMD(CHGVAR VAR(&MMLRIC) VALUE('Ricevente' + *BCAT &CMLIB§ *CAT ' NON esiste.')) /* Converte due variabili logiche in due variabili carattere. */ IF COND(&ESIDTR) THEN(CHGVAR VAR(&ESIDTRC) + VALUE('1')) ELSE CMD(CHGVAR VAR(&ESIDTRC) VALUE('0')) IF COND(&ESIRIC) THEN(CHGVAR VAR(&ESIRICC) + VALUE('1')) ELSE CMD(CHGVAR VAR(&ESIRICC) VALUE('0')) /* Messaggia "Datrice Esiste/NonEsiste. Ricevente Esiste/NonEsiste. */ CHGVAR VAR(&MSGDTA) VALUE(&MMLDTR *CAT &MMLRIC *CAT + &CMLIB *CAT &ESIDTRC *CAT &CMLIB§ *CAT + &ESIRICC) JSNDMSG MSGID(JCL0405) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Se corre run diagnostico con creazione librerie riceventi */ /* e non esiste la libreria ricevente. */ IF COND((&RUN *EQ *DIAGCRT) *AND (*NOT + &ESIRIC)) THEN(DO) /* Crea la libreria ricevente con le caratteristiche della datrice. */ /* Aggira l'autorita' mancante su CRTLIB usando MKDIR. */ RTVLIBD LIB(&CMLIB) TYPE(&LIBTYPE) TEXT(&LIBTEXT) CHGVAR VAR(&LIBTYPE) VALUE('*' *CAT &LIBTYPE) MKDIR DIR(&CMLIB§DIR) /*CN01-***** CHGLIB LIB(&CMLIB§) TYPE(&LIBTYPE) TEXT(&LIBTEXT) /**/ CHGLIB LIB(&CMLIB§) TYPE(&LIBTYPE) TEXT(&WRKLIB ) /* Conta le librerie create. */ CHGVAR VAR(&RTNLIBCRT) VALUE(&RTNLIBCRT + 1) /* Messaggia "Creata libreria ricevente". */ CHGVAR VAR(&MSGDTA) VALUE(&CMLIB§) JSNDMSG MSGID(JCL0407) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Se corre run diagnostico con creazione librerie riceventi. */ /* e non esiste la libreria ricevente. */ ENDDO /* Se la libreria e' diversa dalla precedente. */ ENDDO /* Conta record dei membri da muovere. */ CHGVAR VAR(&TOTCNTTOM) VALUE(&TOTCNTTOM + 1) CHGVAR VAR(&LIBCNTTOM) VALUE(&LIBCNTTOM + 1) /* Se corre run diagnostico con creazione librerie riceventi, ricicla. */ IF COND(&RUN *EQ *DIAGCRT) THEN(ITERATE) /*----------------------------------------------------------------------------*/ /* CONTROLLA MEMBRI. BEG */ /* Assume non segnalare membro datore ne' ricevente. */ CHGVAR VAR(&SIGDTR) VALUE('0') CHGVAR VAR(&SIGRIC) VALUE('0') /* Esegue elaborazione record. */ DOUNTIL COND(1 = 1) /* Se esiste libreria datrice. */ IF COND(&ESIDTR) THEN(DO) /*----------------------------------------------------------------------------*/ /* Se nome membro valorizzato. */ IF COND(&CMNAME *NE ' ') THEN(DO) /* Somma spazio occupato liberabile. */ CHGVAR VAR(&TOTSIZFRE) VALUE(&TOTSIZFRE + &CMTSIZ) CHGVAR VAR(&LIBSIZFRE) VALUE(&LIBSIZFRE + &CMTSIZ) /* Controlla esistenza e caratteristiche membro datore. */ RTVMBRD FILE(&CMLIB/&CMFILE) MBR(&CMNAME) + NBRCURRCD(&NBRCURRCD) CHGDATE(&CHGDATE) + USEDATE(&USEDATE) USECOUNT(&USECOUNT) /* Se manca membro, annota segnalare, segnala conta e abbandona. */ MONMSG MSGID(CPF9815) EXEC(DO) CHGVAR VAR(&SIGDTR) VALUE('1') CHGVAR VAR(&MSGDTA) VALUE('->r' *BCAT &CMLIB *CAT + '/' *CAT &CMFILE *CAT '-' *CAT &CMNAME + *CAT ' membro non esiste piu''') JSNDMSG MSGDTA(&MSGDTA) MSGTYPE(*INFO) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) CHGVAR VAR(&TOTCNTDSR) VALUE(&TOTCNTDSR + 1) CHGVAR VAR(&LIBCNTDSR) VALUE(&LIBCNTDSR + 1) LEAVE ENDDO /* Se manca file, annota segnalare, segnala, conta e abbandona. */ MONMSG MSGID(CPF0000) EXEC(DO) CHGVAR VAR(&SIGDTR) VALUE('1') CHGVAR VAR(&MSGDTA) VALUE('->r' *BCAT &CMLIB *CAT + '/' *CAT &CMFILE *CAT '-' *CAT &CMNAME + *CAT ' file del membro non esiste piu''') JSNDMSG MSGDTA(&MSGDTA) MSGTYPE(*INFO) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) CHGVAR VAR(&TOTCNTDSR) VALUE(&TOTCNTDSR + 1) CHGVAR VAR(&LIBCNTDSR) VALUE(&LIBCNTDSR + 1) LEAVE ENDDO /* Converte i dati recuperati per renderli confrontabili. */ IF COND(&CHGDATE *EQ ' ') THEN(DO) CHGVAR VAR(&CHGDATED) VALUE('0001-01-01') CHGVAR VAR(&CHGDATET) VALUE('00.00.00') ENDDO ELSE CMD(DO) CVTDAT DATE(%SST(&CHGDATE 1 7)) TOVAR(&CHGDATED) + FROMFMT(*CYMD) TOFMT(*ISO) TOSEP(-) CHGVAR VAR(&CHGDATET) VALUE(%SST(&CHGDATE 8 2) *CAT + '.' *CAT %SST(&CHGDATE 10 2) *CAT '.' + *CAT %SST(&CHGDATE 12 2)) ENDDO IF COND(&USEDATE *EQ ' ') THEN(DO) CHGVAR VAR(&USEDATED) VALUE('0001-01-01') ENDDO ELSE CMD(DO) CVTDAT DATE(&USEDATE) TOVAR(&USEDATED) + FROMFMT(*CYMD) TOFMT(*ISO) TOSEP(-) ENDDO /* Se una data ora recuperata non corrisponde a record, */ /* annota segnalare membro datore. */ IF COND((&CHGDATED *NE &CMGDAT) *OR (&CHGDATET + *NE &CMGTIM) *OR (&USEDATED *NE &CMUDAT)) + THEN(CHGVAR VAR(&SIGDTR) VALUE('1')) /* Se richiesto segnalare membro datore, segnala e conta. */ IF COND(&SIGDTR) THEN(DO) CHGVAR VAR(&MSGDTA) VALUE('->r' *BCAT &CMLIB *CAT + '/' *CAT &CMFILE *CAT '-' *CAT &CMNAME + *CAT ' "' *CAT &CMGDAT *CAT '" "' *CAT + &CMGTIM *CAT '" "' *CAT &CMUDAT *CAT '"') JSNDMSG MSGDTA(&MSGDTA) MSGTYPE(*INFO) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) CHGVAR VAR(&TOTCNTCHG) VALUE(&TOTCNTCHG + 1) CHGVAR VAR(&LIBCNTCHG) VALUE(&LIBCNTCHG + 1) ENDDO /* Se richiesto segnalare membro datore, segnala. */ IF COND(&SIGDTR) THEN(DO) CHGVAR VAR(&MSGDTA) VALUE('->m' *BCAT &CMLIB *CAT + '/' *CAT &CMFILE *CAT '-' *CAT &CMNAME + *CAT ' "' *CAT &CHGDATED *CAT '" "' *CAT + &CHGDATET *CAT '" "' *CAT &USEDATED *CAT '"') JSNDMSG MSGDTA(&MSGDTA) MSGTYPE(*INFO) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) ENDDO /* Se corre esecuzione. */ IF COND(&RUN *EQ *EXEC) THEN(DO) /* Duplica il membro nella libreria ricevente. */ JCLNPF8 FROMLIB(&CMLIB) FILE(&CMFILE) + MEMBER(&CMNAME) TOLIB(&CMLIB§) + RTNMSGID(&DUPMSGID) RTNMSGDTA(&DUPMSGDTA) + RTNERR(&DUPERR) RTNEXIST(&DUPEXIST) + RTNDUP(&DUPDUP) /* Se duplicazione in errore, conta errore. */ IF COND(&DUPERR) THEN(DO) CHGVAR VAR(&TOTCNTERR) VALUE(&TOTCNTERR + 1) CHGVAR VAR(&LIBCNTERR) VALUE(&LIBCNTERR + 1) ENDDO /* Se esiste gia' ricevente, conta gia' esistente. */ IF COND(&DUPEXIST) THEN(DO) CHGVAR VAR(&TOTCNTALR) VALUE(&TOTCNTALR + 1) CHGVAR VAR(&LIBCNTALR) VALUE(&LIBCNTALR + 1) ENDDO /* Se eseguito duplicato, conta duplicazione. */ IF COND(&DUPDUP) THEN(DO) CHGVAR VAR(&TOTCNTDUP) VALUE(&TOTCNTDUP + 1) CHGVAR VAR(&LIBCNTDUP) VALUE(&LIBCNTDUP + 1) ENDDO /* Messaggia quanto segnalato dalla duplicazione membro. */ IF COND(&DUPMSGID *NE ' ') THEN(DO) JSNDMSG MSGID(&DUPMSGID) MSGF(&MSGF) + MSGDTA(&DUPMSGDTA) MSGTYPE(*INFO) + STATUS(*YES) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) ENDDO /* Se corre esecuzione. */ ENDDO /* Se non corre esecuzione. */ IF COND(&RUN *NE *EXEC) THEN(DO) /* Controlla l'esistenza del membro ricevente. */ CHKOBJ OBJ(&CMLIB§/&CMFILE) OBJTYPE(*FILE) + MBR(&CMNAME) /* Se non esiste il ricevente, passa oltre. */ MONMSG MSGID(CPF0000) EXEC(DO) RCVMSG MSGTYPE(*EXCP) WAIT(1) RMV(*YES) GOTO CMDLBL(ENDMBR) ENDDO /* Conta membro gia' esistente. */ CHGVAR VAR(&TOTCNTALR) VALUE(&TOTCNTALR + 1) CHGVAR VAR(&LIBCNTALR) VALUE(&LIBCNTALR + 1) ENDMBR: /* Se non corre esecuzione. */ ENDDO /* Se nome membro valorizzato. */ ENDDO /*----------------------------------------------------------------------------*/ /* Se nome membro e' vuoto. */ IF COND(&CMNAME *EQ ' ') THEN(DO) /* Controlla esistenza e caratteristiche file datore. */ RTVOBJD OBJ(&CMLIB/&CMFILE) OBJTYPE(*FILE) + CHGDATE(&CHGDATE) USEDATE(&USEDATE) + USECOUNT(&USECOUNT) /* Se manca file, annota segnalare, segnala, conta e abbandona. */ MONMSG MSGID(CPF0000) EXEC(DO) CHGVAR VAR(&SIGDTR) VALUE('1') CHGVAR VAR(&MSGDTA) VALUE('->r' *BCAT &CMLIB *CAT + '/' *CAT &CMFILE *CAT '-' *CAT &CMNAME + *CAT ' file non esiste piu''') JSNDMSG MSGDTA(&MSGDTA) MSGTYPE(*INFO) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) CHGVAR VAR(&TOTCNTDSR) VALUE(&TOTCNTDSR + 1) CHGVAR VAR(&LIBCNTDSR) VALUE(&LIBCNTDSR + 1) LEAVE ENDDO /* Converte i dati recuperati per renderli confrontabili. */ IF COND(&CHGDATE *EQ ' ') THEN(DO) CHGVAR VAR(&CHGDATED) VALUE('0001-01-01') CHGVAR VAR(&CHGDATET) VALUE('00.00.00') ENDDO ELSE CMD(DO) CVTDAT DATE(%SST(&CHGDATE 1 7)) TOVAR(&CHGDATED) + FROMFMT(*CYMD) TOFMT(*ISO) TOSEP(-) CHGVAR VAR(&CHGDATET) VALUE(%SST(&CHGDATE 8 2) *CAT + '.' *CAT %SST(&CHGDATE 10 2) *CAT '.' + *CAT %SST(&CHGDATE 12 2)) ENDDO IF COND(&USEDATE *EQ ' ') THEN(DO) CHGVAR VAR(&USEDATED) VALUE('0001-01-01') ENDDO ELSE CMD(DO) CVTDAT DATE(&USEDATE) TOVAR(&USEDATED) + FROMFMT(*CYMD) TOFMT(*ISO) TOSEP(-) ENDDO /* Se una data ora recuperata non corrisponde a record, */ /* annota segnalare file datore. */ IF COND((&CHGDATED *NE &CMFDAT) *OR (&CHGDATET + *NE &CMFTIM) *OR (&USEDATED *NE &CMXDAT)) + THEN(CHGVAR VAR(&SIGDTR) VALUE('1')) /* Se richiesto segnalare file datore, segnala e conta. */ IF COND(&SIGDTR) THEN(DO) CHGVAR VAR(&MSGDTA) VALUE('->r' *BCAT &CMLIB *CAT + '/' *CAT &CMFILE *CAT '-' *CAT &CMNAME + *CAT ' "' *CAT &CMGDAT *CAT '" "' *CAT + &CMGTIM *CAT '" "' *CAT &CMUDAT *CAT '"') JSNDMSG MSGDTA(&MSGDTA) MSGTYPE(*INFO) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) CHGVAR VAR(&TOTCNTCHG) VALUE(&TOTCNTCHG + 1) CHGVAR VAR(&LIBCNTCHG) VALUE(&LIBCNTCHG + 1) ENDDO /* Se richiesto segnalare file datore, segnala. */ IF COND(&SIGDTR) THEN(DO) CHGVAR VAR(&MSGDTA) VALUE('->f' *BCAT &CMLIB *CAT + '/' *CAT &CMFILE *CAT '-' *CAT &CMNAME + *CAT ' "' *CAT &CHGDATED *CAT '" "' *CAT + &CHGDATET *CAT '" "' *CAT &USEDATED *CAT '"') JSNDMSG MSGDTA(&MSGDTA) MSGTYPE(*INFO) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) ENDDO /* Se corre esecuzione. */ IF COND(&RUN *EQ *EXEC) THEN(DO) /* Duplica il file nella libreria ricevente. */ JCLNPF9 FROMLIB(&CMLIB) FILE(&CMFILE) TOLIB(&CMLIB§) + RTNMSGID(&DUPMSGID) RTNMSGDTA(&DUPMSGDTA) + RTNERR(&DUPERR) RTNEXIST(&DUPEXIST) + RTNDUP(&DUPDUP) /* Se duplicazione in errore, conta errore. */ IF COND(&DUPERR) THEN(DO) CHGVAR VAR(&TOTCNTERR) VALUE(&TOTCNTERR + 1) CHGVAR VAR(&LIBCNTERR) VALUE(&LIBCNTERR + 1) ENDDO /* Se esiste gia' ricevente, conta gia' esistente. */ IF COND(&DUPEXIST) THEN(DO) CHGVAR VAR(&TOTCNTALR) VALUE(&TOTCNTALR + 1) CHGVAR VAR(&LIBCNTALR) VALUE(&LIBCNTALR + 1) ENDDO /* Se eseguito duplicato, conta duplicazione. */ IF COND(&DUPDUP) THEN(DO) CHGVAR VAR(&TOTCNTDUP) VALUE(&TOTCNTDUP + 1) CHGVAR VAR(&LIBCNTDUP) VALUE(&LIBCNTDUP + 1) ENDDO /* Messaggia quanto segnalato dalla duplicazione file. */ IF COND(&DUPMSGID *NE ' ') THEN(DO) JSNDMSG MSGID(&DUPMSGID) MSGF(&MSGF) + MSGDTA(&DUPMSGDTA) MSGTYPE(*INFO) + STATUS(*YES) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) ENDDO /* Se corre esecuzione. */ ENDDO /* Se non corre esecuzione. */ IF COND(&RUN *NE *EXEC) THEN(DO) /* Controlla l'esistenza del file ricevente. */ CHKOBJ OBJ(&CMLIB§/&CMFILE) OBJTYPE(*FILE) /* Se non esiste il ricevente, passa oltre. */ MONMSG MSGID(CPF0000) EXEC(DO) RCVMSG MSGTYPE(*EXCP) WAIT(1) RMV(*YES) GOTO CMDLBL(ENDFILE) ENDDO /* Conta file gia' esistente. */ CHGVAR VAR(&TOTCNTALR) VALUE(&TOTCNTALR + 1) CHGVAR VAR(&LIBCNTALR) VALUE(&LIBCNTALR + 1) ENDFILE: /* Se non corre esecuzione. */ ENDDO /* Se nome membro e' vuoto. */ ENDDO /*----------------------------------------------------------------------------*/ /* Se esiste libreria datrice. */ ENDDO /* Esegue elaborazione record. */ ENDDO /* CONTROLLA MEMBRI. END */ /*----------------------------------------------------------------------------*/ /* Cicla lettura record. */ ENDDO /*----------------------------------------------------------------------------*/ /* Emette l'ultimo messaggio totali libreria precedente. */ CALLSUBR SUBR(MSGPRELIB) /* Messaggia "Esaminato elenco librerie". */ CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB) JSNDMSG MSGID(JCL0410) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*COMP) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Se non corre run diagnostico con creazione librerie riceventi. */ IF COND(&RUN *NE *DIAGCRT) THEN(DO) /* Messaggia "Contatori". */ JDECCHA FROMDEC(&TOTCNTRCD) TOCHAR5(&TOTCNTRCDC) JDECCHA FROMDEC(&TOTCNTTOM) TOCHAR5(&TOTCNTTOMC) JDECCHA FROMDEC(&TOTCNTDSR) TOCHAR5(&TOTCNTDSRC) JDECCHA FROMDEC(&TOTCNTCHG) TOCHAR5(&TOTCNTCHGC) JDECCHA FROMDEC(&TOTCNTERR) TOCHAR5(&TOTCNTERRC) JDECCHA FROMDEC(&TOTCNTALR) TOCHAR5(&TOTCNTALRC) JDECCHA FROMDEC(&TOTCNTDUP) TOCHAR5(&TOTCNTDUPC) JDECCHA FROMDEC(&TOTSIZALL) TOCHAR8(&TOTSIZALLC) JDECCHA FROMDEC(&TOTSIZFRE) TOCHAR8(&TOTSIZFREC) CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB *CAT &TOTCNTRCDC + *CAT &TOTCNTTOMC *CAT &TOTCNTDSRC *CAT + &TOTCNTCHGC *CAT &TOTCNTERRC *CAT + &TOTCNTALRC *CAT &TOTCNTDUPC *CAT + &TOTSIZALLC *CAT &TOTSIZFREC) JSNDMSG MSGID(JCL0413) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*COMP) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Se non corre run diagnostico con creazione librerie riceventi. */ ENDDO /* Se la conta dei membri da muovere e' zero, */ /* messaggia "Nessuna libreria da pulire". */ IF COND(&TOTCNTTOM *EQ 0) THEN(DO) CHGVAR VAR(&RTNID) VALUE(JCL0411) CHGVAR VAR(&RTNDTA) VALUE(' ') GOTO CMDLBL(ERRORE) ENDDO /* Label di esecuzione delle attivita' finali. */ RCLRSC: /* Dealloca ... */ /* Riacquisisce le risorse. */ RCLRSC MONMSG MSGID(CPF0000 MCH0000) /* Ritorna. */ RETURN /* Label di errore. */ ERRORE: /* Se manca identificazione errore, assume "Errore imprevisto". */ IF COND(&RTNID *EQ ' ') THEN(CHGVAR VAR(&RTNID) + VALUE(JCL0412)) CHGVAR VAR(&RTNDTA) VALUE(&CMLIB *CAT &CMFILE *CAT + &CMNAME) CHGVAR VAR(&RTNERR) VALUE('1') GOTO CMDLBL(RCLRSC) /*----------------------------------------------------------------------------*/ /* Emette il messaggio totali libreria precedente e li azzera. */ /* Riceve in &PRELIB il Nome libreria precedente. */ /* Riceve in &LIBCNTRCD la Conta dei record. */ /* Riceve in &LIBCNTTOM la Conta dei membri da muovere. */ /* Riceve in &LIBCNTDSR la Conta dei membri da muovere ma spariti. */ /* Riceve in &LIBCNTCHG la Conta dei membri da muovere ma cambiati. */ /* Riceve in &LIBCNTERR la Conta dei membri da muovere ma con duplic in err. */ /* Riceve in &LIBCNTALR la Conta dei membri da muovere ma gia' duplicati. */ /* Riceve in &LIBCNTDUP la Conta dei membri mossi nel run corrente. */ /* Riceve in &LIBSIZALL la Somma dello spazio occupato. */ /* Riceve in &LIBSIZFRE la Somma dello spazio occupato liberabile. */ SUBR SUBR(MSGPRELIB) /* Se non corre run diagnostico con creazione librerie riceventi */ /* e se libreria precedente e' valorizzata. */ IF COND((&RUN *NE *DIAGCRT) *AND (&PRELIB *NE ' + ')) THEN(DO) /* Conta le librerie esaminate. */ CHGVAR VAR(&RTNLIBEXA) VALUE(&RTNLIBEXA + 1) /* Messaggia "Contatori di libreria". */ JDECCHA FROMDEC(&LIBCNTRCD) TOCHAR5(&LIBCNTRCDC) JDECCHA FROMDEC(&LIBCNTTOM) TOCHAR5(&LIBCNTTOMC) JDECCHA FROMDEC(&LIBCNTDSR) TOCHAR5(&LIBCNTDSRC) JDECCHA FROMDEC(&LIBCNTCHG) TOCHAR5(&LIBCNTCHGC) JDECCHA FROMDEC(&LIBCNTERR) TOCHAR5(&LIBCNTERRC) JDECCHA FROMDEC(&LIBCNTALR) TOCHAR5(&LIBCNTALRC) JDECCHA FROMDEC(&LIBCNTDUP) TOCHAR5(&LIBCNTDUPC) JDECCHA FROMDEC(&LIBSIZALL) TOCHAR8(&LIBSIZALLC) JDECCHA FROMDEC(&LIBSIZFRE) TOCHAR8(&LIBSIZFREC) CHGVAR VAR(&MSGDTA) VALUE(&PRELIB *CAT &LIBCNTRCDC + *CAT &LIBCNTTOMC *CAT &LIBCNTDSRC *CAT + &LIBCNTCHGC *CAT &LIBCNTERRC *CAT + &LIBCNTALRC *CAT &LIBCNTDUPC *CAT + &LIBSIZALLC *CAT &LIBSIZFREC) JSNDMSG MSGID(JCL0414) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*COMP) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Azzera i contatori di libreria. */ CHGVAR VAR(&LIBCNTRCD) VALUE(0) CHGVAR VAR(&LIBCNTTOM) VALUE(0) CHGVAR VAR(&LIBCNTDSR) VALUE(0) CHGVAR VAR(&LIBCNTCHG) VALUE(0) CHGVAR VAR(&LIBCNTERR) VALUE(0) CHGVAR VAR(&LIBCNTALR) VALUE(0) CHGVAR VAR(&LIBCNTDUP) VALUE(0) CHGVAR VAR(&LIBSIZALL) VALUE(0) CHGVAR VAR(&LIBSIZFRE) VALUE(0) /* Se corre esecuzione. */ IF COND(&RUN *EQ *EXEC) THEN(DO) /* Duplica i file di servizio dalla work library alla ricevente. */ CALLSUBR SUBR(DUPJCLNPF) /* Se corre esecuzione. */ ENDDO /* Se non corre run diagnostico con creazione librerie riceventi */ /* e se libreria precedente e' valorizzata. */ ENDDO /* Se corre run diagnostico con creazione librerie riceventi */ /* e se libreria precedente e' valorizzata, conta le librerie esaminate. */ IF COND((&RUN *EQ *DIAGCRT) *AND (&PRELIB *NE ' + ')) THEN(CHGVAR VAR(&RTNLIBEXA) + VALUE(&RTNLIBEXA + 1)) ENDSUBR /*----------------------------------------------------------------------------*/ /* Duplica i file di servizio dalla work library alla ricevente */ /* allo scopo di conservare le informazioni usate per la pulizia. */ /* Riceve in &PRELIB il Nome libreria precedente. */ SUBR SUBR(DUPJCLNPF) /* Compone il nome della libreria ricevente. */ CHGVAR VAR(&PRELIB§) VALUE(%SST(&PRELIB 1 9) *TCAT §) /* Cancella gli eventuali file di servizio dalla libreria ricevente. */ DLTF FILE(&PRELIB§/JCLNPF*) MONMSG MSGID(CPF0000 MCH0000) /* Duplica i file di servizio nella libreria ricevente. */ CRTDUPOBJ OBJ(JCLNPF*) FROMLIB(&WRKLIB) OBJTYPE(*FILE) + TOLIB(&PRELIB§) DATA(*YES) CST(*NO) + TRG(*NO) FILEID(*YES) MONMSG MSGID(CPF0000 MCH0000) ENDSUBR /*----------------------------------------------------------------------------*/ ENDPGM //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF4P) FILETYPE(*SRC) ENDCHAR('//ENDSRC') :PNLGRP. :IMPORT NAME='*' PNLGRP=JPNL. .*------------------------------------------------------------------------------ :HELP NAME=CMD. .*------------------ :H3.Procedura JCLNPF :H2.Cleanings Physical Files :P.La procedura e' composta dai comandi :HP2.JCLNPF1 JCLNPF2 JCLNPF3 JCLNPF4 JCLNPF5:EHP2. documentati nei rispettivi help mentre la documentazione della procedura risiede nell'help del comando fittizio :HP2.JCLNPF:EHP2. .*------------------ :H3.Comando JCLNPF4 :H2.Duplicate Members :P.Duplica i file e i membri da sgombrare in librerie omonime delle originali ma con "§" in fondo al nome. :P.Prima del run esecutivo, e' possibile ed utile un run diagnostico. I membri originali da sgombrare risultano ancora intatti dopo le esecuzioni dei comandi :HP2.JCLNPF1 JCLNPF2 JCLNPF3 JCLNPF4:EHP2.. .*------------------ :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/wrk'. :H3.Cleaning work library suffix (WRK) :P.La procedura utilizza un gruppo di file con prefisso "JCLN" che vengono creati, riempiti e gestiti in una "Work Library" il cui nome viene composto facendo uso dello stesso prefisso "JCLN" e del suffisso indicato in questo parametro. :P.Il suffisso e' il primo parametro in tutti i comandi della procedura ed identifica in modo elementare ed univoco l'operazione di pulizia intrapresa con il primo comando della serie (JCLNPF1). :P.Valori permessi: :PARML. :PT.Nome di 6 caratteri :PD.Il valore č obbligatorio. :EPARML. :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/run'. :H3.Diagnostic/executive run (RUN) :P.Opzione di Diagnosi o Esecuzione della duplicazione dei file e dei membri da sgombrare dal sistema. :P.Valori permessi: :PARML. :PT.:PK DEF.*DIAG:EPK. :PD.Diagnostica la fattibilita' della duplicazione dei file e dei membri da sgombrare dal sistema. :PT.*EXEC :PD.Esegue la duplicazione dei file e dei membri da sgombrare dal sistema. :EPARML. :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/refpgm'. :IMHELP NAME='refpgm'. :EHELP. .*------------------------------------------------------------------------------ :HELP NAME='CMD/COMMAND/EXAMPLES'. .*------------------ :XH3.Esempi d'uso del comando :P.:HP2.Esempio 1: Diagnostica la duplicazione di file e membri.:EHP2. :XMP. Con i soli parametri necessari: JCLNPF4 WRK(NERO) Anche con i parametri di default: JCLNPF4 WRK(NERO) RUN(*DIAG) REFPGM(*CPP) :EXMP. :P.Questo comando esamina i dati gia' raccolti nella libreria di work JCLNNERO e diagnostica la fattibilita' della copia dei membri scelti in librerie parallele alle originali. Il comando genera un log di cui si riporta esempio. :XMP. > JCLNPF4 WRK(NERO) ->Run *DIAG Spostamenti ->Elabora duplicazione membri scelti tramite WorkLib JCLNNERO ->Legge elenco membri da spostare. WorkLib: JCLNNERO ->Datrice NERONI2 esiste. -Ricevente NERONI2§ NON esiste. ->Lib:NERONI2 Obj:704 ToMov:113 Desap:0 Chg:0 Err:0 Alrd:0 Dup:0 Siz:31510528 Fre:8372224 ->Esaminato elenco membri da spostare. WorkLib: JCLNNERO ->Wrk:JCLNNERO Obj:704 ToMov:113 Desap:0 Chg:0 Err:0 Alrd:0 Dup:0 Siz:31510528 Fre:8372224 ->Run *DIAG. Spostamenti diagnosticati: esamina i messaggi. :EXMP. :P.Si osservino i messaggi informativi e i comandi promemoria duplicabili per indagare o per eseguire i passi successivi della procedura. .*------------------ :P.:HP2.Esempio 2: Esegue la duplicazione di file e membri.:EHP2. :XMP. Con i soli parametri necessari: JCLNPF4 WRK(NERO) RUN(*EXEC) Anche con i parametri di default: JCLNPF4 WRK(NERO) RUN(*EXEC) REFPGM(*CPP) :EXMP. :P.Questo comando esamina i dati gia' raccolti nella libreria di work JCLNNERO e copia i membri scelti in librerie parallele alle originali. Il comando genera un log di cui si riporta esempio. :XMP. > JCLNPF4 WRK(NERO) ->Run *DIAG Spostamenti ->Elabora duplicazione membri scelti tramite WorkLib JCLNNERO ->Legge elenco membri da spostare. WorkLib: JCLNNERO ->Datrice NERONI2 esiste. -Ricevente NERONI2§ NON esiste. ->Lib:NERONI2 Obj:704 ToMov:113 Desap:0 Chg:0 Err:0 Alrd:0 Dup:0 Siz:31510528 Fre:8372224 ->Esaminato elenco membri da spostare. WorkLib: JCLNNERO ->Wrk:JCLNNERO Obj:704 ToMov:113 Desap:0 Chg:0 Err:0 Alrd:0 Dup:0 Siz:31510528 Fre:8372224 ->Run *DIAG. Spostamenti diagnosticati: esamina i messaggi. :EXMP. :P.Si osservino i messaggi informativi e i comandi promemoria duplicabili per indagare o per eseguire i passi successivi della procedura. .*------------------ :EHELP. .*------------------------------------------------------------------------------ :HELP NAME='CMD/ERROR/MESSAGES'. .*------------------ :XH3.Messaggi informativi e di completamento :P.:HP3.Messaggi *INFO e *COMP:EHP3. :DL COMPACT. :DT.JCL0401 :DD.&MSG(JCL0401,JCLNPF,*LIBL,nosub). :DT.JCL0402 :DD.&MSG(JCL0402,JCLNPF,*LIBL,nosub). :DT.JCL0421 :DD.&MSG(JCL0421,JCLNPF,*LIBL,nosub). :DT.JCL0422 :DD.&MSG(JCL0422,JCLNPF,*LIBL,nosub). :DT.JCL0424 :DD.&MSG(JCL0424,JCLNPF,*LIBL,nosub). :EDL. .*------------------ :XH3.Messaggi di errore :P.:HP3.Messaggi *DIAG seguiti da *ESCAPE CPF0001:EHP3. :DL COMPACT. :DT.JCL0002 :DD.&MSG(JCL0002,JCLNPF,*LIBL,nosub). :DT.JCL0406 :DD.&MSG(JCL0406,JCLNPF,*LIBL,nosub). :DT.JCL0411 :DD.&MSG(JCL0411,JCLNPF,*LIBL,nosub). :DT.JCL0412 :DD.&MSG(JCL0412,JCLNPF,*LIBL,nosub). :EDL. .*------------------ :EHELP. .*------------------------------------------------------------------------------ :EPNLGRP. //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF5) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 29-10-2015 Creato. */ /* Cleanings. Physical. Dlt. Cmd */ /* Pulizie. Fisici. Cancella. Comando */ /* */ CMD PROMPT('Delete Original Members') PARM KWD(WRK) TYPE(*NAME) LEN(6) MIN(1) + PROMPT('Cleaning work library suffix') PARM KWD(RUN) TYPE(*CHAR) LEN(10) RSTD(*YES) + DFT(*DIAG) VALUES(*DIAG *EXEC) + PROMPT('Diagnostic/executive run') PARM KWD(REFPGM) TYPE(*NAME) LEN(10) DFT(*CPP) + SPCVAL((*CPP)) PROMPT('Reference program + for messages') //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF5C) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 03-11-2015 Creato. */ /* Cleanings. Physical. Dlt. Cpp */ /* Pulizie. Fisici. Cancella. Cpp */ /* Cancella i membri dalle librerie originali. */ /* */ PGM PARM(&WRK &RUN &REFPGM) /* Riceve Cleaning work library suffix. */ DCL VAR(&WRK) TYPE(*CHAR) LEN(6) /* Riceve Run Type: diagnostic or executive. */ /* *DIAG = Diagnostica prima di eseguire. */ /* *EXEC = Esegue */ DCL VAR(&RUN) TYPE(*CHAR) LEN(10) /* Riceve Programma di riferimento per i messaggi. */ DCL VAR(&REFPGM) TYPE(*CHAR) LEN(10) /* Cleaning work library. */ DCL VAR(&WRKLIB) TYPE(*CHAR) LEN(10) /* Messaggio. */ DCL VAR(&MSGID) TYPE(*CHAR) LEN(7) DCL VAR(&MSGDTA) TYPE(*CHAR) LEN(512) /* Flag di errore. */ DCL VAR(&ERR) TYPE(*LGL) /* File messaggi. */ DCL VAR(&MSGF) TYPE(*CHAR) LEN(10) VALUE(JCLNPF) /* To message queue. */ DCL VAR(&TOMSGQ) TYPE(*CHAR) LEN(10) VALUE(JCLNPF) DCL VAR(&TOMSGQTXT) TYPE(*CHAR) LEN(50) + VALUE('Cleanings Physical Files') /* Prenotazione del CPF0001. */ DCL VAR(&CPF0001) TYPE(*LGL) /* Intercetta gli errori imprevisti. */ MONMSG MSGID(CPF0000 MCH0000 CEE0000) EXEC(GOTO + CMDLBL(ERRORE)) /* Se richiesto *CPP (Command Processing Program) come programma */ /* di riferimento dei messaggi, assume il nome del programma corrente. */ IF COND(&REFPGM *EQ *CPP) THEN(DO) JCALLER CALLER(&REFPGM) KINSHIP(*FATHER) ENDDO /* Segnala inizio log. */ SNDPGMMSG MSG(DLTBEG) TOPGMQ(*SAME) /* Compone il nome della Cleaning work library. */ CHGVAR VAR(&WRKLIB) VALUE(JCLN *CAT &WRK) /* Controlla l'esistenza della work library. */ CHKOBJ OBJ(&WRKLIB) OBJTYPE(*LIB) /* Se la work library non esiste, messaggia "Manca libreria" e abbandona. */ MONMSG MSGID(CPF0000) EXEC(DO) CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB *CAT &WRK) SNDPGMMSG MSGID(JCL0002) MSGF(&MSGF) MSGDTA(&MSGDTA) + TOPGMQ(*PRV (&REFPGM)) MSGTYPE(*DIAG) GOTO CMDLBL(CPF0001) ENDDO /* Avvia coda messaggi. */ JSNDMSG MSGDTA(JCLNPF4) MSGTYPE(*INFO) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) + TOMSGQTXT(&TOMSGQTXT) SEQ(*FIRST) /* Messaggia "Run Type". */ CHGVAR VAR(&MSGDTA) VALUE(&RUN) JSNDMSG MSGID(JCL0501) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Messaggia "Elabora". */ CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB) JSNDMSG MSGID(JCL0502) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Se run diagnostico. */ IF COND(&RUN *EQ *DIAG) THEN(DO) /* Chiama controllo cancellazioni. */ CALL PGM(JCLNPF5D) PARM(&WRKLIB &RUN &MSGID + &MSGDTA &ERR &REFPGM) /* Se errore, messaggia e abbandona. */ IF COND(&ERR) THEN(DO) JSNDMSG MSGID(&MSGID) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*DIAG) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) GOTO CMDLBL(CPF0001) ENDDO /* Se richiesto messaggio informativo, messaggia. */ IF COND(&MSGID *NE ' ') THEN(DO) JSNDMSG MSGID(&MSGID) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) ENDDO /* Se run diagnostico. */ ENDDO /* Se run esecutivo. */ IF COND(&RUN *EQ *EXEC) THEN(DO) /* Chiama il controllo che le librerie duplicate, se esistenti, */ /* appartengano alla work library corrente. */ OVRDBF FILE(JCLNPFCA) TOFILE(&WRKLIB/JCLNPFCA) CALL PGM(JCLNPFCDL) PARM(&WRKLIB &REFPGM &ERR) DLTOVR FILE(*ALL) /* Se errore, rilascia. */ IF COND(&ERR) THEN(GOTO CMDLBL(CPF0001)) /* Chiama esecuzione cancellazioni. */ CALL PGM(JCLNPF5D) PARM(&WRKLIB &RUN &MSGID + &MSGDTA &ERR &REFPGM) /* Se errore, messaggia e abbandona. */ IF COND(&ERR) THEN(DO) JSNDMSG MSGID(&MSGID) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*DIAG) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) GOTO CMDLBL(CPF0001) ENDDO /* Se richiesto messaggio informativo, messaggia. */ IF COND(&MSGID *NE ' ') THEN(DO) JSNDMSG MSGID(&MSGID) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) ENDDO /* Se run esecutivo. */ ENDDO /* Messaggia "Cancellazioni controllate/eseguite". */ SELECT WHEN COND(&RUN *EQ *DIAG) THEN(CHGVAR VAR(&MSGID) + VALUE(JCL0521)) WHEN COND(&RUN *EQ *EXEC) THEN(CHGVAR VAR(&MSGID) + VALUE(JCL0522)) OTHERWISE CMD(CHGVAR VAR(&MSGID) VALUE(JCL0524)) ENDSELECT CHGVAR VAR(&MSGDTA) VALUE(&RUN *CAT &WRKLIB) JSNDMSG MSGID(&MSGID) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Se run diagnostico. */ IF COND(&RUN *EQ *DIAG) THEN(DO) /* Chiama il controllo che le librerie duplicate, se esistenti, */ /* appartengano alla work library corrente. */ OVRDBF FILE(JCLNPFCA) TOFILE(&WRKLIB/JCLNPFCA) CALL PGM(JCLNPFCDL) PARM(&WRKLIB &REFPGM &ERR) DLTOVR FILE(*ALL) /* Se errore, rilascia. */ IF COND(&ERR) THEN(GOTO CMDLBL(CPF0001)) /* Se run diagnostico. */ ENDDO /* Label di esecuzione delle attivitā finali. */ RCLRSC: /* Dealloca ... */ /* Se run esecutivo, scarica joblog su file fisico. */ IF COND(&RUN *EQ *EXEC) THEN(DO) JLOG FROMTAG(DLTBEG) OUTFILE(&WRKLIB/JLOGJCLNPF) + MBROPT(*ADD) TOPGMQ(*PRVPRV) MONMSG MSGID(CPF0000 MCH0000) ENDDO /* Riacquisisce le risorse. */ RCLRSC MONMSG MSGID(CPF0000 MCH0000) /* Se richiesto, rilascia il CPF0001. */ IF COND(&CPF0001) THEN(DO) JSNDMSG MSGID(CPF0001) MSGF(QCPFMSG) MSGDTA(JCLNPF4) + MSGTYPE(*MSGQ) REFPGM(&REFPGM) + TOMSGQ(&WRKLIB/&TOMSGQ) MONMSG MSGID(CPF0000 MCH0000) SNDPGMMSG MSGID(CPF0001) MSGF(QCPFMSG) MSGDTA(JCLNPF5) + MSGTYPE(*ESCAPE) MONMSG MSGID(CPF0000 MCH0000) ENDDO /* Ritorna. */ RETURN /* Label di errore. */ ERRORE: /* Restituisce i messaggi al chiamante, */ /* trasformando eventuali escape in diagnostici. */ JRSNMSG MONMSG MSGID(CPF0000 MCH0000) /* Label di prenotazione del CPF0001. */ CPF0001: /* Prenota il CPF0001. */ CHGVAR VAR(&CPF0001) VALUE('1') MONMSG MSGID(CPF0000 MCH0000) /* Salta alle attivitā finali. */ GOTO CMDLBL(RCLRSC) ENDPGM //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF5D) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 04-11-2015 Creato. */ /* Cleanings. Physical. Dlt. Chk&Dlt */ /* Pulizie. Fisici. Cancella. Controlla e cancella. */ /* Controlla l'esistenza delle librerie riceventi */ /* menzionate nell'elenco dei membri da spostare. */ /* Controlla l'esistenza e le caratteristiche dei membri originali e */ /* dei membri duplicati menzionati nell'elenco dei membri da spostare. */ /* Cancella i membri originali. */ /* */ PGM PARM(&WRKLIB &RUN &RTNID &RTNDTA &RTNERR + &REFPGM) /* Riceve Work library. */ DCL VAR(&WRKLIB) TYPE(*CHAR) LEN(10) /* Riceve Tipo run diagnostico/esecutivo. */ /* *DIAG = Diagnostica prima di eseguire. */ /* *EXEC = Esegue */ DCL VAR(&RUN) TYPE(*CHAR) LEN(10) /* Ritorna Messaggio. */ DCL VAR(&RTNID) TYPE(*CHAR) LEN(7) DCL VAR(&RTNDTA) TYPE(*CHAR) LEN(256) /* Ritorna Flag di errore. */ DCL VAR(&RTNERR) TYPE(*LGL) /* Riceve Programma di riferimento per i messaggi. */ DCL VAR(&REFPGM) TYPE(*CHAR) LEN(10) /* Libreria datrice precedente. */ DCL VAR(&PRELIB) TYPE(*CHAR) LEN(10) /* Libreria ricevente. */ DCL VAR(&CMLIB§) TYPE(*CHAR) LEN(10) /* Flag di segnalazione membro datore. */ DCL VAR(&SIGDTR) TYPE(*LGL) /* Flag di segnalazione membro ricevente. */ DCL VAR(&SIGRIC) TYPE(*LGL) /* Dati messaggio. */ DCL VAR(&MSGDTA) TYPE(*CHAR) LEN(512) /* Messaggio. */ DCL VAR(&RTNMSGID) TYPE(*CHAR) LEN(7) DCL VAR(&RTNMSGDTA) TYPE(*CHAR) LEN(256) /* Conta record. */ DCL VAR(&TRCD) TYPE(*DEC) LEN(9 0) DCL VAR(&TRCDC) TYPE(*CHAR) LEN(5) DCL VAR(&LRCD) TYPE(*DEC) LEN(9 0) DCL VAR(&LRCDC) TYPE(*CHAR) LEN(5) /* Conta dei membri da muovere. */ DCL VAR(&TMDM) TYPE(*DEC) LEN(9 0) DCL VAR(&TMDMC) TYPE(*CHAR) LEN(5) DCL VAR(&LMDM) TYPE(*DEC) LEN(9 0) DCL VAR(&LMDMC) TYPE(*CHAR) LEN(5) /* Conta manca membro ricevente. */ DCL VAR(&TMMR) TYPE(*DEC) LEN(9 0) DCL VAR(&TMMRC) TYPE(*CHAR) LEN(5) DCL VAR(&LMMR) TYPE(*DEC) LEN(9 0) DCL VAR(&LMMRC) TYPE(*CHAR) LEN(5) /* Conta dei membri datori esistenti. */ DCL VAR(&TEFR) TYPE(*DEC) LEN(9 0) DCL VAR(&TEFRC) TYPE(*CHAR) LEN(5) DCL VAR(&LEFR) TYPE(*DEC) LEN(9 0) DCL VAR(&LEFRC) TYPE(*CHAR) LEN(5) /* Conta dei membri riceventi esistenti. */ DCL VAR(&TETO) TYPE(*DEC) LEN(9 0) DCL VAR(&TETOC) TYPE(*CHAR) LEN(5) DCL VAR(&LETO) TYPE(*DEC) LEN(9 0) DCL VAR(&LETOC) TYPE(*CHAR) LEN(5) /* Conta dei membri da muovere ma cambiati. */ DCL VAR(&TCHG) TYPE(*DEC) LEN(9 0) DCL VAR(&TCHGC) TYPE(*CHAR) LEN(5) DCL VAR(&LCHG) TYPE(*DEC) LEN(9 0) DCL VAR(&LCHGC) TYPE(*CHAR) LEN(5) /* Conta dei membri da muovere ma con cancellazione in errore. */ DCL VAR(&TERR) TYPE(*DEC) LEN(9 0) DCL VAR(&TERRC) TYPE(*CHAR) LEN(5) DCL VAR(&LERR) TYPE(*DEC) LEN(9 0) DCL VAR(&LERRC) TYPE(*CHAR) LEN(5) /* Conta dei membri cancellati nel run corrente. */ DCL VAR(&TDLT) TYPE(*DEC) LEN(9 0) DCL VAR(&TDLTC) TYPE(*CHAR) LEN(5) DCL VAR(&LDLT) TYPE(*DEC) LEN(9 0) DCL VAR(&LDLTC) TYPE(*CHAR) LEN(5) /* Flag esiste datore. */ DCL VAR(&RTNEXIFROM) TYPE(*LGL) /* Flag esiste ricevente. */ DCL VAR(&RTNEXITO) TYPE(*LGL) /* Flag non eguale numero records. */ DCL VAR(&RTNNEQ) TYPE(*LGL) /* Flag cancellato datore. */ DCL VAR(&RTNDLT) TYPE(*LGL) /* File messaggi. */ DCL VAR(&MSGF) TYPE(*CHAR) LEN(10) VALUE(JCLNPF) /* To message queue. */ DCL VAR(&TOMSGQ) TYPE(*CHAR) LEN(10) VALUE(JCLNPF) DCL VAR(&TOMSGQTXT) TYPE(*CHAR) LEN(50) + VALUE('Cleanings Physical Files') /* Elenco dei membri da muovere. */ DCLF FILE(JCLNPFCA) /* Intercetta gli errori imprevisti. */ MONMSG MSGID(CPF0000 MCH0000 CEE0000) EXEC(GOTO + CMDLBL(ERRORE)) /* Pulisce i parametri di ritorno. */ CHGVAR VAR(&RTNID) VALUE(' ') CHGVAR VAR(&RTNDTA) VALUE(' ') CHGVAR VAR(&RTNERR) VALUE('0') /* Controlla l'esistenza della work library. */ CHKOBJ OBJ(&WRKLIB) OBJTYPE(*LIB) /* Se la work library non esiste, restituisce errore al chiamante. */ MONMSG MSGID(CPF0000) EXEC(DO) CHGVAR VAR(&RTNID) VALUE(JCL0002) CHGVAR VAR(&RTNDTA) VALUE(&WRKLIB) GOTO CMDLBL(ERRORE) ENDDO /* Messaggia "Lettura elenco membri in corso". */ CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB) JSNDMSG MSGID(JCL0503) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Reindirizza il file da leggere. */ OVRDBF FILE(JCLNPFCA) TOFILE(&WRKLIB/JCLNPFCA) /*----------------------------------------------------------------------------*/ /* Cicla lettura record. */ DOWHILE COND(1 = 1) /* Legge un record membro candidato a pulizia. */ RCVF /* Se non ce ne sono altri, abbandona. */ MONMSG MSGID(CPF0864) EXEC(LEAVE) /* Conta record. */ CHGVAR VAR(&TRCD) VALUE(&TRCD + 1) CHGVAR VAR(&LRCD) VALUE(&LRCD + 1) /* Se il candidato e' da conservare, ricicla. */ IF COND(&CMFIFG *NE '1') THEN(ITERATE) /* Se la libreria e' diversa dalla precedente. */ IF COND(&CMLIB *NE &PRELIB) THEN(DO) /* Emette il messaggio totali libreria precedente e li azzera. */ CALLSUBR SUBR(MSGPRELIB) /* Accantona la libreria precedente. */ CHGVAR VAR(&PRELIB) VALUE(&CMLIB) /* Controlla l'esistenza della libreria datrice. */ CHKOBJ OBJ(&CMLIB) OBJTYPE(*LIB) /* Se la libreria datrice non esiste, restituisce errore al chiamante. */ MONMSG MSGID(CPF0000) EXEC(DO) CHGVAR VAR(&RTNID) VALUE(JCL0003) CHGVAR VAR(&RTNDTA) VALUE(&CMLIB) GOTO CMDLBL(ERRORE) ENDDO /* Compone il nome della libreria ricevente. */ CHGVAR VAR(&CMLIB§) VALUE(%SST(&CMLIB 1 9) *TCAT §) /* Se datrice e ricevente coincidono, restituisce errore al chiamante. */ IF COND(&CMLIB *EQ &CMLIB§) THEN(DO) CHGVAR VAR(&RTNID) VALUE(JCL0506) CHGVAR VAR(&RTNDTA) VALUE(&CMLIB) GOTO CMDLBL(ERRORE) ENDDO /* Controlla l'esistenza della libreria ricevente. */ CHKOBJ OBJ(&CMLIB§) OBJTYPE(*LIB) /* Se la libreria ricevente non esiste, restituisce errore al chiamante.*/ MONMSG MSGID(CPF0000) EXEC(DO) CHGVAR VAR(&RTNID) VALUE(JCL0004) CHGVAR VAR(&RTNDTA) VALUE(&CMLIB§) GOTO CMDLBL(ERRORE) ENDDO /* Messaggia "Datrice - Ricevente". */ CHGVAR VAR(&MSGDTA) VALUE(&CMLIB *CAT &CMLIB§) JSNDMSG MSGID(JCL0505) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*INFO) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Se la libreria e' diversa dalla precedente. */ ENDDO /* Conta record dei membri da muovere. */ CHGVAR VAR(&TMDM) VALUE(&TMDM + 1) CHGVAR VAR(&LMDM) VALUE(&LMDM + 1) /*----------------------------------------------------------------------------*/ /* CONTROLLA MEMBRI. BEG */ /* Assume non segnalare membro datore ne' ricevente. */ CHGVAR VAR(&SIGDTR) VALUE('0') CHGVAR VAR(&SIGRIC) VALUE('0') /* Esegue elaborazione record. */ DOUNTIL COND(1 = 1) /*----------------------------------------------------------------------------*/ /* Se corre diagnostico. */ IF COND(&RUN *EQ *DIAG) THEN(DO) /* Se nome membro valorizzato. */ IF COND(&CMNAME *NE ' ') THEN(DO) /* Controlla cancellabilita' membro datore. */ JCLNPF8X FROMLIB(&CMLIB) FILE(&CMFILE) + MEMBER(&CMNAME) TOLIB(&CMLIB§) + RTNMSGID(&RTNMSGID) RTNMSGDTA(&RTNMSGDTA) + RTNERR(&RTNERR) RTNEXIFROM(&RTNEXIFROM) + RTNEXITO(&RTNEXITO) RTNNEQRCD(&RTNNEQ) + RTNDLT(&RTNDLT) RUN(*DIAG) if &RTNERR do dlyjob 1 enddo /* Incrementa i contatori. */ CALLSUBR SUBR(INCREMENTA) /* Se manca membro ricevente, segnala, conta e abbandona. */ IF COND(*NOT &RTNEXITO) THEN(DO) CHGVAR VAR(&SIGRIC) VALUE('1') CHGVAR VAR(&MSGDTA) VALUE('->r' *BCAT &CMLIB *CAT + '/' *CAT &CMFILE *CAT '-' *CAT &CMNAME + *CAT ' manca membro ricevente') JSNDMSG MSGDTA(&MSGDTA) MSGTYPE(*INFO) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) LEAVE ENDDO /* Se datore diverso da ricevente, segnala e abbandona. */ IF COND(&RTNNEQ) THEN(DO) CHGVAR VAR(&SIGRIC) VALUE('1') CHGVAR VAR(&MSGDTA) VALUE('->r' *BCAT &CMLIB *CAT + '/' *CAT &CMFILE *CAT '-' *CAT &CMNAME + *CAT ' datore-ricevente diversi') JSNDMSG MSGDTA(&MSGDTA) MSGTYPE(*INFO) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) LEAVE ENDDO /* Se nome membro valorizzato. */ ENDDO /* Se nome membro vuoto. */ IF COND(&CMNAME *EQ ' ') THEN(DO) /* Controlla cancellabilita' file datore. */ JCLNPF9X FROMLIB(&CMLIB) FILE(&CMFILE) TOLIB(&CMLIB§) + RTNMSGID(&RTNMSGID) RTNMSGDTA(&RTNMSGDTA) + RTNERR(&RTNERR) RTNEXIFROM(&RTNEXIFROM) + RTNEXITO(&RTNEXITO) RTNNEQRCD(&RTNNEQ) + RTNDLT(&RTNDLT) RUN(*DIAG) if &RTNERR do dlyjob 1 enddo /* Incrementa i contatori. */ CALLSUBR SUBR(INCREMENTA) /* Se manca file ricevente, segnala, conta e abbandona. */ IF COND(*NOT &RTNEXITO) THEN(DO) CHGVAR VAR(&SIGRIC) VALUE('1') CHGVAR VAR(&MSGDTA) VALUE('->r' *BCAT &CMLIB *CAT + '/' *CAT &CMFILE *CAT '-' *CAT + ' manca file ricevente') JSNDMSG MSGDTA(&MSGDTA) MSGTYPE(*INFO) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) LEAVE ENDDO /* Se datore diverso da ricevente, segnala e abbandona. */ IF COND(&RTNNEQ) THEN(DO) CHGVAR VAR(&SIGRIC) VALUE('1') CHGVAR VAR(&MSGDTA) VALUE('->r' *BCAT &CMLIB *CAT + '/' *CAT &CMFILE *CAT '-' *CAT &CMNAME + *CAT ' datore-ricevente diversi') JSNDMSG MSGDTA(&MSGDTA) MSGTYPE(*INFO) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) LEAVE ENDDO /* Se nome membro vuoto. */ ENDDO /* Se corre diagnostico. */ ENDDO /*----------------------------------------------------------------------------*/ /* Se corre esecuzione. */ IF COND(&RUN *EQ *EXEC) THEN(DO) /* Se nome membro valorizzato. */ IF COND(&CMNAME *NE ' ') THEN(DO) /* Cancella membro datore. */ JCLNPF8X FROMLIB(&CMLIB) FILE(&CMFILE) + MEMBER(&CMNAME) TOLIB(&CMLIB§) + RTNMSGID(&RTNMSGID) RTNMSGDTA(&RTNMSGDTA) + RTNERR(&RTNERR) RTNEXIFROM(&RTNEXIFROM) + RTNEXITO(&RTNEXITO) RTNNEQRCD(&RTNNEQ) + RTNDLT(&RTNDLT) RUN(*EXEC) /* Se ha eseguito cancellazione, conta. */ IF COND(&RTNDLT) THEN(DO) CHGVAR VAR(&TDLT) VALUE(&TDLT + 1) CHGVAR VAR(&LDLT) VALUE(&LDLT + 1) ENDDO /* Se nome membro valorizzato. */ ENDDO /* Se nome membro vuoto. */ IF COND(&CMNAME *EQ ' ') THEN(DO) /* Cancella file datore. */ JCLNPF9X FROMLIB(&CMLIB) FILE(&CMFILE) TOLIB(&CMLIB§) + RTNMSGID(&RTNMSGID) RTNMSGDTA(&RTNMSGDTA) + RTNERR(&RTNERR) RTNEXIFROM(&RTNEXIFROM) + RTNEXITO(&RTNEXITO) RTNNEQRCD(&RTNNEQ) + RTNDLT(&RTNDLT) RUN(*EXEC) /* Se ha eseguito cancellazione, conta. */ IF COND(&RTNDLT) THEN(DO) CHGVAR VAR(&TDLT) VALUE(&TDLT + 1) CHGVAR VAR(&LDLT) VALUE(&LDLT + 1) ENDDO /* Se nome membro vuoto. */ ENDDO /* Se corre esecuzione. */ ENDDO /*----------------------------------------------------------------------------*/ /* Esegue elaborazione record. */ ENDDO /* CONTROLLA MEMBRI. END */ /*----------------------------------------------------------------------------*/ /* Cicla lettura record. */ ENDDO /*----------------------------------------------------------------------------*/ /* Emette l'ultimo messaggio totali libreria precedente. */ CALLSUBR SUBR(MSGPRELIB) /* Messaggia "Esaminato elenco librerie". */ CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB) JSNDMSG MSGID(JCL0510) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*COMP) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Messaggia "Contatori". */ JDECCHA FROMDEC(&TRCD) TOCHAR5(&TRCDC) JDECCHA FROMDEC(&TMDM) TOCHAR5(&TMDMC) JDECCHA FROMDEC(&TMMR) TOCHAR5(&TMMRC) JDECCHA FROMDEC(&TEFR) TOCHAR5(&TEFRC) JDECCHA FROMDEC(&TETO) TOCHAR5(&TETOC) JDECCHA FROMDEC(&TCHG) TOCHAR5(&TCHGC) JDECCHA FROMDEC(&TERR) TOCHAR5(&TERRC) JDECCHA FROMDEC(&TDLT) TOCHAR5(&TDLTC) CHGVAR VAR(&MSGDTA) VALUE(&WRKLIB *CAT &TRCDC *CAT + &TMDMC *CAT &TMMRC *CAT &TEFRC *CAT + &TETOC *CAT &TERRC *CAT &TCHGC *CAT &TDLTC) JSNDMSG MSGID(JCL0513) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*COMP) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Se la conta dei membri da muovere e' zero, */ /* messaggia "Nessuna libreria da pulire". */ IF COND(&TMDM *EQ 0) THEN(DO) CHGVAR VAR(&RTNID) VALUE(JCL0411) /*OK*/ CHGVAR VAR(&RTNDTA) VALUE(' ') GOTO CMDLBL(ERRORE) ENDDO /* Label di esecuzione delle attivita' finali. */ RCLRSC: /* Dealloca ... */ /* Riacquisisce le risorse. */ RCLRSC MONMSG MSGID(CPF0000 MCH0000) /* Ritorna. */ RETURN /* Label di errore. */ ERRORE: /* Se manca identificazione errore, assume "Errore imprevisto". */ IF COND(&RTNID *EQ ' ') THEN(DO) CHGVAR VAR(&RTNID) VALUE(JCL0512) CHGVAR VAR(&RTNDTA) VALUE(&CMLIB *CAT &CMFILE *CAT + &CMNAME) ENDDO /* Annota errore. */ CHGVAR VAR(&RTNERR) VALUE('1') /* Salta ad attivita' finali. */ GOTO CMDLBL(RCLRSC) RETURN /*----------------------------------------------------------------------------*/ /* Emette il messaggio totali libreria precedente e li azzera. */ /* Riceve in &PRELIB il Nome libreria precedente. */ /* Riceve i contatori di libreria. */ SUBR SUBR(MSGPRELIB) /* Se libreria precedente e' valorizzata. */ IF COND(&PRELIB *NE ' ') THEN(DO) /* Messaggia "Contatori di libreria". */ JDECCHA FROMDEC(&LRCD) TOCHAR5(&LRCDC) JDECCHA FROMDEC(&LMDM) TOCHAR5(&LMDMC) JDECCHA FROMDEC(&LMMR) TOCHAR5(&LMMRC) JDECCHA FROMDEC(&LEFR) TOCHAR5(&LEFRC) JDECCHA FROMDEC(&LETO) TOCHAR5(&LETOC) JDECCHA FROMDEC(&LCHG) TOCHAR5(&LCHGC) JDECCHA FROMDEC(&LERR) TOCHAR5(&LERRC) JDECCHA FROMDEC(&LDLT) TOCHAR5(&LDLTC) CHGVAR VAR(&MSGDTA) VALUE(&PRELIB *CAT &LRCDC *CAT + &LMDMC *CAT &LMMRC *CAT &LEFRC *CAT + &LETOC *CAT &LERRC *CAT &LCHGC *CAT &LDLTC) JSNDMSG MSGID(JCL0514) MSGF(&MSGF) MSGDTA(&MSGDTA) + MSGTYPE(*COMP) STATUS(*YES) + REFPGM(&REFPGM) TOMSGQ(&WRKLIB/&TOMSGQ) /* Azzera i contatori di libreria. */ CHGVAR VAR(&LRCD) VALUE(0) CHGVAR VAR(&LMDM) VALUE(0) CHGVAR VAR(&LMMR) VALUE(0) CHGVAR VAR(&LEFR) VALUE(0) CHGVAR VAR(&LETO) VALUE(0) CHGVAR VAR(&LCHG) VALUE(0) CHGVAR VAR(&LERR) VALUE(0) CHGVAR VAR(&LDLT) VALUE(0) /* Se libreria precedente e' valorizzata. */ ENDDO ENDSUBR /*----------------------------------------------------------------------------*/ /* Incrementa i contatori. */ SUBR SUBR(INCREMENTA) /* Conta manca membro ricevente. */ IF COND(*NOT &RTNEXITO) THEN(DO) CHGVAR VAR(&TMMR) VALUE(&TMMR + 1) CHGVAR VAR(&LMMR) VALUE(&LMMR + 1) ENDDO /* Conta membro datore esistente. */ IF COND(&RTNEXIFROM) THEN(DO) CHGVAR VAR(&TEFR) VALUE(&TEFR + 1) CHGVAR VAR(&LEFR) VALUE(&LEFR + 1) ENDDO /* Conta membro ricevente esistente. */ IF COND(&RTNEXITO) THEN(DO) CHGVAR VAR(&TETO) VALUE(&TETO + 1) CHGVAR VAR(&LETO) VALUE(&LETO + 1) ENDDO /* Conta dei membri da muovere ma cambiati. */ IF COND(&RTNNEQ) THEN(DO) CHGVAR VAR(&TCHG) VALUE(&TCHG + 1) CHGVAR VAR(&LCHG) VALUE(&LCHG + 1) ENDDO /* Conta dei membri da muovere ma con cancellazione in errore. */ IF COND(&RTNERR) THEN(DO) CHGVAR VAR(&TERR) VALUE(&TERR + 1) CHGVAR VAR(&LERR) VALUE(&LERR + 1) ENDDO /* Conta dei membri cancellati nel run corrente. */ IF COND(&RTNDLT) THEN(DO) CHGVAR VAR(&TDLT) VALUE(&TDLT + 1) CHGVAR VAR(&LDLT) VALUE(&LDLT + 1) ENDDO ENDSUBR /*----------------------------------------------------------------------------*/ ENDPGM //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF5P) FILETYPE(*SRC) ENDCHAR('//ENDSRC') :PNLGRP. :IMPORT NAME='*' PNLGRP=JPNL. .*------------------------------------------------------------------------------ :HELP NAME=CMD. .*------------------ :H3.Procedura JCLNPF :H2.Cleanings Physical Files :P.La procedura e' composta dai comandi :HP2.JCLNPF1 JCLNPF2 JCLNPF3 JCLNPF4 JCLNPF5:EHP2. documentati nei rispettivi help mentre la documentazione della procedura risiede nell'help del comando fittizio :HP2.JCLNPF:EHP2. .*------------------ :H3.Comando JCLNPF5 :H2.Delete Original Members :P.Cancella i file e i membri da sgombrare gia' copiati nelle librerie duplicate, omonime delle originali ma con "§" in fondo al nome. :P.Prima del run esecutivo, e' possibile ed utile un run diagnostico. I membri originali da sgombrare risultano ancora intatti dopo le esecuzioni dei comandi :HP2.JCLNPF1 JCLNPF2 JCLNPF3 JCLNPF4:EHP2. ma anche dopo un run diagnostico del comando :HP2.JCLNPF5:EHP2.. .*------------------ :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/wrk'. :H3.Cleaning work library suffix (WRK) :P.La procedura utilizza un gruppo di file con prefisso "JCLN" che vengono creati, riempiti e gestiti in una "Work Library" il cui nome viene composto facendo uso dello stesso prefisso "JCLN" e del suffisso indicato in questo parametro. :P.Il suffisso e' il primo parametro in tutti i comandi della procedura ed identifica in modo elementare ed univoco l'operazione di pulizia intrapresa con il primo comando della serie (JCLNPF1). :P.Valori permessi: :PARML. :PT.Nome di 6 caratteri :PD.Il valore č obbligatorio. :EPARML. :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/run'. :H3.Diagnostic/executive run (RUN) :P.Opzione di Diagnosi o Esecuzione della cancellazione dei file e dei membri originali da sgombrare dal sistema. :P.Valori permessi: :PARML. :PT.:PK DEF.*DIAG:EPK. :PD.Diagnostica la fattibilita' della cancellazione dei file e dei membri originali da sgombrare dal sistema. :PT.*EXEC :PD.Esegue la cancellazione dei file e dei membri originali da sgombrare dal sistema. :EPARML. :EHELP. .*------------------------------------------------------------------------------ :HELP name='CMD/refpgm'. :IMHELP NAME='refpgm'. :EHELP. .*------------------------------------------------------------------------------ :HELP NAME='CMD/COMMAND/EXAMPLES'. .*------------------ :XH3.Esempi d'uso del comando :P.:HP2.Esempio 1: Diagnostica la cancellazione di file e membri originali.:EHP2. :XMP. Con i soli parametri necessari: JCLNPF5 WRK(TST) Anche con i parametri di default: JCLNPF5 WRK(TST) RUN(*DIAG) REFPGM(*CPP) :EXMP. :P.Questo comando esamina i dati gia' raccolti nella libreria di work JCLNNERO e diagnostica la fattibilita' della cancelazione di file e membri originali gia' duplicati nelle librerie parallele omonime delle originali ma con "§" in fondo al nome. Il comando genera un log di cui si riporta esempio. :XMP. > JCLNPF5 WRK(TST) ->Run *DIAG Cancellazioni ->Elabora cancellazione membri scelti tramite WorkLib JCLNTST ->Legge elenco membri da cancellare. WorkLib: JCLNTST Lib datrice NERONITST. Lib ricevente NERONITST§. ->Lib:NERONITST Obj:512 ToMov:485 InOri:485 InSav:485 NoSav:0 Err:2 Chg:0 Dlt:0 ->Esaminato elenco membri da cancellare. WorkLib: JCLNTST ->Obj:512 ToMov:485 InOri:485 InSav:485 NoSav:0 Err:2 Chg:0 Dlt:0 ->Run *DIAG. Cancellazioni diagnosticate: esamina i messaggi. :EXMP. :P.Si osservino i messaggi informativi e i comandi promemoria duplicabili per indagare o per eseguire i passi successivi della procedura. .*------------------ :P.:HP2.Esempio 2: Esegue la cancellazione definitiva di file e membri originali.:EHP2. :XMP. Con i soli parametri necessari: JCLNPF5 WRK(TST) RUN(*EXEC) Anche con i parametri di default: JCLNPF5 WRK(TST) RUN(*EXEC) REFPGM(*CPP) :EXMP. :P.Questo comando esamina i dati gia' raccolti nella libreria di work JCLNTST e copia i membri scelti in librerie parallele alle originali. Il comando genera un log di cui si riporta esempio. :XMP. > JCLNPF5 WRK(TST) RUN(*EXEC) ->Run *EXEC Cancellazioni ->Elabora cancellazione membri scelti tramite WorkLib JCLNTST ->Legge elenco membri da cancellare. WorkLib: JCLNTST Lib datrice NERONITST. Lib ricevente NERONITST§. ->Lib:NERONITST Obj:512 ToMov:485 InOri:0 InSav:0 NoSav:0 Err:0 Chg:0 Dlt:482 ->Esaminato elenco membri da cancellare. WorkLib: JCLNTST ->Obj:512 ToMov:485 InOri:0 InSav:0 NoSav:0 Err:0 Chg:0 Dlt:482 ->Run *EXEC. Cancellazioni eseguite: esamina i messaggi. > /**/DSPPFM FILE(JCLNTST/JLOGJCLNPF) :EXMP. :P.Si osservino i messaggi informativi e i comandi promemoria duplicabili per indagare o per eseguire i passi successivi della procedura. .*------------------ :EHELP. .*------------------------------------------------------------------------------ :HELP NAME='CMD/ERROR/MESSAGES'. .*------------------ :XH3.Messaggi informativi e di completamento :P.:HP3.Messaggi *INFO e *COMP:EHP3. :DL COMPACT. :DT.JCL0501 :DD.&MSG(JCL0501,JCLNPF,*LIBL,nosub). :DT.JCL0502 :DD.&MSG(JCL0502,JCLNPF,*LIBL,nosub). :DT.JCL0521 :DD.&MSG(JCL0521,JCLNPF,*LIBL,nosub). :DT.JCL0522 :DD.&MSG(JCL0522,JCLNPF,*LIBL,nosub). :DT.JCL0524 :DD.&MSG(JCL0524,JCLNPF,*LIBL,nosub). :DT.JCL0503 :DD.&MSG(JCL0503,JCLNPF,*LIBL,nosub). :DT.JCL0505 :DD.&MSG(JCL0505,JCLNPF,*LIBL,nosub). :DT.JCL0510 :DD.&MSG(JCL0510,JCLNPF,*LIBL,nosub). :DT.JCL0513 :DD.&MSG(JCL0513,JCLNPF,*LIBL,nosub). :DT.JCL0514 :DD.&MSG(JCL0514,JCLNPF,*LIBL,nosub). :EDL. .*------------------ :XH3.Messaggi di errore :P.:HP3.Messaggi *DIAG seguiti da *ESCAPE CPF0001:EHP3. :DL COMPACT. :DT.JCL0002 :DD.&MSG(JCL0002,JCLNPF,*LIBL,nosub). :EDL. .*------------------ :EHELP. .*------------------------------------------------------------------------------ :EPNLGRP. //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF8) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 21-10-2015 Creato. */ /* Cleanings. Physical. DupMbr. Cmd */ /* Pulizie. Fisici. Duplica Membro. Comando */ /* */ CMD PROMPT('Duplicate Member') PARM KWD(FROMLIB) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('From Library') PARM KWD(FILE) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('File') PARM KWD(MEMBER) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('Member') PARM KWD(TOLIB) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('To Library') PARM KWD(RTNMSGID) TYPE(*CHAR) LEN(7) + RTNVAL(*YES) MIN(1) PROMPT('Return + Message Id Var 7') PARM KWD(RTNMSGDTA) TYPE(*CHAR) LEN(256) + RTNVAL(*YES) MIN(1) PROMPT('Return + Message Data Var 256') PARM KWD(RTNERR) TYPE(*LGL) RTNVAL(*YES) MIN(1) + PROMPT('Return Error Flag Var Lgl') PARM KWD(RTNEXIST) TYPE(*LGL) RTNVAL(*YES) MIN(1) + PROMPT('Return Already Exist Var Lgl') PARM KWD(RTNDUP) TYPE(*LGL) RTNVAL(*YES) MIN(1) + PROMPT('Return Duplication Var Lgl') PARM KWD(REFPGM) TYPE(*NAME) LEN(10) DFT(*CPP) + SPCVAL((*CPP)) PROMPT('Reference program + for messages') //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF8C) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 21-10-2015 Creato. */ /* Cleanings. Physical. DupMbr. Cpp */ /* Pulizie. Fisici. Duplica Membri. Cpp */ /* Duplica un singolo membro dalla libreria datrice */ /* alla libreria ricevente tramite salvataggio e ripristino. */ /* Claudio Neroni 21-02-2016 Modificato. */ /* Isolato il comando RSTOBJ nel nuovo comando JRSTF. */ /* */ PGM PARM(&FROMLIB &FILE &MEMBER &TOLIB &RTNMSGID + &RTNMSGDTA &RTNERR &RTNEXIST &RTNDUP &REFPGM) /* Riceve From Library. */ DCL VAR(&FROMLIB) TYPE(*CHAR) LEN(10) /* Riceve File. */ DCL VAR(&FILE) TYPE(*CHAR) LEN(10) /* Riceve Member. */ DCL VAR(&MEMBER) TYPE(*CHAR) LEN(10) /* Riceve To Library. */ DCL VAR(&TOLIB) TYPE(*CHAR) LEN(10) /* Riceve richiesta messaggio. */ /* Ritorna Messaggio. */ DCL VAR(&RTNMSGID) TYPE(*CHAR) LEN(7) DCL VAR(&RTNMSGDTA) TYPE(*CHAR) LEN(256) /* Ritorna Flag di errore. */ DCL VAR(&RTNERR) TYPE(*LGL) /* Ritorna Flag esiste gia' ricevente. */ DCL VAR(&RTNEXIST) TYPE(*LGL) /* Ritorna Flag eseguita duplicazione. */ DCL VAR(&RTNDUP) TYPE(*LGL) /* Riceve Programma di riferimento per i messaggi. */ DCL VAR(&REFPGM) TYPE(*CHAR) LEN(10) /* Conserva richiesta messaggio. */ DCL VAR(&RQSMSG) TYPE(*CHAR) LEN(7) /* Nome del file di salvataggio di comodo in libreria temporanea. */ DCL VAR(&SAVF) TYPE(*CHAR) LEN(10) + VALUE(JCLNPFSAV) /* Intercetta gli errori imprevisti. */ MONMSG MSGID(CPF0000 MCH0000 CEE0000) EXEC(GOTO + CMDLBL(ERRORE)) /* Se richiesto *CPP (Command Processing Program) come programma */ /* di riferimento dei messaggi, assume il nome del programma corrente. */ IF COND(&REFPGM *EQ *CPP) THEN(DO) JCALLER CALLER(&REFPGM) KINSHIP(*FATHER) ENDDO /* Se richiesto messaggio finale dalla versione interattiva del comando, */ /* conserva richiesta messaggio. */ CHGVAR VAR(&RQSMSG) VALUE(&RTNMSGID) /* Pulisce i parametri di ritorno. */ CHGVAR VAR(&RTNMSGID) VALUE(' ') CHGVAR VAR(&RTNMSGDTA) VALUE(' ') CHGVAR VAR(&RTNERR) VALUE('0') /* Assume che il ricevente non esista. */ CHGVAR VAR(&RTNEXIST) VALUE('0') /* Assume non eseguita duplicazione. */ CHGVAR VAR(&RTNDUP) VALUE('0') /* Controlla l'esistenza del membro datore. */ CHKOBJ OBJ(&FROMLIB/&FILE) OBJTYPE(*FILE) MBR(&MEMBER) /* Controlla l'esistenza della libreria ricevente. */ CHKOBJ OBJ(&TOLIB) OBJTYPE(*LIB) /* Controlla l'esistenza del membro ricevente. */ CHKOBJ OBJ(&TOLIB/&FILE) OBJTYPE(*FILE) MBR(&MEMBER) /* Se non esiste il ricevente, passa oltre. */ MONMSG MSGID(CPF0000) EXEC(GOTO CMDLBL(OLTRE)) /* Informa il chiamante che esiste gia' il ricevente. */ CHGVAR VAR(&RTNEXIST) VALUE('1') /* Abbandona senza segnalare. */ RETURN OLTRE: /* Pulisce il file di salvataggio temporaneo. */ CLRSAVF FILE(QTEMP/&SAVF) /* Se il file di salvataggio non esiste, lo crea. */ MONMSG MSGID(CPF0000) EXEC(DO) CRTSAVF FILE(QTEMP/&SAVF) TEXT('Per duplicazione + file e membri.') ENDDO /* Salva il membro. */ SAVOBJ OBJ(&FILE) LIB(&FROMLIB) DEV(*SAVF) + OBJTYPE(*FILE) SAVF(QTEMP/&SAVF) + TGTRLS(*CURRENT) UPDHST(*NO) + FILEMBR((*ALL (&MEMBER))) /* Ripristina il membro. */ /*********** RSTOBJ OBJ(&FILE) SAVLIB(&FROMLIB) DEV(*SAVF) + OBJTYPE(*FILE) SAVF(QTEMP/&SAVF) + FILEMBR((*ALL (&MEMBER))) MBROPT(*ALL) + RSTLIB(&TOLIB) /**/ JRSTF MEMBER(&MEMBER) FILE(&FILE) + FROMLIB(&FROMLIB) TOLIB(&TOLIB) SAVF(&SAVF) /* Annota eseguita duplicazione. */ CHGVAR VAR(&RTNDUP) VALUE('1') /* Label di esecuzione delle attivita' finali. */ RCLRSC: /* Se richiesto dalla versione interattiva del comando, messaggia. */ IF COND((&RQSMSG *EQ *MSG) *AND &RTNERR) THEN(DO) JRSNMSG MONMSG MSGID(CPF0000 MCH0000) ENDDO IF COND((&RQSMSG *EQ *MSG) *AND (&RTNMSGID *NE + ' ')) THEN(DO) SNDPGMMSG MSGID(&RTNMSGID) MSGF(JCLNPF) + MSGDTA(&RTNMSGDTA) MSGTYPE(*INFO) MONMSG MSGID(CPF0000 MCH0000) ENDDO /* Dealloca ... */ /* Riacquisisce le risorse. */ RCLRSC MONMSG MSGID(CPF0000 MCH0000) /* Ritorna. */ RETURN /* Label di errore. */ ERRORE: /* Se manca identificazione errore, assume "Errore imprevisto". */ IF COND(&RTNMSGID *EQ ' ') THEN(DO) CHGVAR VAR(&RTNMSGID) VALUE(JCL0810) CHGVAR VAR(&RTNMSGDTA) VALUE(&FROMLIB *CAT &FILE + *CAT &MEMBER *CAT &TOLIB) ENDDO CHGVAR VAR(&RTNERR) VALUE('1') GOTO CMDLBL(RCLRSC) ENDPGM //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF8I) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 21-10-2015 Creato. */ /* Cleanings. Physical. DupMbr. CmdInteract */ /* Pulizie. Fisici. Duplica Membro. Comando Interattivo */ /* */ CMD PROMPT('Duplicate Member Inter') PARM KWD(FROMLIB) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('From Library') PARM KWD(FILE) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('File') PARM KWD(MEMBER) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('Member') PARM KWD(TOLIB) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('To Library') PARM KWD(RTNMSGID) TYPE(*CHAR) LEN(7) CONSTANT(*MSG) PARM KWD(RTNMSGDTA) TYPE(*CHAR) LEN(256) CONSTANT(' ') PARM KWD(RTNERR) TYPE(*LGL) CONSTANT('0') PARM KWD(RTNEXIST) TYPE(*LGL) CONSTANT('0') PARM KWD(RTNDUP) TYPE(*LGL) CONSTANT('0') PARM KWD(REFPGM) TYPE(*NAME) LEN(10) DFT(*CPP) + SPCVAL((*CPP)) PROMPT('Reference program + for messages') //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF8X) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 04-11-2015 Creato. */ /* Cleanings. Physical. DltMbr. Cmd */ /* Pulizie. Fisici. Cancella Membro. Comando */ /* */ CMD PROMPT('Delete Member') PARM KWD(FROMLIB) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('From Library') PARM KWD(FILE) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('File') PARM KWD(MEMBER) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('Member') PARM KWD(TOLIB) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('To Library') PARM KWD(RTNMSGID) TYPE(*CHAR) LEN(7) + RTNVAL(*YES) MIN(1) PROMPT('Return + Message Id Var 7') PARM KWD(RTNMSGDTA) TYPE(*CHAR) LEN(256) + RTNVAL(*YES) MIN(1) PROMPT('Return + Message Data Var 256') PARM KWD(RTNERR) TYPE(*LGL) RTNVAL(*YES) MIN(1) + PROMPT('Return Error Flag Var Lgl') PARM KWD(RTNEXIFROM) TYPE(*LGL) RTNVAL(*YES) + MIN(1) PROMPT('Return Exist From Mbr Var + Lgl') PARM KWD(RTNEXITO) TYPE(*LGL) RTNVAL(*YES) MIN(1) + PROMPT('Return Exist To Mbr Var Lgl') PARM KWD(RTNNEQRCD) TYPE(*LGL) RTNVAL(*YES) + MIN(1) PROMPT('Return Not Eq Records Var + Lgl') PARM KWD(RTNDLT) TYPE(*LGL) RTNVAL(*YES) MIN(1) + PROMPT('Return Deletion Var Lgl') PARM KWD(RUN) TYPE(*CHAR) LEN(10) RSTD(*YES) + DFT(*DIAG) VALUES(*DIAG *EXEC) + PROMPT('Diagnostic/executive run') PARM KWD(REFPGM) TYPE(*NAME) LEN(10) DFT(*CPP) + SPCVAL((*CPP)) PROMPT('Reference program + for messages') //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF8XC) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 21-10-2015 Creato. */ /* Cleanings. Physical. DltMbr. Cpp */ /* Pulizie. Fisici. Cancella Membro. Cpp */ /* Cancella un singolo membro dalla libreria datrice. */ /* */ PGM PARM(&FROMLIB &FILE &MEMBER &TOLIB &RTNMSGID + &RTNMSGDTA &RTNERR &RTNEXIFROM &RTNEXITO + &RTNNEQ &RTNDLT &RUN &REFPGM) /* Riceve From Library. */ DCL VAR(&FROMLIB) TYPE(*CHAR) LEN(10) /* Riceve File. */ DCL VAR(&FILE) TYPE(*CHAR) LEN(10) /* Riceve Member. */ DCL VAR(&MEMBER) TYPE(*CHAR) LEN(10) /* Riceve To Library. */ DCL VAR(&TOLIB) TYPE(*CHAR) LEN(10) /* Riceve richiesta messaggio. */ /* Ritorna Messaggio. */ DCL VAR(&RTNMSGID) TYPE(*CHAR) LEN(7) DCL VAR(&RTNMSGDTA) TYPE(*CHAR) LEN(256) /* Ritorna Flag di errore. */ DCL VAR(&RTNERR) TYPE(*LGL) DCL VAR(&RTNERRC) TYPE(*CHAR) LEN(1) /* Ritorna Flag esiste datore. */ DCL VAR(&RTNEXIFROM) TYPE(*LGL) DCL VAR(&RTNEXIFROC) TYPE(*CHAR) LEN(1) /* Ritorna Flag esiste ricevente. */ DCL VAR(&RTNEXITO) TYPE(*LGL) DCL VAR(&RTNEXITOC) TYPE(*CHAR) LEN(1) /* Ritorna Flag non eguale numero records. */ DCL VAR(&RTNNEQ) TYPE(*LGL) DCL VAR(&RTNNEQC) TYPE(*CHAR) LEN(1) /* Ritorna Flag cancellato datore. */ DCL VAR(&RTNDLT) TYPE(*LGL) DCL VAR(&RTNDLTC) TYPE(*CHAR) LEN(1) /* Riceve Run Type: diagnostic or executive. */ /* *DIAG = Diagnostica prima di eseguire. */ /* *EXEC = Esegue */ DCL VAR(&RUN) TYPE(*CHAR) LEN(10) /* Riceve Programma di riferimento per i messaggi. */ DCL VAR(&REFPGM) TYPE(*CHAR) LEN(10) /* Conserva richiesta messaggio. */ DCL VAR(&RQSMSG) TYPE(*CHAR) LEN(7) /* Caratteristiche del membro datore. */ DCL VAR(&FILEAT1) TYPE(*CHAR) LEN(3) DCL VAR(&FILETYP1) TYPE(*CHAR) LEN(5) DCL VAR(&SRCCHGDAT1) TYPE(*CHAR) LEN(13) DCL VAR(&CRTDAT1) TYPE(*CHAR) LEN(13) DCL VAR(&NBRCURRC1) TYPE(*DEC) LEN(10 0) DCL VAR(&NBRDLTRC1) TYPE(*DEC) LEN(10 0) DCL VAR(&CHGDAT1) TYPE(*CHAR) LEN(13) /* Caratteristiche del membro ricevente. */ DCL VAR(&FILEAT2) TYPE(*CHAR) LEN(3) DCL VAR(&FILETYP2) TYPE(*CHAR) LEN(5) DCL VAR(&SRCCHGDAT2) TYPE(*CHAR) LEN(13) DCL VAR(&CRTDAT2) TYPE(*CHAR) LEN(13) DCL VAR(&NBRCURRC2) TYPE(*DEC) LEN(10 0) DCL VAR(&NBRDLTRC2) TYPE(*DEC) LEN(10 0) DCL VAR(&CHGDAT2) TYPE(*CHAR) LEN(13) /* Numero corrente di membri nel file datore dopo la rimozione di un membro. */ DCL VAR(&MBRSNBR) TYPE(*DEC) LEN(5 0) /* Nome del file restituito dal Retrieve File Description. */ DCL VAR(&RTNFILE) TYPE(*CHAR) LEN(10) /* Intercetta gli errori imprevisti. */ MONMSG MSGID(CPF0000 MCH0000 CEE0000) EXEC(GOTO + CMDLBL(ERRORE)) /* Se richiesto *CPP (Command Processing Program) come programma */ /* di riferimento dei messaggi, assume il nome del programma corrente. */ IF COND(&REFPGM *EQ *CPP) THEN(DO) JCALLER CALLER(&REFPGM) KINSHIP(*FATHER) ENDDO /* Se richiesto messaggio finale dalla versione interattiva del comando, */ /* conserva richiesta messaggio. */ CHGVAR VAR(&RQSMSG) VALUE(&RTNMSGID) /* Pulisce il messaggio di ritorno. */ CHGVAR VAR(&RTNMSGID) VALUE(' ') CHGVAR VAR(&RTNMSGDTA) VALUE(' ') /* Assume nessun errore. */ CHGVAR VAR(&RTNERR) VALUE('0') /* Assume che il datore non esista. */ CHGVAR VAR(&RTNEXIFROM) VALUE('0') /* Assume che il ricevente non esista. */ CHGVAR VAR(&RTNEXITO) VALUE('0') /* Assume non eseguita cancellazione. */ CHGVAR VAR(&RTNDLT) VALUE('0') /* Controlla l'esistenza del membro datore. */ DOUNTIL COND(1 = 1) /* Controlla l'esistenza della libreria datrice. */ CHKOBJ OBJ(&FROMLIB) OBJTYPE(*LIB) /* Controlla l'esistenza del membro datore. */ CHKOBJ OBJ(&FROMLIB/&FILE) OBJTYPE(*FILE) MBR(&MEMBER) /* Se non esiste il membro datore, abbandona. */ MONMSG MSGID(CPF0000) EXEC(LEAVE) /* Annota che esiste il membro datore. */ CHGVAR VAR(&RTNEXIFROM) VALUE('1') /* Recupera le caratteristiche del membro datore. */ RTVMBRD FILE(&FROMLIB/&FILE) MBR(&MEMBER) + FILEATR(&FILEAT1) FILETYPE(&FILETYP1) + SRCCHGDATE(&SRCCHGDAT1) CRTDATE(&CRTDAT1) + NBRCURRCD(&NBRCURRC1) + NBRDLTRCD(&NBRDLTRC1) CHGDATE(&CHGDAT1) /* Controlla l'esistenza del membro datore. */ ENDDO /* Controlla l'esistenza del membro ricevente. */ DOUNTIL COND(1 = 1) /* Controlla l'esistenza della libreria ricevente. */ CHKOBJ OBJ(&TOLIB) OBJTYPE(*LIB) /* Controlla l'esistenza del membro ricevente. */ CHKOBJ OBJ(&TOLIB/&FILE) OBJTYPE(*FILE) MBR(&MEMBER) /* Se non esiste il membro ricevente, abbandona. */ MONMSG MSGID(CPF0000) EXEC(LEAVE) /* Annota che esiste il membro ricevente. */ CHGVAR VAR(&RTNEXITO) VALUE('1') /* Recupera le caratteristiche del membro ricevente. */ RTVMBRD FILE(&TOLIB/&FILE) MBR(&MEMBER) + FILEATR(&FILEAT2) FILETYPE(&FILETYP2) + SRCCHGDATE(&SRCCHGDAT2) CRTDATE(&CRTDAT2) + NBRCURRCD(&NBRCURRC2) + NBRDLTRCD(&NBRDLTRC2) CHGDATE(&CHGDAT2) /* Controlla l'esistenza del membro ricevente. */ ENDDO /* Controlla la corrispondenza delle caratteristiche tra datore e ricevente. */ /* Considera solo le caratteristiche che si trasferiscono con il save-restore.*/ DOUNTIL COND(1 = 1) /* Assume caratteristiche uguali. */ CHGVAR VAR(&RTNNEQ) VALUE('0') /* Se esistono entrambi i membri. */ IF COND(&RTNEXIFROM *AND &RTNEXITO) THEN(DO) /* Se almeno una delle caratteristiche č diversa. */ IF COND((&FILEAT1 *NE &FILEAT2) *OR (&FILETYP1 + *NE &FILETYP2) *OR (&SRCCHGDAT1 *NE + &SRCCHGDAT2) *OR (&CRTDAT1 *NE &CRTDAT2) + *OR (&NBRCURRC1 *NE &NBRCURRC2) *OR + (&NBRDLTRC1 *NE &NBRDLTRC2)) THEN(DO) /* Annota caratteristiche diverse. */ CHGVAR VAR(&RTNNEQ) VALUE('1') /* Se almeno una delle caratteristiche č diversa. */ ENDDO /* Se esistono entrambi i membri. */ ENDDO /* Controlla la corrispondenza delle caratteristiche tra datore e ricevente. */ ENDDO /* Se corre esecuzione e se esiste il membro ricevente. */ IF COND((&RUN *EQ *EXEC) *AND &RTNEXITO) THEN(DO) /* Cancella il membro datore. */ RMVM FILE(&FROMLIB/&FILE) MBR(&MEMBER) /* Annota eseguita cancellazione. */ CHGVAR VAR(&RTNDLT) VALUE('1') /* Controlla il residuo numero membri nel file del membro datore. */ JRTVFD FILE(&FILE) LIB(&FROMLIB) RTNFILE(&RTNFILE) + MBRSNBR(&MBRSNBR) /* Se il file datore esiste ed e' rimasto senza membri, lo cancella. */ IF COND((&RTNFILE *EQ &FILE) *AND (&MBRSNBR *EQ + 0)) THEN(DO) DLTF FILE(&FROMLIB/&FILE) MONMSG MSGID(CPF0000 MCH0000) ENDDO /* Se corre esecuzione e se esiste il membro ricevente. */ ENDDO /* Label di esecuzione delle attivita' finali. */ RCLRSC: /* Se richiesto dalla versione interattiva del comando, */ /* e se non ancora richiesto messaggio, messaggia. */ IF COND((&RQSMSG *EQ *MSG) *AND (&RTNMSGID *EQ + ' ')) THEN(DO) /* Assegna identificazione messaggio. */ CHGVAR VAR(&RTNMSGID) VALUE(JCL0821) /* Trasforma variabili logiche in variabili carattere. */ IF COND(&RTNERR) THEN(CHGVAR VAR(&RTNERRC) + VALUE('1')) ELSE CMD(CHGVAR VAR(&RTNERRC) VALUE('0')) IF COND(&RTNEXIFROM) THEN(CHGVAR + VAR(&RTNEXIFROC) VALUE('1')) ELSE CMD(CHGVAR VAR(&RTNEXIFROC) VALUE('0')) IF COND(&RTNEXITO) THEN(CHGVAR VAR(&RTNEXITOC) + VALUE('1')) ELSE CMD(CHGVAR VAR(&RTNEXITOC) VALUE('0')) IF COND(&RTNNEQ) THEN(CHGVAR VAR(&RTNNEQC) + VALUE('1')) ELSE CMD(CHGVAR VAR(&RTNNEQC) VALUE('0')) IF COND(&RTNDLT) THEN(CHGVAR VAR(&RTNDLTC) + VALUE('1')) ELSE CMD(CHGVAR VAR(&RTNDLTC) VALUE('0')) /* Compone dati messaggio. */ CHGVAR VAR(&RTNMSGDTA) VALUE(&FROMLIB *CAT &FILE + *CAT &MEMBER *CAT &TOLIB *CAT &RTNERRC + *CAT &RTNEXIFROC *CAT &RTNEXITOC *CAT + &RTNNEQC *CAT &RTNDLTC) /* Invia messaggio. */ SNDPGMMSG MSGID(&RTNMSGID) MSGF(JCLNPF) + MSGDTA(&RTNMSGDTA) MSGTYPE(*INFO) MONMSG MSGID(CPF0000 MCH0000) /* Se richiesto dalla versione interattiva del comando, */ /* e se non ancora richiesto messaggio, messaggia. */ ENDDO /* Dealloca ... */ /* Riacquisisce le risorse. */ RCLRSC MONMSG MSGID(CPF0000 MCH0000) /* Ritorna. */ RETURN /* Label di errore. */ ERRORE: /* Se manca identificazione errore, assume "Errore imprevisto". */ IF COND(&RTNMSGID *EQ ' ') THEN(DO) CHGVAR VAR(&RTNMSGID) VALUE(JCL0820) CHGVAR VAR(&RTNMSGDTA) VALUE(&FROMLIB *CAT &FILE + *CAT &MEMBER *CAT &TOLIB) ENDDO CHGVAR VAR(&RTNERR) VALUE('1') GOTO CMDLBL(RCLRSC) ENDPGM //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF8XI) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 04-11-2015 Creato. */ /* Cleanings. Physical. DltMbr. CmdInteract */ /* Pulizie. Fisici. Cancella Membro. Comando Interattivo */ /* */ CMD PROMPT('Delete Member Inter') PARM KWD(FROMLIB) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('From Library') PARM KWD(FILE) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('File') PARM KWD(MEMBER) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('Member') PARM KWD(TOLIB) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('To Library') PARM KWD(RTNMSGID) TYPE(*CHAR) LEN(7) CONSTANT(*MSG) PARM KWD(RTNMSGDTA) TYPE(*CHAR) LEN(256) CONSTANT(' ') PARM KWD(RTNERR) TYPE(*LGL) CONSTANT('0') PARM KWD(RTNEXIFROM) TYPE(*LGL) CONSTANT('0') PARM KWD(RTNEXITO) TYPE(*LGL) CONSTANT('0') PARM KWD(RTNNEQRCD) TYPE(*LGL) CONSTANT('0') PARM KWD(RTNDLT) TYPE(*LGL) CONSTANT('0') PARM KWD(RUN) TYPE(*CHAR) LEN(10) RSTD(*YES) + DFT(*DIAG) VALUES(*DIAG *EXEC) + PROMPT('Diagnostic/executive run') PARM KWD(REFPGM) TYPE(*NAME) LEN(10) DFT(*CPP) + SPCVAL((*CPP)) PROMPT('Reference program + for messages') //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF9) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 22-10-2015 Creato. */ /* Cleanings. Physical. DupFile. Cmd */ /* Pulizie. Fisici. Duplica File. Comando */ /* */ CMD PROMPT('Duplicate File') PARM KWD(FROMLIB) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('From Library') PARM KWD(FILE) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('File') PARM KWD(TOLIB) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('To Library') PARM KWD(RTNMSGID) TYPE(*CHAR) LEN(7) + RTNVAL(*YES) MIN(1) PROMPT('Return + Message Id Var 7') PARM KWD(RTNMSGDTA) TYPE(*CHAR) LEN(256) + RTNVAL(*YES) MIN(1) PROMPT('Return + Message Data Var 256') PARM KWD(RTNERR) TYPE(*LGL) RTNVAL(*YES) MIN(1) + PROMPT('Return Error Flag Var Lgl') PARM KWD(RTNEXIST) TYPE(*LGL) RTNVAL(*YES) MIN(1) + PROMPT('Return Already Exist Var Lgl') PARM KWD(RTNDUP) TYPE(*LGL) RTNVAL(*YES) MIN(1) + PROMPT('Return Duplication Var Lgl') PARM KWD(REFPGM) TYPE(*NAME) LEN(10) DFT(*CPP) + SPCVAL((*CPP)) PROMPT('Reference program + for messages') //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF9C) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 22-10-2015 Creato. */ /* Cleanings. Physical. DupFile. Cpp */ /* Pulizie. Fisici. Duplica File. Cpp */ /* Duplica un singolo file dalla libreria datrice */ /* alla libreria ricevente tramite salvataggio e ripristino. */ /* Claudio Neroni 21-02-2016 Modificato. */ /* Isolato il comando RSTOBJ nel nuovo comando JRSTF. */ /* */ PGM PARM(&FROMLIB &FILE &TOLIB &RTNMSGID + &RTNMSGDTA &RTNERR &RTNEXIST &RTNDUP &REFPGM) /* Riceve From Library. */ DCL VAR(&FROMLIB) TYPE(*CHAR) LEN(10) /* Riceve File. */ DCL VAR(&FILE) TYPE(*CHAR) LEN(10) /* Riceve To Library. */ DCL VAR(&TOLIB) TYPE(*CHAR) LEN(10) /* Riceve richiesta messaggio. */ /* Ritorna Messaggio. */ DCL VAR(&RTNMSGID) TYPE(*CHAR) LEN(7) DCL VAR(&RTNMSGDTA) TYPE(*CHAR) LEN(256) /* Ritorna Flag di errore. */ DCL VAR(&RTNERR) TYPE(*LGL) /* Ritorna Flag esiste gia' ricevente. */ DCL VAR(&RTNEXIST) TYPE(*LGL) /* Ritorna Flag eseguita duplicazione. */ DCL VAR(&RTNDUP) TYPE(*LGL) /* Riceve Programma di riferimento per i messaggi. */ DCL VAR(&REFPGM) TYPE(*CHAR) LEN(10) /* Conserva richiesta messaggio. */ DCL VAR(&RQSMSG) TYPE(*CHAR) LEN(7) /* Nome del file di salvataggio di comodo in libreria temporanea. */ DCL VAR(&SAVF) TYPE(*CHAR) LEN(10) + VALUE(JCLNPFSAVF) /* Intercetta gli errori imprevisti. */ MONMSG MSGID(CPF0000 MCH0000 CEE0000) EXEC(GOTO + CMDLBL(ERRORE)) /* Se richiesto *CPP (Command Processing Program) come programma */ /* di riferimento dei messaggi, assume il nome del programma corrente. */ IF COND(&REFPGM *EQ *CPP) THEN(DO) JCALLER CALLER(&REFPGM) KINSHIP(*FATHER) ENDDO /* Se richiesto messaggio finale dalla versione interattiva del comando, */ /* conserva richiesta messaggio. */ CHGVAR VAR(&RQSMSG) VALUE(&RTNMSGID) /* Pulisce i parametri di ritorno. */ CHGVAR VAR(&RTNMSGID) VALUE(' ') CHGVAR VAR(&RTNMSGDTA) VALUE(' ') CHGVAR VAR(&RTNERR) VALUE('0') /* Assume che il ricevente non esista. */ CHGVAR VAR(&RTNEXIST) VALUE('0') /* Assume non eseguita duplicazione. */ CHGVAR VAR(&RTNDUP) VALUE('0') /* Controlla l'esistenza del file datore. */ CHKOBJ OBJ(&FROMLIB/&FILE) OBJTYPE(*FILE) /* Controlla l'esistenza della libreria ricevente. */ CHKOBJ OBJ(&TOLIB) OBJTYPE(*LIB) /* Controlla l'esistenza del file ricevente. */ CHKOBJ OBJ(&TOLIB/&FILE) OBJTYPE(*FILE) /* Se non esiste il ricevente, passa oltre. */ MONMSG MSGID(CPF0000) EXEC(GOTO CMDLBL(OLTRE)) /* Informa il chiamante che esiste gia' il ricevente. */ CHGVAR VAR(&RTNEXIST) VALUE('1') /* Abbandona senza segnalare. */ RETURN OLTRE: /* Pulisce il file di salvataggio temporaneo. */ CLRSAVF FILE(QTEMP/&SAVF) /* Se il file di salvataggio non esiste, lo crea. */ MONMSG MSGID(CPF0000) EXEC(DO) CRTSAVF FILE(QTEMP/&SAVF) TEXT('Per duplicazione + file e membri.') ENDDO /* Salva il file. */ SAVOBJ OBJ(&FILE) LIB(&FROMLIB) DEV(*SAVF) + OBJTYPE(*FILE) SAVF(QTEMP/&SAVF) + TGTRLS(*CURRENT) UPDHST(*NO) /* Ripristina il file. */ /*********** RSTOBJ OBJ(&FILE) SAVLIB(&FROMLIB) DEV(*SAVF) + OBJTYPE(*FILE) SAVF(QTEMP/&SAVF) + FILEMBR((*ALL *ALL)) MBROPT(*ALL) + RSTLIB(&TOLIB) /**/ JRSTF MEMBER(*ALL) FILE(&FILE) FROMLIB(&FROMLIB) + TOLIB(&TOLIB) SAVF(&SAVF) /* Annota eseguita duplicazione. */ CHGVAR VAR(&RTNDUP) VALUE('1') /* Label di esecuzione delle attivita' finali. */ RCLRSC: /* Se richiesto dalla versione interattiva del comando, messaggia. */ IF COND((&RQSMSG *EQ *MSG) *AND &RTNERR) THEN(DO) JRSNMSG MONMSG MSGID(CPF0000 MCH0000) ENDDO IF COND((&RQSMSG *EQ *MSG) *AND (&RTNMSGID *NE + ' ')) THEN(DO) SNDPGMMSG MSGID(&RTNMSGID) MSGF(JCLNPF) + MSGDTA(&RTNMSGDTA) MSGTYPE(*INFO) MONMSG MSGID(CPF0000 MCH0000) ENDDO /* Dealloca ... */ /* Riacquisisce le risorse. */ RCLRSC MONMSG MSGID(CPF0000 MCH0000) /* Ritorna. */ RETURN /* Label di errore. */ ERRORE: /* Se manca identificazione errore, assume "Errore imprevisto". */ IF COND(&RTNMSGID *EQ ' ') THEN(DO) CHGVAR VAR(&RTNMSGID) VALUE(JCL0910) CHGVAR VAR(&RTNMSGDTA) VALUE(&FROMLIB *CAT &FILE + *CAT &TOLIB) ENDDO CHGVAR VAR(&RTNERR) VALUE('1') GOTO CMDLBL(RCLRSC) ENDPGM //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF9I) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 21-10-2015 Creato. */ /* Cleanings. Physical. DupMbr. CmdInteract */ /* Pulizie. Fisici. Duplica Membro. Comando Interattivo */ /* */ CMD PROMPT('Duplicate Member Inter') PARM KWD(FROMLIB) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('From Library') PARM KWD(FILE) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('File') PARM KWD(TOLIB) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('To Library') PARM KWD(RTNMSGID) TYPE(*CHAR) LEN(7) CONSTANT(*MSG) PARM KWD(RTNMSGDTA) TYPE(*CHAR) LEN(256) CONSTANT(' ') PARM KWD(RTNERR) TYPE(*LGL) CONSTANT('0') PARM KWD(RTNEXIST) TYPE(*LGL) CONSTANT('0') PARM KWD(RTNDUP) TYPE(*LGL) CONSTANT('0') PARM KWD(REFPGM) TYPE(*NAME) LEN(10) DFT(*CPP) + SPCVAL((*CPP)) PROMPT('Reference program + for messages') //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF9X) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 09-12-2015 Creato. */ /* Cleanings. Physical. DltFile. Cmd */ /* Pulizie. Fisici. Cancella File. Comando */ /* */ CMD PROMPT('Delete File') PARM KWD(FROMLIB) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('From Library') PARM KWD(FILE) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('File') PARM KWD(TOLIB) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('To Library') PARM KWD(RTNMSGID) TYPE(*CHAR) LEN(7) + RTNVAL(*YES) MIN(1) PROMPT('Return + Message Id Var 7') PARM KWD(RTNMSGDTA) TYPE(*CHAR) LEN(256) + RTNVAL(*YES) MIN(1) PROMPT('Return + Message Data Var 256') PARM KWD(RTNERR) TYPE(*LGL) RTNVAL(*YES) MIN(1) + PROMPT('Return Error Flag Var Lgl') PARM KWD(RTNEXIFROM) TYPE(*LGL) RTNVAL(*YES) + MIN(1) PROMPT('Return Exist From File Var + Lgl') PARM KWD(RTNEXITO) TYPE(*LGL) RTNVAL(*YES) MIN(1) + PROMPT('Return Exist To File Var Lgl') PARM KWD(RTNNEQRCD) TYPE(*LGL) RTNVAL(*YES) + MIN(1) PROMPT('Return Not Eq Records Var + Lgl') PARM KWD(RTNDLT) TYPE(*LGL) RTNVAL(*YES) MIN(1) + PROMPT('Return Deletion Var Lgl') PARM KWD(RUN) TYPE(*CHAR) LEN(10) RSTD(*YES) + DFT(*DIAG) VALUES(*DIAG *EXEC) + PROMPT('Diagnostic/executive run') PARM KWD(REFPGM) TYPE(*NAME) LEN(10) DFT(*CPP) + SPCVAL((*CPP)) PROMPT('Reference program + for messages') //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF9XC) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 09-12-2015 Creato. */ /* Cleanings. Physical. DltFile. Cpp */ /* Pulizie. Fisici. Cancella File. Cpp */ /* Cancella un singolo file dalla libreria datrice. */ /* */ PGM PARM(&FROMLIB &FILE &TOLIB &RTNMSGID + &RTNMSGDTA &RTNERR &RTNEXIFROM &RTNEXITO + &RTNNEQ &RTNDLT &RUN &REFPGM) /* Riceve From Library. */ DCL VAR(&FROMLIB) TYPE(*CHAR) LEN(10) /* Riceve File. */ DCL VAR(&FILE) TYPE(*CHAR) LEN(10) /* Riceve To Library. */ DCL VAR(&TOLIB) TYPE(*CHAR) LEN(10) /* Riceve richiesta messaggio. */ /* Ritorna Messaggio. */ DCL VAR(&RTNMSGID) TYPE(*CHAR) LEN(7) DCL VAR(&RTNMSGDTA) TYPE(*CHAR) LEN(256) /* Ritorna Flag di errore. */ DCL VAR(&RTNERR) TYPE(*LGL) DCL VAR(&RTNERRC) TYPE(*CHAR) LEN(1) /* Ritorna Flag esiste datore. */ DCL VAR(&RTNEXIFROM) TYPE(*LGL) DCL VAR(&RTNEXIFROC) TYPE(*CHAR) LEN(1) /* Ritorna Flag esiste ricevente. */ DCL VAR(&RTNEXITO) TYPE(*LGL) DCL VAR(&RTNEXITOC) TYPE(*CHAR) LEN(1) /* Ritorna Flag non eguale numero records. */ DCL VAR(&RTNNEQ) TYPE(*LGL) DCL VAR(&RTNNEQC) TYPE(*CHAR) LEN(1) /* Ritorna Flag cancellato datore. */ DCL VAR(&RTNDLT) TYPE(*LGL) DCL VAR(&RTNDLTC) TYPE(*CHAR) LEN(1) /* Riceve Run Type: diagnostic or executive. */ /* *DIAG = Diagnostica prima di eseguire. */ /* *EXEC = Esegue */ DCL VAR(&RUN) TYPE(*CHAR) LEN(10) /* Riceve Programma di riferimento per i messaggi. */ DCL VAR(&REFPGM) TYPE(*CHAR) LEN(10) /* Conserva richiesta messaggio. */ DCL VAR(&RQSMSG) TYPE(*CHAR) LEN(7) /* Caratteristiche del file datore. */ DCL VAR(&OBJATR1) TYPE(*CHAR) LEN(10) DCL VAR(&CRTDAT1) TYPE(*CHAR) LEN(13) DCL VAR(&CHGDAT1) TYPE(*CHAR) LEN(13) /* Caratteristiche del file ricevente. */ DCL VAR(&OBJATR2) TYPE(*CHAR) LEN(10) DCL VAR(&CRTDAT2) TYPE(*CHAR) LEN(13) DCL VAR(&CHGDAT2) TYPE(*CHAR) LEN(13) /* Intercetta gli errori imprevisti. */ MONMSG MSGID(CPF0000 MCH0000 CEE0000) EXEC(GOTO + CMDLBL(ERRORE)) /* Se richiesto *CPP (Command Processing Program) come programma */ /* di riferimento dei messaggi, assume il nome del programma corrente. */ IF COND(&REFPGM *EQ *CPP) THEN(DO) JCALLER CALLER(&REFPGM) KINSHIP(*FATHER) ENDDO /* Se richiesto messaggio finale dalla versione interattiva del comando, */ /* conserva richiesta messaggio. */ CHGVAR VAR(&RQSMSG) VALUE(&RTNMSGID) /* Pulisce il messaggio di ritorno. */ CHGVAR VAR(&RTNMSGID) VALUE(' ') CHGVAR VAR(&RTNMSGDTA) VALUE(' ') /* Assume nessun errore. */ CHGVAR VAR(&RTNERR) VALUE('0') /* Assume che il datore non esista. */ CHGVAR VAR(&RTNEXIFROM) VALUE('0') /* Assume che il ricevente non esista. */ CHGVAR VAR(&RTNEXITO) VALUE('0') /* Assume non eseguita cancellazione. */ CHGVAR VAR(&RTNDLT) VALUE('0') /* Controlla l'esistenza del file datore. */ DOUNTIL COND(1 = 1) /* Controlla l'esistenza della libreria datrice. */ CHKOBJ OBJ(&FROMLIB) OBJTYPE(*LIB) /* Controlla l'esistenza del file datore. */ CHKOBJ OBJ(&FROMLIB/&FILE) OBJTYPE(*FILE) /* Se non esiste il file datore, abbandona. */ MONMSG MSGID(CPF0000) EXEC(LEAVE) /* Annota che esiste il file datore. */ CHGVAR VAR(&RTNEXIFROM) VALUE('1') /* Recupera le caratteristiche del file datore. */ RTVOBJD OBJ(&FROMLIB/&FILE) OBJTYPE(*FILE) + OBJATR(&OBJATR1) CRTDATE(&CRTDAT1) + CHGDATE(&CHGDAT1) /* Controlla l'esistenza del file datore. */ ENDDO /* Controlla l'esistenza del file ricevente. */ DOUNTIL COND(1 = 1) /* Controlla l'esistenza della libreria ricevente. */ CHKOBJ OBJ(&TOLIB) OBJTYPE(*LIB) /* Controlla l'esistenza del file ricevente. */ CHKOBJ OBJ(&TOLIB/&FILE) OBJTYPE(*FILE) /* Se non esiste il file ricevente, abbandona. */ MONMSG MSGID(CPF0000) EXEC(LEAVE) /* Annota che esiste il file ricevente. */ CHGVAR VAR(&RTNEXITO) VALUE('1') /* Recupera le caratteristiche del file ricevente. */ RTVOBJD OBJ(&TOLIB/&FILE) OBJTYPE(*FILE) + OBJATR(&OBJATR2) CRTDATE(&CRTDAT2) + CHGDATE(&CHGDAT2) /* Controlla l'esistenza del file ricevente. */ ENDDO /* Controlla la corrispondenza delle caratteristiche tra datore e ricevente. */ /* Considera solo le caratteristiche che si trasferiscono con il save-restore.*/ DOUNTIL COND(1 = 1) /* Assume caratteristiche uguali. */ CHGVAR VAR(&RTNNEQ) VALUE('0') /* Se esistono entrambi i file. */ IF COND(&RTNEXIFROM *AND &RTNEXITO) THEN(DO) /* Se almeno una delle caratteristiche č diversa. */ IF COND((&OBJATR1 *NE &OBJATR2) *OR (&CRTDAT1 + *NE &CRTDAT2)) THEN(DO) /* Annota caratteristiche diverse. */ CHGVAR VAR(&RTNNEQ) VALUE('1') /* Se almeno una delle caratteristiche č diversa. */ ENDDO /* Se esistono entrambi i file. */ ENDDO /* Controlla la corrispondenza delle caratteristiche tra datore e ricevente. */ ENDDO /* Se corre esecuzione e se esiste il file ricevente. */ IF COND((&RUN *EQ *EXEC) *AND &RTNEXITO) THEN(DO) /* Cancella il file datore. */ DLTF FILE(&FROMLIB/&FILE) /* Annota eseguita cancellazione. */ CHGVAR VAR(&RTNDLT) VALUE('1') /* Se corre esecuzione e se esiste il file ricevente. */ ENDDO /* Label di esecuzione delle attivita' finali. */ RCLRSC: /* Se richiesto dalla versione interattiva del comando, */ /* e se non ancora richiesto messaggio, messaggia. */ IF COND((&RQSMSG *EQ *MSG) *AND (&RTNMSGID *EQ + ' ')) THEN(DO) /* Assegna identificazione messaggio. */ CHGVAR VAR(&RTNMSGID) VALUE(JCL0921) /* Trasforma variabili logiche in variabili carattere. */ IF COND(&RTNERR) THEN(CHGVAR VAR(&RTNERRC) + VALUE('1')) ELSE CMD(CHGVAR VAR(&RTNERRC) VALUE('0')) IF COND(&RTNEXIFROM) THEN(CHGVAR + VAR(&RTNEXIFROC) VALUE('1')) ELSE CMD(CHGVAR VAR(&RTNEXIFROC) VALUE('0')) IF COND(&RTNEXITO) THEN(CHGVAR VAR(&RTNEXITOC) + VALUE('1')) ELSE CMD(CHGVAR VAR(&RTNEXITOC) VALUE('0')) IF COND(&RTNNEQ) THEN(CHGVAR VAR(&RTNNEQC) + VALUE('1')) ELSE CMD(CHGVAR VAR(&RTNNEQC) VALUE('0')) IF COND(&RTNDLT) THEN(CHGVAR VAR(&RTNDLTC) + VALUE('1')) ELSE CMD(CHGVAR VAR(&RTNDLTC) VALUE('0')) /* Compone dati messaggio. */ CHGVAR VAR(&RTNMSGDTA) VALUE(&FROMLIB *CAT &FILE + *CAT &TOLIB *CAT &RTNERRC *CAT + &RTNEXIFROC *CAT &RTNEXITOC *CAT &RTNNEQC + *CAT &RTNDLTC) /* Invia messaggio. */ SNDPGMMSG MSGID(&RTNMSGID) MSGF(JCLNPF) + MSGDTA(&RTNMSGDTA) MSGTYPE(*INFO) MONMSG MSGID(CPF0000 MCH0000) /* Se richiesto dalla versione interattiva del comando, */ /* e se non ancora richiesto messaggio, messaggia. */ ENDDO /* Dealloca ... */ /* Riacquisisce le risorse. */ RCLRSC MONMSG MSGID(CPF0000 MCH0000) /* Ritorna. */ RETURN /* Label di errore. */ ERRORE: /* Se manca identificazione errore, assume "Errore imprevisto". */ IF COND(&RTNMSGID *EQ ' ') THEN(DO) CHGVAR VAR(&RTNMSGID) VALUE(JCL0920) CHGVAR VAR(&RTNMSGDTA) VALUE(&FROMLIB *CAT &FILE + *CAT &TOLIB) ENDDO CHGVAR VAR(&RTNERR) VALUE('1') GOTO CMDLBL(RCLRSC) ENDPGM //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNPF9XI) FILETYPE(*SRC) ENDCHAR('//ENDSRC') /* Claudio Neroni 09-12-2015 Creato. */ /* Cleanings. Physical. DltFile. CmdInteract */ /* Pulizie. Fisici. Cancella File. Comando Interattivo */ /* */ CMD PROMPT('Delete File Inter') PARM KWD(FROMLIB) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('From Library') PARM KWD(FILE) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('File') PARM KWD(TOLIB) TYPE(*NAME) LEN(10) MIN(1) + PROMPT('To Library') PARM KWD(RTNMSGID) TYPE(*CHAR) LEN(7) CONSTANT(*MSG) PARM KWD(RTNMSGDTA) TYPE(*CHAR) LEN(256) CONSTANT(' ') PARM KWD(RTNERR) TYPE(*LGL) CONSTANT('0') PARM KWD(RTNEXIFROM) TYPE(*LGL) CONSTANT('0') PARM KWD(RTNEXITO) TYPE(*LGL) CONSTANT('0') PARM KWD(RTNNEQRCD) TYPE(*LGL) CONSTANT('0') PARM KWD(RTNDLT) TYPE(*LGL) CONSTANT('0') PARM KWD(RUN) TYPE(*CHAR) LEN(10) RSTD(*YES) + DFT(*DIAG) VALUES(*DIAG *EXEC) + PROMPT('Diagnostic/executive run') PARM KWD(REFPGM) TYPE(*NAME) LEN(10) DFT(*CPP) + SPCVAL((*CPP)) PROMPT('Reference program + for messages') //ENDSRC /*----------------------------------------------------------------------------*/ //DATA FILE(JCLNTSTDAT) FILETYPE(*SRC) ENDCHAR('//ENDSRC') * Claudio Neroni 02-05-2016 Creato. * Test date. * Scambia parametri. C *entry plist CN02 C parm date 7 I Date CYYMMDD C parm err 1 O Date error flag C eval err = *off C *CYMD0 TEST(D E) date C if %error C eval err = *on C endif C return //ENDSRC //ENDBCHJOB