C   ---------------------------------------------------------------------------
C   TIME.FOR - The function of this program is to perform time calculations
C	for the DCL user. The functions which may be performed are:
C
C	TIME - This will return the current time and the user's connect time.
C	TIME absolute_time - This will return the current time and the delta
C			     between the current time and the absolute_time
C			     specified.
C	TIME abs_time (-) abs_time --> gives delta_time.
C	TIME abs_time (+) delat_time --> gives abs_time.
C	TIME abs_time (-) delta_time --> gives abs_time.
C	TIME abs_time (=) abs_time --> 'YES' or 'NO'	also (EQ)
C	TIME abs_time (<>) abs_time --> 'YES' or 'NO'	also (NE)
C	TIME abs_time (<) abs_time --> 'YES' or 'NO'	also (LT)
C	TIME abs_time (>) abs_time --> 'YES' or 'NO'	also (GT)
C	TIME abs_time (<=) abs_time --> 'YES' or 'NO'	also (LE)
C	TIME abs_time (>=) abs_time --> 'YES' or 'NO'	also (GE)
C	TIME abs_time (?) abs_time --> gives:
C						a 'GREATER_THAN' than b
C						a 'LESS_THAN' than b
C						a 'EQUAL_TO' to b
C	TIME delta_time (+) delta_time --> gives delta_time.
C	TIME delta_time (-) delta_time --> gives delta_time.
C	TIME delta_time (=) delta_time --> gives 'YES' or 'NO'	also (EQ)
C	TIME delta_time (<>) delta_time --> gives 'YES' or 'NO'	also (NE)
C	TIME delta_time (<) delta_time --> gives 'YES' or 'NO'	also (LT)
C	TIME delta_time (>) delta_time --> gives 'YES' or 'NO'	also (GT)
C	TIME delta_time (<=) delta_time --> gives 'YES' or 'NO'	also (LE)
C	TIME delta_time (>=) delta_time --> gives 'YES' or 'NO'	also (GE)
C	TIME delta_time (?) delta_time --> gives:
C						a 'GREATER_THAN' than b
C						a 'LESS_THAN' than b
C						a 'EQUAL_TO' to b
C	TIME delta_time (/) delta_time --> gives integer
C	TIME delta_time (/) integer --> gives delta_time
C	TIME delta_time (*) integer --> gives delta_time
C
C	TIME integer (+) integer --> integer
C	TIME integer (-) integer --> integer
C	TIME integer (/) integer --> integer
C	TIME integer (*) integer --> integer
C
C   Input formats:
C
C	The absolute time input format may be either:
C
C		dd-mmm-yyyy hh:mm:ss.hh
C	or
C		dd-mmm-yyyy:hh:mm:ss.hh
C
C	or one of the keywords:
C
C		YESTERDAY, TODAY, TOMORROW, THISMONTH, NEXTMONTH, LASTMONTH
C		THISYEAR, THISWEEK, NEXTWEEK, LASTWEEK
C
C	The colon between the year and the hour is optional.
C
C	The delta time input format may be:
C
C		dddd-hh:mm:ss.hh
C
C	The dash between the days and the hour is optional.
C
C	The operators must may be:
C
C		(+)	addition
C		(-)	subtraction
C		(*)	multiplication
C		(/)	division
C		(=)	compare for equal to
C		(<>)	compare for not equal to
C		(<)	compare for less than
C		(>)	compare for greater than
C		(<=)	compare for less than or equal to
C		(>=)	compare for greater than or equal to
C		(?)	comparsion
C
C	The () must be included.
C
C   Output formats:
C
C	If no /SYMBOL=symbol option is given then the results are sent to
C	SYS$OUTPUT, otherwise the result is returned in the local symbol
C	specified.
C
C	The absolute time returned will be in the following format:
C
C		dd-mmm-yyyy:hh:mm:ss.hh
C
C	The delta time returned will be in the following format:
C
C		dddd-hh:mm:ss.hh
C
C	The comparison values returned will be,
C
C	    for (?):
C		GREATER_THAN
C		LESS_THAN
C		EQUAL_TO
C
C	    and for (=), (<>), (<), (>), (<=), (>=):
C		YES
C		NO
C		
C   ---------------------------------------------------------------------------
C
C V2.0	23-Mar-83	FJN	Converted to using TIME__xxx condition codes
C				from TIMEMSG.MSG file.  Added TIMEKEY with
C				keyword time names.
C V2.1	02-Apr-83	FJN	Added LASTMONTH and LASTWEEK keywords
C
	PROGRAM TIME
C
	IMPLICIT INTEGER*4 (A-Z)
C
	EXTERNAL	SS$_INTOVF
	EXTERNAL	SS$_IVTIME
C
	PARAMETER	PARAMZ=255
	PARAMETER	RESULTZ=64
	PARAMETER	SYMBOLZ=64
	PARAMETER	ABSZ=23
	PARAMETER	DELTAZ=16
	PARAMETER	DASH='-'
	PARAMETER	SLASH='/'
	PARAMETER	EQUAL='='
	PARAMETER	COLON=':'
	PARAMETER	BLANK=' '
	PARAMETER	PLUS='(+)'
	PARAMETER	MINUS='(-)'
	PARAMETER	MULTIPLY='(*)'
	PARAMETER	DIVIDE='(/)'
	PARAMETER	QUESTION='(?)'
	PARAMETER	EQUAL_TO='(=)'
	PARAMETER	NOT_EQUAL='(<>)'
	PARAMETER	LESS_THAN='(<)'
	PARAMETER	LESS_THAN_EQUAL_TO='(<=)'
	PARAMETER	GREATER_THAN='(>)'
	PARAMETER	GREATER_THAN_EQUAL_TO='(>=)'
	PARAMETER	SYM='SYM'
C
C
	CHARACTER	TIMECUR*40	! Function subroutine.
C
	CHARACTER	PARAM*(PARAMZ) /' '/
	CHARACTER	RESULT*(RESULTZ) /' '/
	CHARACTER	SYMBOL*(SYMBOLZ) /' '/
	CHARACTER	ABS_C*(ABSZ)
	CHARACTER	DELTA_C*(DELTAZ)
C
	INTEGER*4	ABS_S, DELTA_S
	INTEGER*4	BIN_0(2) /0,0/
	INTEGER*4	BIN_1(2)
	INTEGER*4	BIN_2(2)
	INTEGER*4	BIN_SCR(2)
	INTEGER*4	STATUS, STATUS_1, STATUS_2
	INTEGER*4	PARAM_S
	INTEGER*4	RESULT_S
	INTEGER*4	SYMBOL_S /0/
	INTEGER*4	P1 /0/, P2 /0/
	INTEGER*4	Q1 /0/, Q2 /0/
	INTEGER*4	R1 /0/, R2 /0/
	INTEGER*4	S1 /0/, S2 /0/
	INTEGER*4	OP1_1, OP1_2
	INTEGER*4	OP2_1, OP2_2
	INTEGER*4	OP3_1, OP3_2
C
C   ---------------------------------------------------------------------------
C
	EXTERNAL  TIME__INVABSTIM	!invalid absolute time format
	EXTERNAL  TIME__INVADD		!invalid add
	EXTERNAL  TIME__INVCMP		!invalid compare
	EXTERNAL  TIME__INVDELTIM	!invalid delta time format
	EXTERNAL  TIME__INVDIV		!invalid divide
	EXTERNAL  TIME__INVINT		!invalid integer value format
	EXTERNAL  TIME__INVMUL		!invalid multiply
	EXTERNAL  TIME__INVOPR		!invalid operation
	EXTERNAL  TIME__INVSUB		!invalid subtract
	EXTERNAL  TIME__MISPAR		!time parameter missing
	EXTERNAL  TIME__OVRFLO		!time calculation overflow
	EXTERNAL  TIME__TOOMNYOPR	!too many operands
C
C   ---------------------------------------------------------------------------
C
C   Get the command line.
C
	STATUS = LIB$GET_FOREIGN ( PARAM, , PARAM_S )
	IF (.NOT.status) CALL EXIT(status)
	STATUS = TABS_TO_BLANKS ( PARAM(1:PARAM_S), PARAM(1:PARAM_S) )
	IF (.NOT.status) CALL EXIT(status)
	STATUS = STR$UPCASE ( PARAM(1:PARAM_S), PARAM(1:PARAM_S) )
	IF (.NOT.status) CALL EXIT(status)
C
C   Scan for /DEBUG option.
C
	DEBUG = Q_STRING( PARAM(1:PARAM_S), '/DEBUG', 4, SYMBOL )
C
C   Scan for /SYMBOL option.
C
	SYMBOL_S = 0
	STATUS = Q_STRING( PARAM(1:PARAM_S), '/SYMBOL', 4, SYMBOL )
	IF ( STATUS .EQ. 1 ) THEN
		CALL STR$TRIM( SYMBOL, SYMBOL, SYMBOL_S )
	ENDIF
C
C   ---------------------------------------------------------------------------
C
C   Fetch the first parameter.
C
	OP1_2 = 0
	STATUS = TIMEGET( PARAM(1:PARAM_S), OP1_1, OP1_2 )
	IF ( .NOT. STATUS ) THEN
C
C	   No parameters specified; fetch the system time and connect time.
C
		RESULT = TIMECUR ( BIN_0 )
		RESULT_S = LEN( RESULT )
		OP3_2 = OP1_2
		GOTO 1999
	ENDIF
C
C   Convert the first parameter into binary time format.
C
	STATUS_1 = TIMECNV( PARAM(OP1_1:OP1_2), BIN_1 )
	IF ( STATUS_1 .EQ. 4 ) THEN
		CALL LIB$STOP(TIME__INVABSTIM)
	ELSEIF ( STATUS_1 .EQ. 6 ) THEN
		CALL LIB$STOP(TIME__INVDELTIM)
	ELSEIF ( STATUS_1 .EQ. 8 ) THEN
		CALL LIB$STOP(TIME__INVINT)
	ENDIF
C
C   ---------------------------------------------------------------------------
      OP3_2 = OP1_2	
      LOOP = 0	
      DO WHILE (.TRUE.)	
	LOOP = LOOP + 1
C
C   Fetch the next parameter (it should be an operator).
C
	OP2_2 = OP3_2	
	STATUS = TIMEGET( PARAM(1:PARAM_S), OP2_1, OP2_2 )
	IF ( .NOT. STATUS ) THEN
		IF ( LOOP .GT. 1 ) GOTO 1999	
C
C	   No operator present; do a delta time calculation with current time
C		and the first parameter already fetched.
C
		IF ( STATUS_1 .NE. 3 ) THEN
			CALL LIB$STOP(TIME__INVABSTIM)
		ELSE
			RESULT = TIMECUR ( BIN_1 )
			RESULT_S = LEN( RESULT )
			GOTO 1999
		ENDIF
	ENDIF
C
C   ---------------------------------------------------------------------------
C
C   Fetch the last parameter (it should be present).
C
	OP3_2 = OP2_2
	STATUS = TIMEGET( PARAM(1:PARAM_S), OP3_1, OP3_2 )
	IF ( .NOT. STATUS ) THEN
C
C	   Third parameter must be present; error
C
		CALL LIB$STOP(TIME__MISPAR)
	ENDIF
C
C   Convert the third parameter to binary time format.
C
	STATUS_2 = TIMECNV( PARAM(OP3_1:OP3_2), BIN_2 )
	IF ( STATUS_2 .EQ. 4 ) THEN
		CALL LIB$STOP(TIME__INVABSTIM)
	ELSEIF ( STATUS_2 .EQ. 6 ) THEN
		CALL LIB$STOP(TIME__INVDELTIM)
	ELSEIF ( STATUS_1 .EQ. 8 ) THEN
		CALL LIB$STOP(TIME__INVINT)
	ENDIF
C
C   ---------------------------------------------------------------------------
C
C   Evaluate the operator and perform the necessary calculation.
C
	IF ( PARAM(OP2_1:OP2_2) .EQ. PLUS ) THEN
C
C   ---------------------------------------------------------------------------
C
C	   Add the two values together.
C
		STATUS = LIB$ADDX( BIN_1, BIN_2, BIN_1, 2 )
		IF ( STATUS .EQ. %LOC(SS$_INTOVF) ) THEN
			CALL LIB$STOP(TIME__OVRFLO)
		ENDIF
C
C	   Determine the output format and convert to the proper format.
C
		A = STATUS_1 + STATUS_2
		S = STATUS_1 - STATUS_2
		IF ( A .EQ. 10 .AND. S .EQ. 0 ) THEN
C
C		   Convert to delta time format.
C
			STATUS = LIB$SUBX( BIN_0, BIN_1, BIN_SCR, 2 )
			IF (.NOT.status) CALL EXIT(status)
			STATUS = SYS$ASCTIM
	1			( RESULT_S, RESULT, BIN_SCR, %VAL(0) )
			RESULT(5:5) = DASH
C
			IF ( DEBUG .NE. 0 ) WRITE(*,*) 
	1			PARAM(1:OP3_2), '=', RESULT
C
			IF ( STATUS .EQ. %LOC(SS$_IVTIME) ) THEN
				CALL LIB$STOP(TIME__OVRFLO)
			ENDIF
			STATUS_1 = 5
C
		ELSEIF ( A .EQ. 8 ) THEN
C
C		   Convert to absolute time format.
C
			STATUS = SYS$ASCTIM
	1			( RESULT_S, RESULT, BIN_1, %VAL(0) )
			RESULT(12:12) = COLON
C
			IF ( DEBUG .NE. 0 ) WRITE(*,*) 
	1			PARAM(1:OP3_2), '=', RESULT
C
			STATUS_1 = 3
C
		ELSEIF ( A .EQ. 14 ) THEN
C
C		   Convert to integer time format.
C
			IF ( BIN_1(1) .LT. 0 .OR. BIN_1(2) .NE. 0 ) THEN
				CALL LIB$STOP(TIME__OVRFLO)
			ENDIF			
C
			STATUS = OTS$CVT_L_TI
	1			( BIN_1(1), RESULT, %VAL(1), %VAL(4) )
			I = LIB$SKPC( BLANK, RESULT )
			RESULT = RESULT(I:)
C
		ELSE
C
C		   Invalid addition requested.
C
			CALL LIB$STOP(TIME__INVADD)
		ENDIF
C
C   ---------------------------------------------------------------------------
C
	ELSEIF ( PARAM(OP2_1:OP2_2) .EQ. MINUS ) THEN
C
C	   Subtract the two values.
C
		STATUS = LIB$SUBX( BIN_1, BIN_2, BIN_1, 2 )
		IF ( BIN_1(2) .LT. 0 ) THEN
			STATUS = LIB$SUBX( BIN_0, BIN_1, BIN_1, 2 )
		ENDIF
C
C	   Perform the output conversion for display.
C
		A = STATUS_1 + STATUS_2
		S = STATUS_1 - STATUS_2
		IF ( S .EQ. 0 .AND. ( A .EQ. 6 .OR. A .EQ. 10 ) ) THEN
C
C		   Convert to delta time format.
C
			IF ( BIN_1(1) .EQ. 0 .AND. BIN_1(2) .EQ. 0 ) THEN
				BIN_1(1) = '00000001'x
			ENDIF
C
			STATUS = LIB$SUBX( BIN_0, BIN_1, BIN_SCR, 2 )
			STATUS = SYS$ASCTIM
	1			( RESULT_S, RESULT, BIN_SCR, %VAL(0) )
			RESULT(5:5) = DASH
C
			IF ( DEBUG .NE. 0 ) WRITE(*,*) 
	1			PARAM(1:OP3_2), '=', RESULT
C
			IF ( STATUS .EQ. %LOC(SS$_IVTIME) ) THEN
				CALL LIB$STOP(TIME__OVRFLO)
			ENDIF
			STATUS_1 = 5
C
		ELSEIF ( S .EQ. -2 .AND. A .EQ. 8 ) THEN
C
C		   Convert to absolute time format.
C
			IF ( BIN_1(1) .EQ. 0 .AND. BIN_1(2) .EQ. 0 ) THEN
				BIN_1(1) = '00000001'x
			ENDIF
C
			STATUS = SYS$ASCTIM
	1			( RESULT_S, RESULT, BIN_1, %VAL(0) )
			RESULT(12:12) = COLON
C
			IF ( DEBUG .NE. 0 ) WRITE(*,*) 
	1			PARAM(1:OP3_2), '=', RESULT
C
			STATUS_1 = 3
C
		ELSEIF ( A .EQ. 14 ) THEN
C
C		   Convert to integer time format.
C
			IF ( BIN_1(1) .LT. 0 .OR. BIN_1(2) .NE. 0 ) THEN
				CALL LIB$STOP(TIME__OVRFLO)
			ENDIF			
C
			STATUS = OTS$CVT_L_TI
	1			( BIN_1(1), RESULT, %VAL(1), %VAL(4) )
			I = LIB$SKPC( BLANK, RESULT )
			RESULT = RESULT(I:)
C
		ELSE
C
C		   Invalid subtraction requested.
C
			CALL LIB$STOP(TIME__INVSUB)
		ENDIF
C
C   ---------------------------------------------------------------------------
C
	ELSEIF ( PARAM(OP2_1:OP2_2) .EQ. MULTIPLY ) THEN
C
C	   Multiply the two values.
C
		STATUS_M = TIMEEMUL( BIN_1, BIN_2, BIN_1 )
C
C	   Determine the output format and convert to the proper format.
C
		A = STATUS_1 + STATUS_2
		S = STATUS_1 - STATUS_2
		IF ( A .EQ. 12 ) THEN
C
C		   Convert to delta time format.
C
			IF ( BIN_1(1) .EQ. 0 .AND. BIN_1(2) .EQ. 0 ) THEN
				BIN_1(1) = '00000001'x
			ENDIF
C
			STATUS = LIB$SUBX( BIN_0, BIN_1, BIN_SCR, 2 )
			STATUS = SYS$ASCTIM
	1			( RESULT_S, RESULT, BIN_SCR, %VAL(0) )
			RESULT(5:5) = DASH
C
			IF ( DEBUG .NE. 0 ) WRITE(*,*) 
	1			PARAM(1:OP3_2), '=', RESULT
C
			IF ( STATUS .EQ. %LOC(SS$_IVTIME) ) THEN
				CALL LIB$STOP(TIME__OVRFLO)
			ENDIF
			STATUS_1 = 5
C
			IF ( STATUS_M .EQ. 0 ) THEN
				CALL LIB$STOP(TIME__OVRFLO)
			ENDIF
C
		ELSEIF ( A .EQ. 14 ) THEN
C
C		   Convert to integer time format.
C
			IF ( BIN_1(1) .LT. 0 .OR. BIN_1(2) .NE. 0 ) THEN
				CALL LIB$STOP(TIME__OVRFLO)
			ENDIF			
C
			STATUS = OTS$CVT_L_TI
	1			( BIN_1(1), RESULT, %VAL(1), %VAL(4) )
			I = LIB$SKPC( BLANK, RESULT )
			RESULT = RESULT(I:)
C
		ELSE
C
C		   Invalid multiplication requested.
C
			CALL LIB$STOP(TIME__INVMUL)
		ENDIF
C
C   ---------------------------------------------------------------------------
C
	ELSEIF ( PARAM(OP2_1:OP2_2) .EQ. DIVIDE ) THEN
C
C	   Divide the two values.
C
		STATUS = TIMEEDIV( BIN_2, BIN_1, BIN_1, BIN_SCR )
C
C	   Determine the output format and convert to the proper format.
C
		A = STATUS_1 + STATUS_2
		S = STATUS_1 - STATUS_2
		IF ( A .EQ. 12 .AND. S .EQ. -2 ) THEN
C
C		   Convert to delta time format.
C
			IF ( BIN_1(1) .EQ. 0 .AND. BIN_1(2) .EQ. 0 ) THEN
				BIN_1(1) = '00000001'x
			ENDIF
C
			STATUS = LIB$SUBX( BIN_0, BIN_1, BIN_SCR, 2 )
			STATUS = SYS$ASCTIM
	1			( RESULT_S, RESULT, BIN_SCR, %VAL(0) )
			RESULT(5:5) = DASH
C
			IF ( DEBUG .NE. 0 ) WRITE(*,*) 
	1			PARAM(1:OP3_2), '=', RESULT
C
			IF ( STATUS .EQ. %LOC(SS$_IVTIME) ) THEN
				CALL LIB$STOP(TIME__OVRFLO)
			ENDIF
			STATUS_1 = 5
C
		ELSEIF ( A .EQ. 14 .OR. ( A .EQ. 10 .AND. S .EQ. 0 ) ) THEN
C
C		   Convert to integer time format.
C
			IF ( BIN_1(1) .LT. 0 .OR. BIN_1(2) .NE. 0 ) THEN
				CALL LIB$STOP(TIME__OVRFLO)
			ENDIF			
C
			STATUS = OTS$CVT_L_TI
	1			( BIN_1(1), RESULT, %VAL(1), %VAL(4) )
			I = LIB$SKPC( BLANK, RESULT )
			RESULT = RESULT(I:)
C
		ELSE
C
C		   Invalid division requested.
C
			CALL LIB$STOP(TIME__INVDIV)
		ENDIF
C
C   ---------------------------------------------------------------------------
C
	ELSEIF ( PARAM(OP2_1:OP2_2) .EQ. QUESTION ) THEN
C
C	   Compare the two operands.
C
		STATUS = LIB$SUBX( BIN_1, BIN_2, BIN_SCR, 2 )
		IF ( BIN_SCR(2) .LT. 0 ) THEN
			RESULT = 'LESS_THAN'
		ELSEIF ( (BIN_SCR(2) + BIN_SCR(1)) .EQ. 0 ) THEN
			RESULT = 'EQUAL_TO'
		ELSE 
			RESULT = 'GREATER_THAN'
		ENDIF
		GOTO 1999
C
C   ---------------------------------------------------------------------------
C
	ELSEIF ( PARAM(OP2_1:OP2_2) .EQ. EQUAL_TO .OR.
	1	 PARAM(OP2_1:OP2_2) .EQ. '(EQ)' ) THEN
C
C	   Compare for equal.
C
		STATUS = LIB$SUBX( BIN_1, BIN_2, BIN_SCR, 2 )
		IF ( (BIN_SCR(2) + BIN_SCR(1)) .EQ. 0 ) THEN
			RESULT = 'YES'
		ELSE
			RESULT = 'NO'
		ENDIF
		GOTO 1999
C
C   ---------------------------------------------------------------------------
C
	ELSEIF ( PARAM(OP2_1:OP2_2) .EQ. NOT_EQUAL .OR.
	1	 PARAM(OP2_1:OP2_2) .EQ. '(NE)' ) THEN
C
C	   Compare for not equal.
C
		STATUS = LIB$SUBX( BIN_1, BIN_2, BIN_SCR, 2 )
		IF ( (BIN_SCR(2) + BIN_SCR(1)) .NE. 0 ) THEN
			RESULT = 'YES'
		ELSE
			RESULT = 'NO'
		ENDIF
		GOTO 1999
C
C   ---------------------------------------------------------------------------
C
	ELSEIF ( PARAM(OP2_1:OP2_2) .EQ. LESS_THAN .OR.
	1	 PARAM(OP2_1:OP2_2) .EQ. '(LT)' ) THEN
C
C	   Compare for less than.
C
		STATUS = LIB$SUBX( BIN_1, BIN_2, BIN_SCR, 2 )
		IF ( BIN_SCR(2) .LT. 0 ) THEN
			RESULT = 'YES'
		ELSE
			RESULT = 'NO'
		ENDIF
		GOTO 1999
C
C   ---------------------------------------------------------------------------
C
	ELSEIF ( PARAM(OP2_1:OP2_2) .EQ. LESS_THAN_EQUAL_TO .OR.
	1	 PARAM(OP2_1:OP2_2) .EQ. '(LE)' ) THEN
C
C	   Compare for less than or equal to.
C
		STATUS = LIB$SUBX( BIN_1, BIN_2, BIN_SCR, 2 )
		IF ( BIN_SCR(2) .LT. 0 ) THEN
			RESULT = 'YES'
		ELSEIF ( (BIN_SCR(2) + BIN_SCR(1)) .EQ. 0 ) THEN
			RESULT = 'YES'
		ELSE
			RESULT = 'NO'
		ENDIF
		GOTO 1999
C
C   ---------------------------------------------------------------------------
C
	ELSEIF ( PARAM(OP2_1:OP2_2) .EQ. GREATER_THAN .OR.
	1	 PARAM(OP2_1:OP2_2) .EQ. '(GT)' ) THEN
C
C	   Compare for greater than.
C
		STATUS = LIB$SUBX( BIN_2, BIN_1, BIN_SCR, 2 )
		IF ( BIN_SCR(2) .LT. 0 ) THEN
			RESULT = 'YES'
		ELSE
			RESULT = 'NO'
		ENDIF
		GOTO 1999
C
C   ---------------------------------------------------------------------------
C
	ELSEIF ( PARAM(OP2_1:OP2_2) .EQ. GREATER_THAN_EQUAL_TO .OR.
	1	 PARAM(OP2_1:OP2_2) .EQ. '(GE)' ) THEN
C
C	   Compare for greater than or equal to.
C
		STATUS = LIB$SUBX( BIN_2, BIN_1, BIN_SCR, 2 )
		IF ( BIN_SCR(2) .LT. 0 ) THEN
			RESULT = 'YES'
		ELSEIF ( (BIN_SCR(2) + BIN_SCR(1)) .EQ. 0 ) THEN
			RESULT = 'YES'
		ELSE
			RESULT = 'NO'
		ENDIF
		GOTO 1999
C
C   ---------------------------------------------------------------------------
C
	ELSE
C
C	   Invalid operator.
C
		CALL LIB$STOP(TIME__INVOPR)
	ENDIF
      ENDDO	
C
C   ---------------------------------------------------------------------------
C
C   See if there are any additional parameters on the line.
C
1999	CONTINUE
	STATUS = TIMEGET( PARAM(1:PARAM_S), OP3_1, OP3_2 )
	IF ( STATUS ) THEN
		CALL LIB$STOP(TIME__TOOMNYOPR)
	ENDIF
C
C   ---------------------------------------------------------------------------
C
C   Store the symbol in the symbol table, or output it to SYS$OUTPUT depending
C	on whether a symbol was defined.
C
	STATUS = STR$TRIM 
	1	( RESULT, RESULT, RESULT_S )
	IF ( SYMBOL_S .NE. 0 ) THEN
		STATUS = LIB$SET_SYMBOL
	1		( SYMBOL(1:SYMBOL_S), RESULT(1:RESULT_S) )
	ELSE
		STATUS = LIB$PUT_OUTPUT ( RESULT(1:RESULT_S) )
	END IF	
C
C   Exit.
C
	CALL EXIT(status)
	END