.;
.;	Title:	TIMCHANGE.CMD
.;	Author:	T. R. Wyant (DuPont)
.;	Date:	12-Sep-1985
.;	Modified:
.;	Remarks:
.;		This command file is used to change a system to/from
.;		Daylight Savings time. The algorithm is as follows:
.;
.;		Determine when the next time change is.
.;		Resubmit self as batch job, to run next time change.
.;		IF today is time change day THEN
.;		    Change the time in the appropriate direction
.;		    Reschedule tasks in the clock queue
.;		  ENDIF
.;
.;		The subroutines used to do date/time manipulation may
.;		be of interest in their own right.
.;
	.ENABLE SUBSTITUTION
;+
;		'<FILSPC>'
;

	.SETS S$DCL "DCL "	! Explicitly pass DCL commands to DCL.
	.SETS S$MCR "MCR "	! Explicitly pass MCR commands to MCR.
	.IF <CLI> = "DCL" .SETS S$DCL ""	! DCL cmds implicit.
	.IF <CLI> = "MCR" .SETS S$MCR ""	! MCR cmds implicit.
	.TESTDEVICE TI:			! Find out where we are running.
	.PARSE <EXSTRI> "," S$TI S$JUNK	! Save our TI: unit. no.
	.SETS S$JUNK S$TI[1:2]		! Get the driver name.
	.SETT L$CAN			! Assume OK to cancel.
	.IF S$JUNK = "VT" .SETF L$CAN	! If a VT, not OK.
	.SETS S$SVP1 P1			! Save P1.
	.SETS S$OUIC <UIC>		! Save UIC.
	.SETF L$SCH			! Not a schedule-only.
	.SETT L$TST			! A test.
	.PARSE S$SVP1 "/" S$DATE S$SVP1	! Strip off the date.
	.IF S$DATE <> "" .GOTO P1LPE	! If a date given, process.
	.SETS S$DATE <DATE>		! Use the real date.
	.SETF L$TST			! Not a test.
	.GOTO P1LPE			! Enter parser loop at bottom.
.P1LP:
	.PARSE S$SVP1 "/" S$SW S$SVP1	! Pick off the next switch.
	.IF S$SW = ""	.GOTO P1LPE	! If null, ignore.
	.TEST S$SW			! Check it out.
	.IFF <ALPHAN>	.GOTO P1LPE	! If not proper format, ignore.
	.IF <STRLEN> > 4 .GOTO P1LPE	! If too long, ignore.
	.IFNDF L$'S$SW'	.GOTO P1LPE	! If no such switch, ignore.
	.SETT L$'S$SW'			! Set the switch.
.P1LPE:	.IF S$SVP1 <> "" .GOTO P1LP	! If not done, loop again.

	.GOSUB CNVDAT 'S$DATE'
	.GOSUB JULDAT '<EXSTRI>'
	.PARSE <EXSTRI> "/" S$JD S$YR	! Separate the JD and year.
	.SETN D$CUJD 'S$JD'.		! Save the current Julian date.
	.SETN D$CUYR 'S$YR'.		! Save the current Julian date.
	.SETN D$TMYR D$CUYR		! Assume next run is this year.
	.SETS S$TMMD "3/31"			! Find the next Sunday
	.GOSUB USUAL				!    AFTER 3/31
	.IF D$TMJD >= D$CUJD	.GOTO SPRING	! If yet to come, fine.
	.SETS S$TMMD "10/24"			! Find next Sunday
	.GOSUB USUAL				!    AFTER 10/24
	.IF D$TMJD >= D$CUJD	.GOTO FALL	! If yet to come, fine.
	.INC D$TMYR				! No time chg this year.
	.SETS S$TMMD "3/31"		! Find the next Sunday AFTER
	.GOSUB USUAL			!    3/31 of next year.
	.GOTO SPRING			! Set it up as spring change.

.SPRING:.SETS S$DESC "Standard Time to Daylight Saving Time"
	.SETS S$INCR "+1."			! Spring forward.
	.IF D$TMJD <> D$CUJD	.GOTO FOUNDS	! If not the day, sched.
	.SETS S$TMMD "10/24"			! Find next Sunday
	.GOSUB USUAL				!    AFTER 10/24
	.GOTO FOUND				! Go join common code.

.FALL:	.SETS S$DESC "Daylight Saving Time to Standard Time"
	.SETS S$INCR "-1."			! Fall back.
	.IF D$TMJD <> D$CUJD	.GOTO FOUNDS	! If not the day, sched.
	.INC D$TMYR				! Schedule for next yr.
	.SETS S$TMMD "3/31"		! Find the next Sunday AFTER
	.GOSUB USUAL			!    3/31 of next year.
	.GOTO FOUND

.USUAL:	.GOSUB JULDAT 'S$TMMD'/'D$TMYR'
	.PARSE <EXSTRI> "/" S$JD S$YR	! Get the Julian day and year.
	.SETN D$TMJD 'S$JD'.		! Convert the Julian day to numb
	.SETN D$TMYR 'S$YR'.		! Convert the year to a number.
	.GOSUB WKDAY '<EXSTRI>'
	.PARSE <EXSTRI> "/" S$JD S$YR	! Secure the day number.
	.SETN D$INCR 7.-'S$JD'.
	.SETN D$TMJD D$TMJD+D$INCR	! Move forward to next Sunday.
	.RETURN				! Return to caller.

.FOUNDS:.SETT L$SCH
.FOUND:	.GOSUB INCDAT 'S$TMMD'/'D$TMYR' 'D$INCR'
	.PARSE <EXSTRI> "/" S$SCHD S$JD S$YR	! Find the actual date.
	.TEST S$YR				! Keep only the last 2
	.SETS S$YR S$YR[<STRLEN>-1:<STRLEN>]	!    digits of the year.
	.SETN D$JUNK 'S$SCHD'.*3-2		! Index into month table
	.SETS S$SCHD "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC"
	.SETS S$SCHD S$JD+"-"+S$SCHD[D$JUNK:D$JUNK+2]+"-"+S$YR

	.SETS S$TXT "Convert "
	.IFT L$SCH .SETS S$TXT "Schedule conversion of "
	.IFT L$TST .SETS S$TXT "Test conversion of "
	.IFT L$TST .IFT L$SCH .SETS S$TXT "Test scheduling conversion of "
.;
;	'S$TXT''S$DESC'
;-
	.IFDISABLED MCR	.SETF L$TST
	.IFT L$TST	.DISABLE MCR
	.IFDISABLED MCR	.GOTO SUBMIT
	.TESTFILE TIMCHANGE.BAT
	.IF <FILERR> = 1	.GOTO SUBMIT
	.OPEN TIMCHANGE.BAT
	.ENABLE DATA
$JOB
$@LB:TIMCHANGE
$EOJ
.DISABLE DATA
	.CLOSE


.SUBMIT:.IFT L$CAN	'S$MCR'QUE SYSBAT:TIMCHANGE/DEL/NM
	'S$MCR'SUB SYSBAT:/AF:2:00:'S$SCHD'/NOPRIN=TIMCHANGE.BAT
	.IFT L$SCH	.EXIT
	'S$MCR'PIP TIMCHANGE.LOG/PU & *.*;1/RE=TIMCHANGE.LOG

	.TESTDEVICE TI:
	.SETS S$JUNK <EXSTRI>[1:2]
	.SETT L$DO
	.IF S$JUNK <> "VT" .ASK L$DO Is this really what you want to do
	.IFF L$DO	.EXIT

	.PARSE <TIME> ":" S$HR S$MI S$SC
	.SETN D$HR 'S$HR'.'S$INCR'
	'S$MCR'TIM 'D$HR':'S$MI':'S$SC'
.;
.;		Reschedule any tasks here.
.;

;
;
;	Done.
;

	.IF <UIC> <> S$OUIC	'S$MCR'SET /UIC='S$OUIC'
	.TEST S$TXT " "
	.SETS S$BRO S$TXT[1:<STRLEN>-1]+"ed"+S$TXT[<STRLEN>:*]+S$DESC
	'S$MCR'BRO CO:'S$BRO'
	.EXIT

.;
.;		Subroutines.
.;

.;
.;
.; CNVDAT - Subroutine to convert date from dd-mmm-yy format to mm/dd/yyyy
.;	    Calling sequence:
.;		.GOSUB CNVDAT dd-mmm-yy
.;	    Return is in <EXSTRI>. Results not guaranteed for invalid input.
.;
.CNVDAT:
	.BEGIN
	.PARSE COMMAN "-" S$CNDA S$CNMO S$CNYR
	.TEST "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC" S$CNMO
	.SETN D$CNDA 'S$CNDA'.
	.SETN D$CNMO (<STRLEN>-1)/3+1.
	.SETN D$CNYR 'S$CNYR'.
	.IF D$CNYR < 60.	.SETN D$CNYR D$CNYR+2000.
	.IF D$CNYR < 100.	.SETN D$CNYR D$CNYR+1900.
	.SETS <EXSTRI> "'D$CNMO'/'D$CNDA'/'D$CNYR'"
	.END
	.RETURN

.;
.;
.; JULDAT - Subroutine to convert date from mm/dd/yyyy to julian date in
.;		form jjj/yyyy
.;	    Calling sequence:
.;		.GOSUB CNVDAT mm/dd/yyyy
.;	    Return is in <EXSTRI>. Results not guaranteed for invalid input.
.;
.JULDAT:
	.BEGIN
	.PARSE COMMAN "/" S$JUMO S$JUDA S$JUYR
	.SETN D$JUMO 'S$JUYR'.-1
	.SETN D$JUMO D$JUMO/4-(D$JUMO/100.)+(D$JUMO/400.)
	.SETN D$JUDA 'S$JUYR'./4-('S$JUYR'./100.)+('S$JUYR'./400.)-D$JUMO
	.SETN D$JUMO ('S$JUMO'.-1)*3+1
	.IF D$JUDA > 0	.IF D$JUMO < 6	.DEC D$JUDA
	.SETS S$JUMO "000031059090120151181212243273304334"
	.SETS S$JUMO S$JUMO[D$JUMO:D$JUMO+2]
	.SETN D$JUDA D$JUDA+'S$JUMO'.+'S$JUDA'.
	.SETS <EXSTRI> "'D$JUDA'/'S$JUYR'"
	.END
	.RETURN

.;
.;
.; DATDIF - Subroutine to find the difference of two julian dates in the
.;		form jjj/yyyy
.;	    Calling sequence:
.;		.GOSUB DATDIF jjj/yyyy jjj/yyyy
.;	    Return is second date minus first in <EXSTRI>. If the first
.;		date is larger than the second, a null string is returned.
.;		Results not guaranteed for invalid input.
.;
.DATDIF:
	.BEGIN
	.PARSE COMMAN "/ /" S$DFJ1 S$DFY1 S$DFJ2 S$DFY2
	.SETS S$DFAN ""
	.SETN D$DFY1 'S$DFY1'.
	.SETN D$DFY2 'S$DFY2'.
	.IF D$DFY1 > D$DFY2	.GOTO DATDIX
	.SETN D$DFJ1 D$DFY1-1
	.SETN D$DFJ1 (D$DFJ1/4)-(D$DFJ1/100.)+(D$DFJ1/400.)
	.SETN D$DFJ2 D$DFY2-1
	.SETN D$DFJ2 (D$DFJ2/4)-(D$DFJ2/100.)+(D$DFJ2/400.)
	.SETN D$DFY1 (D$DFY2-D$DFY1)*365.+D$DFJ2-D$DFJ1
	.SETN D$DFJ1 'S$DFJ1'.
	.SETN D$DFJ2 'S$DFJ2'.
	.IF D$DFY1 = 0	.IF D$DFJ1 > D$DFJ2	.GOTO DATDIX
	.SETN D$DFY1 D$DFY1+D$DFJ2-D$DFJ1
	.SETS S$DFAN "'D$DFY1'"
.DATDIX:.SETS <EXSTRI> S$DFAN
	.END
	.RETURN

.;
.;
.; WKDAY - Subroutine to find the day of the week for a given julian date
.;		in the form jjj/yyyy
.;	    Calling sequence:
.;		.GOSUB WKDAY jjj/yyyy
.;	    Return is day of week in form n/xxxxxxxx in <EXSTRI>, where
.;		n is the day number (Sunday = 0), and xxxxxxx is the name
.;		of the day. Results not guaranteed for invalid input.
.;
.WKDAY:
	.BEGIN
	.PARSE COMMAN "/ /" S$DFJ1 S$DFY1
	.SETN D$DFY1 'S$DFY1'.-1.
	.SETN D$DFY1 (D$DFY1/4)-(D$DFY1/100.)+(D$DFY1/400.)+D$DFY1+'S$DFJ1'.
	.SETN D$DFY1 D$DFY1-((D$DFY1/7)*7)
	.SETS S$DFY1 "0/Sunday:1/Monday:2/Tuesday:3/Wednesday:4/Thursday:"
	.SETS S$DFY1 S$DFY1+"5/Friday:6/Saturday:"
	.TEST S$DFY1 "'D$DFY1'"
	.SETS S$DFY1 S$DFY1[<STRLEN>:*]
	.PARSE S$DFY1 ":" <EXSTRI> S$DFJ1
	.END
	.RETURN

.;
.;
.; NXTDAT - Return next day with given parameters.
.;
.; Calling sequence:
.;	.GOSUB NXTDAT dd/mm/yyyy monrem/monmod ordinal/weekday
.;
.NXTDAT:
	.BEGIN
	.PARSE COMMAN "// / /" S$NXMO S$NXDA S$NXYR S$NXMR S$NXMM S$NXOR S$NXWD
	.GOSUB JULDAT 'S$NXMO'/'S$NXDA'/'S$NXYR'
	.SETS S$NXCJ <EXSTRI>
	.SETN D$NXMO 'S$NXMO'.-(('S$NXMO'./'S$NXMM'.)*'S$NXMM'.)

	.SETN D$NXMO 'S$NXMM'.+'S$NXMR'.-D$NXMO
	.SETN D$NXMO D$NXMO-((D$NXMO/'S$NXMM'.)*'S$NXMM'.)+'S$NXMO'.

	.SETN D$NXYR 'S$NXYR'.
	.SETN D$NXWD 'S$NXWD'.
.NXTDAL:
	.SETN D$NXDA ('S$NXOR'.-1)*7.
	.GOSUB JULDAT 'D$NXMO'/'D$NXDA'/'D$NXYR'
	.SETS S$NXTJ <EXSTRI>
	.GOSUB WKDAY '<EXSTRI>'
	.PARSE <EXSTRI> "/" S$NXTW S$NXJK
	.SETN D$NXJK 7+'S$NXWD'.-'S$NXTW'.
	.SETN D$NXJK D$NXJK-((D$NXJK/7)*7)
	.SETN D$NXDA 'D$NXDA'.+'D$NXJK'.
	.GOSUB JULDAT 'D$NXMO'/'D$NXDA'/'D$NXYR'
	.GOSUB DATDIF 'S$NXCJ' '<EXSTRI>'
	.IF <EXSTRI> <> ""	.GOTO NXTDAX
	.SETN D$NXMO D$NXMO+'S$NXMM'.
	.GOTO NXTDAL
.NXTDAX:.SETN D$NXMO (D$NXMO-1)*3+1
	.SETS S$NXJK "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC"
	.SETS S$NXJK S$NXJK[D$NXMO:D$NXMO+2]
	.SETS <EXSTRI> "'D$NXDA'-'S$NXJK'-'D$NXYR'"
	.END
	.RETURN

.;
.;
.; INCDAT - Add "n" to the current date.
.; Calling Sequence -
.;	.GOSUB INCDAT mm/dd/yyyy n
.; Result in <EXSTRI>, in form mm/dd/yyyy.
.;
.INCDAT:
	.BEGIN
	.PARSE COMMAN "// " S$INM1 S$IND1 S$INY1 S$ININ
	.IF S$ININ = ""	.SETS S$ININ "1"
	.SETN D$INM1 'S$INM1'.
	.SETN D$IND1 'S$IND1'.
	.SETN D$INY1 'S$INY1'.
	.SETT L$INFW
	.SETS S$INJK S$ININ[1:1]
	.IF S$INJK <> "-"	.GOTO INCDAF
	.SETF L$INFW
	.SETS S$ININ S$ININ[2:*]
	.SETN D$IND2 D$IND1
	.SETN D$INM2 D$INM1
	.SETN D$INY2 D$INY1
.INCDAF:.SETN D$INI1 'S$ININ'.

	.GOSUB JULDAT 'D$INM1'/'D$IND1'/'D$INY1'
	.SETS S$INJ1 <EXSTRI>

	.IFF L$INFW	.GOTO INCDAE
	.SETN D$IND2 D$INI1+D$IND1-1
	.SETN D$INM2 (D$IND2/28.)+D$INM1-1
	.SETN D$INY2 D$INM2/12.+D$INY1
	.SETN D$IND2 D$IND2-((D$IND2/28.)*28.)+1
	.SETN D$INM2 D$INM2-((D$INM2/12.)*12.)+1
	.GOTO INCDAE

.INCDAL:
	.DEC D$INM2
	.DEC D$IND2
	.SETN D$INJK D$INI2/366.
	.SETN D$INY2 D$INY2-D$INJK
	.SETN D$INI2 D$INI2-(D$INJK*366.)
	.SETN D$INJK D$INI2/31.
	.SETN D$INM2 D$INM2+12.-D$INJK
	.SETN D$INI2 D$INI2-(D$INJK*31.)
	.SETN D$IND2 D$IND2+31.-D$INI2

	.SETN D$INM2 D$INM2+(D$IND2/31.)-1
	.SETN D$IND2 D$IND2-((D$IND2/31.)*31.)+1

	.SETN D$INY2 D$INY2+(D$INM2/12.)-1
	.SETN D$INM2 D$INM2-((D$INM2/12.)*12.)+1

.INCDAE:.GOSUB JULDAT 'D$INM2'/'D$IND2'/'D$INY2'
	.IFF L$INFW	.GOTO INCDAB
	.GOSUB DATDIF 'S$INJ1' '<EXSTRI>'
	.IF D$INI1 >= '<EXSTRI>'.	.GOTO INCDAX
	.SETN D$INI2 '<EXSTRI>'.-D$INI1
	.GOTO INCDAL
.INCDAB:.GOSUB DATDIF '<EXSTRI>' 'S$INJ1'
	.IF D$INI1 <= 0'<EXSTRI>'.	.GOTO INCDAX
	.SETN D$INI2 D$INI1-0'<EXSTRI>'.
	.GOTO INCDAL
.INCDAX:.SETS <EXSTRI> "'D$INM2'/'D$IND2'/'D$INY2'"
	.END
	.RETURN