; Copyright 1996 Acorn Computers Ltd
;
; Licensed under the Apache License, Version 2.0 (the "License");
; you may not use this file except in compliance with the License.
; You may obtain a copy of the License at
;
; http://www.apache.org/licenses/LICENSE-2.0
;
; Unless required by applicable law or agreed to in writing, software
; distributed under the License is distributed on an "AS IS" BASIS,
; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
; See the License for the specific language governing permissions and
; limitations under the License.
;
; > $.Source.PMF.osword
maxword * &16 ; highest known osword
; *****************************************************************************
MACRO
WordReturnV $cond
ASSERT "$cond"="" :LOR: "$cond"="VS"
[ "$cond"=""
Pull "R0-R4,R11,WsPtr,link,PC", VC
]
ADDVS R13, R13, #4 ; junk stacked R0
Pull "R1-R4,R11,WsPtr,link,PC", VS
MEND
; Main OsWord entry point
; R0,R1,R2 are parameters
OsWord
Push "R0-R4, R11, R12, R14"
CMP R0, #(maxword+1)
BLCC OsWordGo ; Call the subsid entry pt.
LDMIA R13, {R2-R4} ; R2=A, R3=X, R4=Y
MOV R1, #Service_UKWord ; osword service reason
CLRPSR V_bit, R0 ; in case there's no service
IssueService
TEQ R1, #0
STMEQIA R13, {R2-R4} ; if claimed, then update
; returned R0-R2
Pull "R0-R4, R11, R12, PC" ; pass V back from service
GoMyOsword
CLRPSR V_bit, R4
Pull "R0-R4, R11, R12, R14, PC"
; *****************************************************************************
OsWordGo ROUT
BYTEWS WsPtr
10 ; Point to despatch table
ADD PC, PC, R0, LSL #2 ; add in the action*4 and go
& 0
ASSERT DespatchWord-%BT10 = 8
; *****************************************************************************
DespatchWord
BAL OsWord00
BAL OsWord01
BAL OsWord02
BAL OsWord03
BAL OsWord04
BAL OsWord05
BAL OsWord06
BAL OsWord07
BAL OsWord08
BAL OsWord09
BAL OsWord0A
BAL OsWord0B
BAL OsWord0C
BAL OsWord0D
BAL OsWord0E
BAL OsWord0F
BAL OsWord10
BAL OsWord11
BAL OsWord12
BAL OsWord13
BAL OsWord14
BAL OsWord15
BAL OsWord16
; *****************************************************************************
; That's All Folks
; *****************************************************************************
; *****************************************************************************
; The OsWord routines themselves
; *****************************************************************************
; Osword Zero : Input a line
OsWord00 ROUT
[ NoARMv6 :LOR: NoUnaligned
LDRB R0, [R1, #0] ; lo-byte of address
LDRB R2, [R1, #1] ; hi-byte of address
ORR R0, R0, R2, LSL #8 ; R0 := address
|
; Use unaligned load from ARMv6
LDRH R0, [R1] ; 16-bit address(!)
]
LDRB R2, [R1, #3] ; lo limit
LDRB R3, [R1, #4] ; hi limit
LDRB R1, [R1, #2] ; length of buffer
MOV R4, #0 ; flags
SWI XOS_ReadLine32
WordReturnV VS
MOV R2, R1 ; put line length into R2
Pull "R0,R1,R3" ; don't overwrite R2
Pull "R3, R4, R11, R12, R14, PC"
; *****************************************************************************
; Read/Write System Clock
; entered with IRQs off
; in: R0 = 1 => read clock
; R0 = 2 => write clock
OsWord01 ROUT
OsWord02 ROUT
CMP R0, #2 ; C=1 <=> write clock
LDRB R0, TimerState
EORCS R0, R0, #&0F ; if writing, then write to other state
; in case user resets in middle
TEQ R0, #5 ; 5 => alpha, 10 => beta (C preserved)
ADREQ R2, TimerAlpha
ADRNE R2, TimerBeta
Swap R1, R2, CS ; if writing then R2 is destination
[ NoARMv6 :LOR: NoUnaligned
MOV R3, #5
10
LDRB R4, [R2], #1
STRB R4, [R1], #1
SUBS R3, R3, #1
BNE %BT10
|
; Use unaligned load/store from ARMv6
LDR R3, [R2], #4
LDRB R4, [R2]
STR R3, [R1], #4
STRB R4, [R1]
]
STRB R0, TimerState ; if writing, switch state
; (if reading, write current state)
MyOsWord
; *****************************************************************************
; Read/Write Interval Timer
; entered with IRQs off
; in: R0 = 3 => read interval timer
; R0 = 4 => write interval timer
OsWord03 ROUT
OsWord04 ROUT
CMP R0, #4 ; C=1 => write timer
MOVCS R2, R1 ; if writing then R1 is source
ADRCS R1, IntervalTimer
ADRCC R2, IntervalTimer ; else R2 is source
[ NoARMv6 :LOR: NoUnaligned
MOV R0, #5
10
LDRB R3, [R2], #1
STRB R3, [R1], #1
SUBS R0, R0, #1
BNE %BT10
|
; Use unaligned load/store from ARMv6
LDR R0, [R2], #4
LDRB R3, [R2]
STR R0, [R1], #4
STRB R3, [R1]
]
MyOsWord
; *****************************************************************************
; Perform a SOUND command
OsWord07 ROUT
TST R1, #3
BNE %FT05
LDMIA R1, {R0,R1}
SWI XSound_ControlPacked
MyOsWord
05
[ NoARMv6 :LOR: NoUnaligned
; Block not word aligned, so push it on the stack
SUB R13, R13, #8 ; create stack frame of 8 bytes
MOV R0, #7
10
LDRB R2, [R1, R0] ; copy block into stack frame
STRB R2, [R13, R0]
SUBS R0, R0, #1
BCS %BT10
Pull "R0, R1" ; then pull stack frame into R0 and R1
|
; Use unaligned load from ARMv6
LDR R0, [R1], #4
LDR R1, [R1]
]
SWI XSound_ControlPacked
MyOsWord
; *****************************************************************************
; Read the logical colour of a Pixel ( BASIC'S POINT function)
; Uses SWI ReadPoint
OsWord09 ROUT
Push R1 ; save pointer
[ NoARMv6 :LOR: NoUnaligned
LDRB R2, [R1, #0] ; X lo-byte
LDRB R0, [R1, #1] ; X hi-byte
ORR R0, R2, R0, LSL #8
MOV R0, R0, LSL #16 ; sign extend X
MOV R0, R0, ASR #16
LDRB R2, [R1, #2] ; Y lo-byte
LDRB R1, [R1, #3] ; Y hi-byte
ORR R1, R2, R1, LSL #8
MOV R1, R1, LSL #16 ; sign extend Y
MOV R1, R1, ASR #16
|
; Use unaligned load from ARMv6
LDRSH R0, [R1], #2
LDRSH R1, [R1]
]
SWI XOS_ReadPoint ; in: R0=X, R1=Y
; out: R2=colour, R3=tint, R4=0/-1 (on/off)
Pull R1
STRB R2, [R1, #4]
WordReturnV
; *****************************************************************************
; Read a character definition
OsWord0A ROUT
ByteToNosbod DoReadFont
MyOsWord
; *****************************************************************************
; Read the palette setting (VDU19,L,P,R,G,B)
OsWord0B ROUT
ByteToNosbod DoReadPalette
MyOsWord
; *****************************************************************************
; Write the palette setting (see VDU19)
OsWord0C ROUT
ByteToNosbod DoSetPalette
MyOsWord
; *****************************************************************************
; Read the last two graphics cursor positions
OsWord0D ROUT
ByteToNosbod DoOsWord13
MyOsWord
; *****************************************************************************
; Osword 14 (&0E) -- Read Real Time Clock
; Four (was six) different calls
; Read CMOS clock
OsWord0E ROUT
Push "R5-R8, R14" ; R0-R4 saved by Osword
MOV R4, R1 ; pointer to the Osword Block
LDRB R0, [R4, #0]
CMP R0, #1
BCC OsWord0EAlpha
BEQ OsWord0EBeta
CMP R0, #3
BCC OsWord0EGamma
BEQ OsWord0EDelta
[ {FALSE}
CMP R0, #5
BCC OsWord0EEpsilon
BEQ OsWord0EZeta ; this is getting ridiculous !
]
Pull "R5-R8, PC" ; unknown option
; *****************************************************************************
;
; OsWord0EAlpha - Read time as a string in the form
; eg Wed,01 Jan 1986.12:34:56
;
; in: R1 -> buffer for string
;
OsWord0EAlpha ROUT
; TMD 30-May-89: We want to enable IRQs here, but OS_ConvertDateAndTime
; loads bytes out of the block, and if IRQs are on it might end using an
; inconsistent value, so we must make a copy of the block on the stack
; and use that. The label OsWord0EDandT was used by a commented out routine
; in file 'RealTime' which will have to be rewritten if it needs to be
; included again.
ADR R0, RealTime ; load snapshot of 5 bytes of real time
LDMIA R0, {R0, R2} ; while IRQs are still off
Push "R0, R2" ; save on stack
CLRPSR I_bit, R0 ; enable IRQs now
OSWord0EReturnString
MOV R0, R13 ; point to stacked copy
; KJB 07-Sep-98: No-one is guaranteeing anywhere the length of %w3 or %m3 -
; see PRM 1-402 and 1-415. So give an indefinite buffer length here (making
; overflow the caller's problem - this call is obsolete anyway). Problem
; first noted with territory Japan, for which %m3 is potentially 5 bytes long.
MOV R2, #&10000000
ADR R3, TimeFormat
SWI XOS_ConvertDateAndTime
ADD R13, R13, #8 ; junk stack frame
MOVVC R0, #13 ; if no error
STRVCB R0, [R1] ; overwrite terminating 0 with CR
Pull "R5-R8,R14"
WordReturnV
TimeFormat
= "%w3,%dy %m3 %ce%yr.%24:%mi:%se", 0
ALIGN
; *****************************************************************************
;
; OsWord0EBeta - Read time in BCD format
;
; in: R4 -> parameter block
;
; out: [R4, #0] = year (00-99)
; [R4, #1] = month (01-12)
; [R4, #2] = day of month (01-31)
; [R4, #3] = day of week (01-07) Sun=01
; [R4, #4] = hours (00-23)
; [R4, #5] = minutes (00-59)
; [R4, #6] = seconds (00-59)
;
OsWord0EBeta ROUT
ADR R0, RealTime ; load snapshot of 5 bytes of real time
LDMIA R0, {R0, R2} ; while IRQs are still off
Push "R0, R2" ; save on stack
CLRPSR I_bit, R0 ; this may take some time
MOV R0,#-1
MOV R1,SP
SUB SP,SP,#36 ; Space for ordinals.
MOV R2,SP
SWI XTerritory_ConvertTimeToOrdinals
ADDVS SP,SP,#36+(2*4)
BVS OSWord0Eerror
; [R2] = CS. ; all values are for LOCAL time
; [R2+4] = Second
; [R2+8] = Minute
; [R2+12] = Hour (out of 24)
; [R2+16] = Day number in month.
; [R2+20] = Month number in year.
; [R2+24] = Year number.
; [R2+28] = Day of week.
; [R2+32] = Day of year
LDR R0,[R2,#24] ; Get year
LDR R1,=1900
SUB R0,R0,R1
01
CMP R0,#100
SUBGT R0,R0,#100
BGT %BT01 ; Get year MOD 100.
STRB R0,[R4,#0] ; Store it.
LDR R0,[R2,#20]
STRB R0,[R4,#1]
LDR R0,[R2,#16]
STRB R0,[R4,#2]
LDR R0,[R2,#28]
STRB R0,[R4,#3]
LDR R0,[R2,#12]
STRB R0,[R4,#4]
LDR R0,[R2,#8]
STRB R0,[R4,#5]
LDR R0,[R2,#4]
STRB R0,[R4,#6]
ADD SP,SP,#36+(2*4) ; junk stack frame and 5 byte time.
; now we have the time in hex in the parameter block
; so convert each item into BCD
MOV R1, #6 ; seven bytes to convert
10
LDRB R0, [R4, R1]
BL HexToBCD
STRB R0, [R4, R1]
SUBS R1, R1, #1
BPL %BT10
B OsWord0Eend
; *****************************************************************************
;
; OsWord0EGamma - Convert time in BCD format (at offsets 1..7)
; into string format at offsets (0..24)
;
; in: R4 -> BCD time
;
OsWord0EGamma ROUT
;build a block for Territory_ConvertOrdinalsToTime
; [R2] = CS. ; all values are for LOCAL time
; [R2+4] = Second
; [R2+8] = Minute
; [R2+12] = Hour (out of 24)
; [R2+16] = Day number in month.
; [R2+20] = Month number in year.
; [R2+24] = Year number.
SUB SP,SP,#28
MOV R2,SP
MOV R0,#0
STR R0,[R2]
LDRB R0,[R4,#7] ; Seconds
BL BCDToHex
STR R0,[R2,#4]
LDRB R0,[R4,#6] ; Minutes
BL BCDToHex
STR R0,[R2,#8]
LDRB R0,[R4,#5] ; Hours
BL BCDToHex
STR R0,[R2,#12]
LDRB R0,[R4,#3] ; Day of month
BL BCDToHex
STR R0,[R2,#16]
LDRB R0,[R4,#2] ; Month
BL BCDToHex
STR R0,[R2,#20]
LDRB R0,[R4,#1] ; Year
BL BCDToHex
LDR R1,=1900
ADD R0,R0,R1
STR R0,[R2,#24]
MOV R0,#-1
ADD R1,SP,#20 ; Put value on satck
SWI XTerritory_ConvertOrdinalsToTime
ADDVS SP,SP,#28
BVS OSWord0Eerror
ADD SP,SP,#20
MOV R1,R4
B OSWord0EReturnString ; Now we have 5 byte value on stack,
; use same code as OSWord0EAlpha
; *****************************************************************************
;
; OsWord0EDelta - Read 5-byte RealTime
;
; in: R4 -> block
;
; out: [R4, #0..4] = RealTime
;
OsWord0EDelta ROUT
LDR R1, RealTime +0
[ NoARMv6 :LOR: NoUnaligned
STRB R1, [R4, #0]
MOV R1, R1, LSR #8
STRB R1, [R4, #1]
MOV R1, R1, LSR #8
STRB R1, [R4, #2]
MOV R1, R1, LSR #8
STRB R1, [R4, #3]
|
; Use unaligned store from ARMv6
STR R1, [R4, #0]
]
LDRB R1, RealTime +4
STRB R1, [R4, #4]
; and drop thru to ...
OsWord0Eend
Pull "R5-R8, R14"
MyOsWord
OSWord0Eerror
Pull "R5-R8, R14"
WordReturnV
; *****************************************************************************
;
; GetDecimalPair - Get pair of decimal digits from [R4+R1+0..1]
;
; in: R1 is offset from R4 to find 1st digit
;
; out: if valid, R1=value of pair of digits, C=0
; if invalid, R1=undefined, C=1
; R10 is corrupted
;
GetDecimalPair ROUT
LDRB R10, [R1, R4]! ; get hi-digit
SUB R10, R10, #"0" ; put in range 0..9
CMP R10, #10 ; C=1 if bad digit
ADD R10, R10, R10, LSL #2 ; R10 = 5*hi
LDRB R1, [R1, #1] ; get lo-digit
SUB R1, R1, #"0" ; put in range 0..9
CMPCC R1, #10 ; C=1 if bad digit
ADD R1, R1, R10, LSL #1 ; R1 = lo + 2*(5*hi)
MOV PC, R14
; *****************************************************************************
; Osword 15 (&0F) Write the Real Time Clock.
; Three different calls
OsWord0F ROUT
CLRPSR I_bit, R0 ; this may take some time
Push "R5-R10, R14"
MOV R4, R1 ; Copy the parameter block pointer
LDRB R0, [R1]
MOV R9, #0
TEQ R0, #5 ; write all of time (5-byte UTC)
BEQ OsWord0F_5byte
TEQ R0, #8 ; write hours, minutes, seconds
MOVEQ R9, #1
TEQ R0, #15 ; write day, date, month, year
MOVEQ R9, #2
TEQ R0, #24 ; write all of time
MOVEQ R9, #3
TEQ R9, #0
Pull "R5-R10, PC", EQ ; unknown call, pass it on
; first set up data in registers as follows :-
; R0 = hours
; R1 = minutes
; R2 = days
; R3 = months
; (R4 -> block)
; R5 = year(lo)
; R6 = year(hi)
; R7 = seconds
; R8 = centiseconds
TST R9, #2
BEQ %FT01
; KJB 980908 - can't assume length of date, as %w3, %dy and %m3 may be any length. Unfortunately,
; the string may not be terminated. Best we can do is plop a terminator at the maximum length position,
; which will at least cope with territories with fixed-length strings. Territories with variable length
; strings may work anyway, as territory modules are quite good at ignoring trailing junk. I've
; fixed things I've spotted that didn't terminate, such as BASIC.
SUB SP, SP, #48
MOV R0, #-1
MOV R2, SP ; R1 points to real memory - contents don't matter to us
SWI XTerritory_ReadCalendarInformation
ADDVS SP, SP, #48
BVS Bad0F
; need to work out maximum length of "%w3,%dy %m3 %ce%yr[.%24:%mi:%se]"
TST R9, #1
MOVEQ R0, #7 ; length of ", %ce%yr"
MOVNE R0, #16 ; length of ", %ce%yr.%24:%mi:%se"
LDR R10, [R2, #24]
LDR R14, [R2, #28]
ADD R0, R0, R10 ; + max length of %w3
LDR R10, [R2, #40]
ADD R0, R0, R14 ; + max length of %dy
ADD R0, R0, R10 ; + max length of %m3
ADD SP, SP, #48
01 ADD r10, r0, #3+1 ; round up number of bytes in block to word boundary, including null terminator
BIC r10, r10, #3
SUB sp, sp, r10
ADD r2, r1, #1 ; point at actual string
MOV r1, #0
02
LDRB r14, [r2, r1] ; copy string (not terminated) on stack
STRB r14, [sp, r1]
ADD r1, r1, #1
TEQ r1, r0 ; have we copied all bytes of string?
BNE %BT02 ; loop if not
MOV r14, #0 ; null terminator
STRB r14, [sp, r0]
MOV r0,#-1 ; set things up for territory SWI - r0 = -1 for current territory
MOV r1, r9 ; r1 = reason code (1, 2 or 3)
MOV r2, sp ; r2 -> terminated string on stack
SUB sp, sp, #36 ; get space for result.
MOV r3, sp
SWI XTerritory_ConvertTimeStringToOrdinals
ADDVS sp, sp, #36 ; if error then junk return block
ADDVS sp, sp, r10 ; and junk variable length string on stack
BVS Bad0F
CMP r9, #2 ; if just writing the date, write it !
BEQ %FT10
BGT %FT05 ; if writing everything just get UTC time
; We only have the time from the string, we now need the date
; because changing the time may change it.
ADR r0, RealTime
LDMIA r0, {r0,r1} ; LDM is atomic wrt interrupts
Push "r0,r1" ; put value on stack
MOV r0,#-1 ; use configured territory.
ADD r2, sp, #8
LDMIA r2, {r3-r6} ; preserve time values from entry string
MOV r1, sp
SWI XTerritory_ConvertTimeToOrdinals ; get ordinals for current time
ADDVS sp, sp, #44 ; 36 From above + 8 for 5 byte time
ADDVS sp, sp, r10 ; and junk string as well
BVS Bad0F
ADD sp, sp, #8 ; dump 5 byte time on TOS
STMIA r2, {r3-r6} ; restore the time we read from the string.
05
; Now [SP] -> ordinals in local time, but we want time in UTC
; First convert the ordinals to 5 byte UTC time
MOV r0, #-1 ; use configured territory.
MOV r2, sp ; r2 -> ordinals block
SUB sp, sp, #8 ; two more words to contain 5 byte time
MOV r1, sp
SWI XTerritory_ConvertOrdinalsToTime
ADDVS sp, sp, #44 ; 36 From above + 8 for 5 byte time.
ADDVS sp, sp, r10 ; and junk string as well
BVS Bad0F
; Now we have a 5 byte UTC time, convert it to UTC ordinals
MOV r1, sp ; our 5 byte time
ADD r2, sp, #8 ; place to put ordinals
SWI XTerritory_ConvertTimeToUTCOrdinals
ADDVS sp, sp, #44 ; 36 bytes ordinals + 8 for 5 byte time.
ADDVS sp, sp, r10 ; and junk string as well
BVS Bad0F
ADD sp, sp, #8 ; discard 5 byte time
10
; Load the registers. (SP->Ordinals)
LDR r8, [sp], #4 ; centiseconds
LDR r7, [sp], #4 ; seconds
LDR r1, [sp], #4 ; minutes
Pull "r0,r2,r3,r5" ; hours, day of month, month, year
ADD sp, sp, #8 ; junk day of week, day of year
ADD sp, sp, r10 ; and string on stack
MOV r4, #100
DivRem r6, r5, r4, r14 ; r5 = Year (lo), r6 = Year (hi)
BL SetTime ; also updates 5-byte RealTime
Bad0F ; come here if setting invalid
Pull "R5-R10, R14"
MyOsWord
OsWord0F_5byte
SUB SP, SP, #36
ADD R1, R1, #1 ; process the user's 5-byte block
MOV R2, SP
SWI XTerritory_ConvertTimeToUTCOrdinals
ADDVS SP, SP, #36
BVS Bad0F
MOV R10, #0 ; no string on stack
B %BT10 ; nip back in to the main handler
; *****************************************************************************
;
; CheckYear - Check for year wrap (year in RTC <> year "YearCMOS")
; and for leap year fudging
;
CheckYear ROUT
Push "R0,R1,R2,R14"
LDR R0, =ZeroPage
LDR R0, [R0, #RTCFitted]
[ HAL
CMP R0, #2048
[ RTCSupport
BLO %FT8
|
BLO %FT15
]
; Ask the RTC what it thinks the year is
Push "R3,R10,R12"
MOV R10, R0
SUB R13, R13, #RTCTimeStruct_BCD_Size
MOV R1, R13
ADRL R2, HALRTC_IICOp
MOV LR, PC
LDR PC, [R0, #HALDevice_RTCReadTime]
; Did we succeed?
CMP R0, #RTCRetCode_OK
LDRB R0, [R13, #RTCTimeStruct_BCD_YearLO]
LDRB R1, [R13, #RTCTimeStruct_BCD_YearHI]
ADD R13, R13, #RTCTimeStruct_BCD_Size
LDRB R2, [R10, #HALDevice_RTCFormatFlags]
Pull "R3,R10,R12"
BNE %FT15
ASSERT RTCFormatFlags_BCD_NeedsYearHelp = 1 :SHL: 2
ASSERT RTCFormatFlags_BCD_YearLOIsGood = 1 :SHL: 3
AND LR, R2, #RTCFormatFlags_BCD_NeedsYearHelp + RTCFormatFlags_BCD_YearLOIsGood
MOVS LR, LR, ROR #3 ; CC = good, CS+EQ = 2 bit, CS+NE = BCD
ADDCS R1, LR, #RTCAddressPHI+1 ; 2 bit=RTCAddressPHI+1, BCD!=RTCAddressPHI+1
BCS %FT9
; Year is reliable; convert R0 & R1 to ints and update CMOS if necessary.
BL BCDToHex
MOV R2, R1
MOV R1, R0 ; YearLO
MOV R0, #YearCMOS
BL Read
CMP R0, R1
MOVNE R0, #YearCMOS
BLNE Write
MOV R0, R2
BL BCDToHex
MOV R1, R0 ; YearHI
MOV R0, #YearCMOS+1
BL Read
CMP R0, R1
MOVNE R0, #YearCMOS+1
BLNE Write
B %FT15
8
] ; HAL
[ RTCSupport :LOR: :LNOT: HAL
TEQ R0, #RTCAddressPHI
MOVEQ R1, #5
MOVNE R1, #6 ; year address (dependant on RTC)
STRB R1, [R13, #-4]!
MOV R1, R13
ORR R0, R0, #1:SHL:29
MOV R2, #1
BL IIC_Op
ORR R0, R0, #1
BL IIC_Op
AND R1, R0, #&FF
LDRB R0, [R13], #4
TEQ R1, #RTCAddressPHI+1
] ; RTCSupport :LOR: :LNOT: HAL
9
MOVEQ R0, R0, LSR #6 ; R0= year MOD 4.
BLNE BCDToHex
MOV R2, R0 ; remember RTC value
MOV R0, #YearCMOS
BL Read
TEQ R1, #RTCAddressPHI+1
ANDEQ R1, R0, #3
MOVNE R1, R0
MOVEQ R14,#4
MOVNE R14,#100
SUBS R2, R2, R1 ; same year ?
Pull "R0,R1,R2,PC", EQ ; [yes, so no bother]
ADDCC R2, R2, R14 ; if lower, then must be carry
ADD R2, R0, R2 ; new year value
CMP R2, #100
BCC %FT10 ; no carry thru to next century
SUB R2, R2, #100
MOV R0, #YearCMOS +1
BL Read
ADD R1, R0, #1
TEQ R1, #100
MOVEQ R1, #0 ; wrap century
MOV R0, #YearCMOS +1
BL Write
10
MOV R1, R2
MOV R0, #YearCMOS
BL Write
15
BL RTCToRealTime
Pull "R0,R1,R2,PC"
; *****************************************************************************
; Define hardware cursor size, shape and active point
OsWord15
ByteToNosbod DoPointerStuff
MyOsWord
; *****************************************************************************
; Set start of screen address (for VDU drivers and display)
; [R1, #0] = bit mask (bit0 set => change drivers; bit1 set => change display)
; [R1, #1..4] = byte offset from start of screen memory
OsWord16
ByteToNosbod DoSetScreenStart
MyOsWord
; **************************************************************************
; All the unused OS_Word calls
; Read Byte of I/O proc memory
OsWord05 ROUT
; Write byte of I/O proc memory
OsWord06 ROUT
; Define an ENVELOPE
OsWord08 ROUT
; Allocated to the net
OsWord10
OsWord11
OsWord12
OsWord13
OsWord14
Unused
LTORG
END