/******************************************************************************/
/*									      */
/*	Programmer :	Hunter Goatley					      */
/*	Program	:	VIDEO_BACK.PLI					      */
/*	Language :	VAX-11 PL/1 v2.3				      */
/*	System :	VAX 11/785  VAX/VMS v4.1			      */
/*	Purpose	:	Display	ACRS VAX backup	procedures		      */
/*	Date :		30-MAY-1985					      */
/*									      */
/******************************************************************************/
/*									      */
/*	This program displays ACRS VAX backups.	 The schedule starting date   */
/*	is May 20, 1985.						      */
/*									      */
/******************************************************************************/


/******************************************************************************/
/*									      */
/*  PROCEDURE TABLE :							      */
/*									      */
/*	AUTOMATICALLY			Internal subroutine - called if	the   */
/*					user wants to display the procedure   */
/*					for the	current	day		      */
/*									      */
/*	BACKUP				Entry procedure			      */
/*									      */
/*	CLEARSCREEN			Internal subroutine - clears screen   */
/*									      */
/*	DISPLAY_BACKUP			Internal subroutine - displays the    */
/*					backup procedures for specified	days  */
/*									      */
/*	GETINFO				Internal subroutine - get user info   */
/*									      */
/*	LIB$DATE_TIME			External function - returns current   */
/*					date & time			      */
/*									      */
/*	LIB$DAY				External function - returns number of */
/*					days between given date	and system    */
/*					zero date			      */
/*									      */
/*	LIB$DAY_OF_WEEK			External function - returns integer   */
/*					day number			      */
/*									      */
/*	PRINTDISK			Internal subroutine - displays DISK   */
/*					to DISK	backup			      */
/*									      */
/*	PRINTTAPE			Internal subroutine - displays DISK   */
/*					to TAPE	backup			      */
/*									      */
/*	SELECTIVELY			Internal subroutine - gets specific   */
/*					day from user			      */
/*									      */
/*	STR$UPCASE			External function - convert string to */
/*					uppercase			      */
/*									      */
/*	SYS$BINTIM			External function - convert time to   */
/*					system binary time		      */
/*									      */
/*									      */
/******************************************************************************/


/******************************************************************************/
/*									      */
/*  PROCEDURE BACKUP							      */
/*									      */
/*  FUNCTION -	The main routine calls GETINFO to get information from the    */
/*		user and then acts according to	the user's choice.	      */
/*									      */
/*  GLOBAL VARIABLES:							      */
/*									      */
/*	BYTE				Builtin	PL/1 function		      */
/*									      */
/*	CHOICE				The user's menu	choice		      */
/*									      */
/*	ESC				ASCII ESC (escape) character	      */
/*									      */
/*	MOD				Builtin	PL/1 function		      */
/*									      */
/*	OK				Flag indicating	valid choice	      */
/*									      */
/*	SYSIN				External File			      */
/*									      */
/*	SYSPRINT			External File			      */
/*									      */
/*	TRUNC				Builtin	PL/1 function		      */
/*									      */
/******************************************************************************/

BACKUP:	PROC OPTIONS(MAIN);

 DCL	STR$UPCASE EXTERNAL ENTRY
		(CHAR(*),CHAR(*)) OPTIONS(VARIABLE) RETURNS(FIXED BIN(31));

 DCL	OK		BIT(1) INIT('1'B),
       (CHOICE,
	ESC)		CHAR(1);

 OPEN FILE(SYSIN) INPUT;


/******** M A I	N ********/

 ESC = BYTE(27);

 PUT EDIT (ESC,'[2J',ESC,'[3;24H',ESC,'[7m') (A);
 PUT EDIT (' VAX  11/785  BACKUP  PROCEDURE ',ESC,'[m')	(A);

 DO WHILE (OK);

     CALL GETINFO;
     SELECT;
	    WHEN (CHOICE = '1')	CALL AUTOMATICALLY;
	    WHEN (CHOICE = '2')	CALL SELECTIVELY;
	    OTHERWISE OK = '0'B;
     END;

 END;

 PUT SKIP EDIT (ESC,'[2J') (A);
 CLOSE FILE(SYSIN);

/* END OF MAIN */



/******************************************************************************/
/*									      */
/*  SUBROUTINE CLEARSCREEN						      */
/*									      */
/*  FUNCTION -	This routine clears a VT100 video screen.		      */
/*									      */
/******************************************************************************/

CLEARSCREEN: PROC;	/******* Clears	the screen window *******/

   PUT EDIT (ESC,'[4;1H',ESC,'[J') (A);
END;



/******************************************************************************/
/*									      */
/*  SUBROUTINE GETINFO							      */
/*									      */
/*  FUNCTION -	This routine dispalys the menu and gets	the user's choice.    */
/*									      */
/******************************************************************************/

GETINFO: PROC;		/******* Gets information from the user	*******/

   CALL	CLEARSCREEN;
   PUT SKIP(3) EDIT ('Would you like to :') (COL(24),A);
   PUT SKIP(3) EDIT ('1. Display the procedure for today ?') (COL(24),A);
   PUT SKIP(2) EDIT ('2. Display the procedure for a selected day ?') (COL(24),A);
   PUT SKIP(2) EDIT ('3. Exit ?')  (COL(24),A);
   PUT SKIP(5) EDIT ('Please enter the number of your option : ') (COL(22),A);
   GET LIST (CHOICE);
   CALL	CLEARSCREEN;

END;


/******************************************************************************/
/*									      */
/*  SUBROUTINE SELECTIVELY						      */
/*									      */
/*  FUNCTION -	This routine is	executed if the	procedure for a	specific day  */
/*		is to be displayed;  it	gets necessary info from the user.    */
/*									      */
/*  LOCAL VARIABLES:							      */
/*									      */
/*	JUNK2				The return status from STR$UPCASE     */
/*									      */
/*	WEEK				The user's desired week	number	      */
/*									      */
/*	WKDAY				The user's desired weekday	      */
/*									      */
/******************************************************************************/

SELECTIVELY : PROC;	/******* Executed if a selected	day is desired *******/

   DCL	 (JUNK,
	  WEEK)	     CHAR(1),
	 WKDAY	     CHAR(3),
	 JUNK2	     FIXED BIN(31);

   PUT SKIP(3) EDIT ('Enter the WEEK number (1, 2, 3, or 4) ? ') (COL(20),A);
   GET LIST (WEEK);

   IF (WEEK < '1'  |  WEEK > '4')
   THEN	WKDAY =	'INV';
     ELSE DO;
     PUT SKIP(3) EDIT ('Enter the DAY of WEEK ',WEEK,' (ex. MON) ? ')
		    (COL(20),A,A,A);
     GET LIST (WKDAY);
     JUNK2 = STR$UPCASE(WKDAY,WKDAY);
     END;

   CALL	DISPLAY_BACKUP(WEEK,WKDAY);
   RETURN;
END;  /******  SELECTIVELY  ******/



/******************************************************************************/
/*									      */
/*  SUBROUTINE DISPLAY_BACKUP						      */
/*									      */
/*  FUNCTION -	This routine displays the backup for the week and day passed  */
/*		to it.							      */
/*									      */
/*  LOCAL VARIABLES:							      */
/*									      */
/*	JUNK				Junk byte used to "Press RETURN	..."  */
/*									      */
/*	WEEK				Parameter - the	user's week number    */
/*									      */
/*	WKDAY				Parameter - the	user's weekday	      */
/*									      */
/******************************************************************************/

DISPLAY_BACKUP:	PROC (WEEK,WKDAY);	/******* Displays the procedures ****/

 DCL	WEEK	CHAR(*),
	WKDAY	CHAR(*);
 DCL	JUNK	CHAR(1);

   CALL	CLEARSCREEN;

   SELECT;
	WHEN (WKDAY = 'MON') DO;
	      PUT SKIP(2) EDIT (ESC,'[7m',' Monday -- Week ',WEEK,ESC,'[m')
			       (COL(31),A,A,A,A,X(1),A,A);

	      IF (WEEK='1' | WEEK='3')
	      THEN CALL	PRINTDISK('DUA0:','1');
	      ELSE CALL	PRINTDISK('DUA0:','2');

	      PUT SKIP EDIT (ESC,'[23;24H','Press RETURN for next screen ... ')
			    (A,A,A);
	      GET LIST (JUNK);

	      PUT EDIT (ESC,'[6;1H',ESC,'[J') (A);
	      IF (WEEK='1' | WEEK='3')
	      THEN CALL	PRINTTAPE('DUA1:','A');
	      ELSE CALL	PRINTTAPE('DUA1:','B');
	   END;

	WHEN (WKDAY = 'TUE') DO;
	      PUT SKIP(2) EDIT (ESC,'[7m',' Tuesday -- Week ',WEEK,ESC,'[m')
			    (COL(30),A,A,A,A,X(1),A,A);
	      CALL PRINTTAPE('DJA2:','A');
	   END;

	WHEN (WKDAY = 'WED') DO;
	      PUT SKIP(2) EDIT (ESC,'[7m',' Wednesday -- WEEK ',WEEK,ESC,'[m')
			    (COL(29),A,A,A,A,X(1),A,A);
	      PUT SKIP(2) LIST ('INCREMENTAL of	 DUA1:');
	      PUT SKIP LIST ('-----------     -----');
	      PUT SKIP(2) LIST ('$ ALLOCATE MSA0:');
	      PUT SKIP LIST ('	  mount	incremental tape');
	      PUT SKIP LIST ('$	INIT MSA0: mmmdd');
	      PUT SKIP LIST ('$	MOUNT MSA0:/FOREIGN');
	      PUT SKIP EDIT ('$	BACKUP/RECORD/IGNORE=INTERLOCK DUA1:[*...]',
		       '/SINCE=BACKUP MSA0:mmmdd.BCK') (A);
	      PUT SKIP LIST ('$	DISMOUNT MSA0:');
	      PUT SKIP LIST ('	  dismount tape');
	      PUT SKIP LIST ('$	DEALLOCATE MSA0:');
	      PUT SKIP(3);
	   END;

	WHEN (WKDAY = 'THU') DO;
	      PUT SKIP(2) EDIT (ESC,'[7m',' Thursday --	Week ',WEEK,ESC,'[m')
			    (COL(30),A,A,A,A,X(1),A,A);
	       IF (WEEK	= '1' |	WEEK = '3')
	       THEN CALL PRINTTAPE('DUA0:','A');
	       ELSE CALL PRINTTAPE('DUA0:','B');
	   END;

	WHEN (WKDAY = 'FRI') DO;
	      PUT SKIP(2) EDIT (ESC,'[7m',' Friday -- Week ',WEEK,ESC,'[m')
			    (COL(31),A,A,A,A,X(1),A,A);

	      IF (WEEK='1' | WEEK='3')
	      THEN CALL	PRINTDISK('DUA1:','1');
	      ELSE CALL	PRINTDISK('DUA1:','2');

	      PUT SKIP EDIT (ESC,'[23;23H','Press RETURN for next screen ... ')
		       (A,A,A);
	      GET LIST (JUNK);
	      PUT EDIT (ESC,'[6;1H',ESC,'[J') (A);
	      CALL PRINTTAPE('DJA2:','B');
	   END;

	OTHERWISE PUT SKIP(7) EDIT ('NOT A VALID DAY FOR BACKUPS')
				   (COL(27),A);

   END;

   PUT SKIP EDIT (ESC,'[23;28H','Press RETURN for menu ... ') (A,A,A);
   GET LIST (JUNK);
   RETURN;
END;


/******************************************************************************/
/*									      */
/*  SUBROUTINE AUTOMATICALLY						      */
/*									      */
/*  FUNCTION -	This routine determines	the current week number	and weekday.  */
/*		DISPLAY_BACKUP is then called for the display.		      */
/*									      */
/*  LOCAL VARIABLES:							      */
/*									      */
/*	CURRENT				Current	LIB$DATE_TIME return	      */
/*									      */
/*	CURRENT_DATE			*/
/*									      */
/*	DAY				LIB$DAY_OF_WEEK	day number	      */
/*									      */
/*	DAYS_BETWEEN			The number of days between the start  */
/*					date 20-MAY-1985 and the current date */
/*									      */
/*	START				Backup schedule	start (20-MAY-1985)   */
/*									      */
/*	STATUS				Return status of system/library	calls */
/*									      */
/*	TEMP1				Number of days between START & system */
/*					zero date			      */
/*									      */
/*	TEMP2				Same as	TEMP1 (current date)	      */
/*									      */
/*	WEEK				The week number	as a character	      */
/*									      */
/*	WEEK_NO				The week number			      */
/*									      */
/*	WKDAY				The weekday			      */
/*									      */
/******************************************************************************/

AUTOMATICALLY :	PROC;	   /****** Executed to display current procedure **/

 DCL	WEEK	CHAR(1),
	WKDAY	CHAR(3);

 DECLARE  LIB$DATE_TIME	 EXTERNAL ENTRY
	       (CHAR(*))  RETURNS (FIXED BIN(31));
 DECLARE  LIB$DAY_OF_WEEK  EXTERNAL ENTRY
	       (BIT(64),FIXED BIN(31))	OPTIONS(VARIABLE)
	       RETURNS (FIXED BIN(31));

 DECLARE  LIB$DAY  EXTERNAL ENTRY
	       (FIXED BIN(31),BIT(64))	RETURNS	(FIXED BIN(31));

 DECLARE  SYS$BINTIM  EXTERNAL ENTRY
		(CHAR(*),BIT(64)) OPTIONS(VARIABLE) RETURNS (FIXED BIN(31));

  DCL	DAY	  FIXED	BIN(31),
	CURRENT_DATE	 CHAR(23),
       (STATUS,DAYS_BETWEEN,TEMP1,TEMP2,WEEK_NO)   FIXED BIN(31),
       (CURRENT, START)	 BIT(64);

    STATUS = LIB$DATE_TIME(CURRENT_DATE);
    STATUS = SYS$BINTIM('20-MAY-1985 00:00:00.00',START);
    STATUS = SYS$BINTIM(CURRENT_DATE,CURRENT);
    STATUS = LIB$DAY(TEMP1,START);
    STATUS = LIB$DAY(TEMP2,CURRENT);

    DAYS_BETWEEN = TEMP2 - TEMP1;

    WEEK_NO = MOD(TRUNC(DAYS_BETWEEN/7),2);
    IF WEEK_NO = 0
    THEN WEEK =	'1';
    ELSE WEEK =	'2';

    STATUS = LIB$DAY_OF_WEEK(,DAY);
    SELECT (DAY);

	 WHEN (1)  WKDAY = 'MON';
	 WHEN (2)  WKDAY = 'TUE';
	 WHEN (3)  WKDAY = 'WED';
	 WHEN (4)  WKDAY = 'THU';
	 WHEN (5)  WKDAY = 'FRI';
	 OTHERWISE WKDAY = 'INV';
    END;

  CALL DISPLAY_BACKUP(WEEK,WKDAY);
  RETURN;

END;	  /****** end Automatically ******/



/******************************************************************************/
/*									      */
/*  SUBROUTINE PRINTDISK						      */
/*									      */
/*  FUNCTION -	This routine displays a	DISK to	DISK backup.		      */
/*									      */
/*  LOCAL VARIABLES:							      */
/*									      */
/*	DEVICE				Parameter - the	device to be backed   */
/*									      */
/*	DISK				Parameter - the	disk number	      */
/*									      */
/******************************************************************************/

PRINTDISK: PROC	(DEVICE,DISK);		/*** Sub to print DISK to DISK ***/

   DCL	   DEVICE   CHAR(5),
	   DISK	    CHAR(1);

   PUT SKIP(2) EDIT ('IMAGE of  ',DEVICE,'  to DISK ',DISK) (A);
   PUT SKIP EDIT ('----- --  -----  -- ---- -') (A);
   PUT SKIP(2) LIST ('$ DISMOUNT DJA2:');
   PUT SKIP EDIT ('$ ALLOCATE DJA2:') (A);
   PUT SKIP LIST ('    load disk ',DISK);
   PUT SKIP LIST ('$ INIT DJA2: mmmdd');
   PUT SKIP LIST ('$ MOUNT DJA2:/FOREIGN');
   PUT SKIP LIST ('$ BACKUP/IMAGE/RECORD/IGNORE=INTERLOCK ',DEVICE,' DJA2:');
   PUT SKIP LIST ('$ DISMOUNT DJA2:');
   PUT SKIP LIST ('$ DEALLOCATE DJA2:');
   PUT SKIP LIST ('    load original DJA2: disk');
   PUT SKIP LIST ('$ @MNTDJA2');
   PUT SKIP;
   RETURN;
END;



/******************************************************************************/
/*									      */
/*  SUBROUTINE PRINTTAPE						      */
/*									      */
/*  FUNCTION -	This routine displays a	DISK to	TAPE backup.		      */
/*									      */
/*  LOCAL VARIABLES:							      */
/*									      */
/*	DEVICE				Parameter - the	device to be backed   */
/*									      */
/*	TAPE				Parameter - the	tape (A	or B)	      */
/*									      */
/******************************************************************************/

PRINTTAPE: PROC	(DEVICE,TAPE);		/*** Sub to print DISK to TAPE ***/

   DCL	   DEVICE   CHAR(5),
	   TAPE	    CHAR(1);

   PUT SKIP(2) EDIT ('IMAGE of  ',DEVICE,'  to Tape ',TAPE) (A);
   PUT SKIP LIST ('----- --  -----  -- ---- -');
   PUT SKIP(2) LIST ('$ ALLOCATE MSA0:');
   PUT SKIP LIST ('    mount tape ',TAPE);
   PUT SKIP LIST ('$ INIT MSA0: mmmdd');
   PUT SKIP LIST ('$ MOUNT MSA0:/FOREIGN');
   PUT SKIP EDIT ('$ BACKUP/IMAGE/RECORD/IGNORE=INTERLOCK ',DEVICE,
		  ' MSA0:mmmdd.BCK/SAVE_SET') (A);
   PUT SKIP LIST ('$ DISMOUNT MSA0:');
   PUT SKIP LIST ('    dismount tape');
   PUT SKIP LIST ('$ DEALLOCATE MSA0:');
   PUT SKIP(3);

   RETURN;
END;

END BACKUP;