MOV	A,saveacc
		MOV	PSW,savepsw
		USING	0		; Registerbank 0 for following code

IF (TIMESHARING == 0)
; Round Robin Task Switching not required.  System Interrupt ends here
?RTX?SET_ISR:	
IF (CPU_IDLE_CODE)
                SETB	?RTX_ISR_SIG
ENDIF
		RET	
ENDIF

IF (TIMESHARING)
; Round Robin Task Switching required.  Check if task generates timeout
; Check for Round Robin Timeout on the current task
		JNB	?RTX_TS_DELAY,CheckRobinTime
NoRobinTimeout:	
?RTX?SET_ISR:	
IF (CPU_IDLE_CODE)
                SETB	?RTX_ISR_SIG
ENDIF
                RET	
CheckRobinTime: DJNZ     ?RTX_ROBINTIME,NoRobinTimeout

?RTX_TASKSWITCHING:
		PUSH	ACC
		PUSH	PSW
		PUSH	B
		PUSH	DPH
		PUSH	DPL
		PUSH	AR0
		PUSH	AR1
		PUSH	AR2
		PUSH	AR3
		PUSH	AR4
		PUSH	AR5
		PUSH	AR6
		PUSH	AR7
IF (CODE_BANKING <> 0)
		PUSH	?B_CURRENTBANK
ENDIF

		MOV	A,?RTX_CURRENTTASK
		RL	A
		ADD	A,#?RTX?TASKSTATE?S+1
		MOV	R0,A
		MOV     A,#K_ROBIN
		CLR	EA
		ORL	A,@R0
		MOV	@R0,A
		SETB	EA
IF (CODE_BANKING <> 0)
		SJMP    os_switch_task1
ENDIF
ENDIF

;------------------------------------------------
; Perform a Task-Switch
;  void os_switch_task (void)
;      uchar i;
;      uchar limit;

;---- Variable 'current' assigned to Register 'R6' ----
;---- Variable 'next' assigned to Register 'R7' ----
;---- Variable 'i' assigned to Register 'R0' ----
;---- Variable 'limit' assigned to Register 'R5' ----
;
;------------------------------------------------

os_switch_task:

IF (CODE_BANKING <> 0)
		PUSH	?B_CURRENTBANK
ENDIF

os_switch_task1:

;      next = current;
IF (TIMESHARING <> 0)
		SETB	?RTX_TS_DELAY		; Delay Task Switching
ENDIF
		MOV	A,?RTX_CURRENTTASK
		MOV	R7,A
;      while (1)  {
		RL	A
		ADD	A,#?RTX?TASKSTATE?S+1
		MOV	R0,A
?C0001:
;        if (++next == MAXTASKN+1)  next = 0;
		INC     R7
		INC	R0
		INC	R0
IF (CPU_IDLE_CODE)
		MOV	A,R7
		CJNE	A,?RTX_CURRENTTASK,NoIDLE
		JBC	?RTX_ISR_SIG,NoIDLE
		CPU_IDLE          ; CPU sleep
NoIDLE:
ENDIF
		CJNE    R7,#?RTX_MAXTASKN+1,?C0003
		MOV	R7,#0
		MOV	R0,#?RTX?TASKSTATE?S+1
?C0003:
;        if (STATE[next].st & K_READY)  break;
		MOV     A,@R0
		JNB     ACC.B_READY,?C0001
;      }
;

PUBLIC	?RTX_NEXTID
PUBLIC  ?RTX_NEXTTASK

?RTX_NEXTID	EQU	AR7
?RTX_NEXTTASK:	NOP		; for Debugging

;      while (current < next)  {
?C0005:
		MOV     A,?RTX_CURRENTTASK
		CLR     C
		SUBB    A,R7
		JNC     ?C0011

;        current++;
		INC	?RTX_CURRENTTASK
;        i = STKP[current];
		MOV     A,#?RTX?TASKSP?S
		ADD     A,?RTX_CURRENTTASK
		MOV     R0,A
		MOV     A,@R0
		MOV     R5,A
;        STKP[current] = SP;
		MOV     @R0,SP
;        if (current == MAXTASKN) limit = RAMTOP;
		INC	R0
		MOV	A,@R0
		MOV	R6,?RTX_CURRENTTASK
		CJNE	R6,#?RTX_MAXTASKN,?C0007
		MOV	A,#RAMTOP
?C0007:
		XCH	A,R5
		MOV	R0,A
;        else                       limit = STKP[current+1];
;
;        while (i != limit)  {
?C0009:
		MOV     A,R0
		XRL     A,R5
		JZ      ?C0005
;          SP++;
;          i++;
;          STACK[SP] = STACK[i];
		INC	R0
		MOV	A,@R0
		PUSH	ACC
		SJMP    ?C0009
;        }
;      }
?C0011:
;
;      while (current > next)  {
		MOV     A,?RTX_CURRENTTASK
		SETB    C
		SUBB    A,R7
		JC      ?C0012
	
		MOV	A,?RTX_CURRENTTASK
		ADD	A,#?RTX?TASKSP?S+1
		MOV	R0,A
		MOV	A,@R0
;        if (current == (MAXTASKN)) i = RAMTOP;
;        else                       i = STKP[current+1];
		MOV	R6,?RTX_CURRENTTASK
		CJNE	R6,#?RTX_MAXTASKN,?C0013
		MOV	A,#RAMTOP
?C0013:
		MOV	R5,A
;        limit = STKP[current];
		DEC	R0
		MOV	A,@R0
		XCH	A,R5
		MOV	R0,A
;
;        while (SP != limit)  {
?C0015:
		MOV     A,SP
		XRL     A,R5
		JZ      ?C0016
;          STACK[i] = STACK[SP];
;          i--;
;          SP--;
		POP	ACC
		MOV	@R0,A
		DEC	R0

		SJMP    ?C0015
?C0016:
;        }
;        STKP[current] = i;
		MOV	A,?RTX_CURRENTTASK
		ADD	A,#?RTX?TASKSP?S
		XCH	A,R0
		MOV	@R0,A
;        current--;
		DEC	?RTX_CURRENTTASK
		SJMP	?C0011
?C0012:
;      }

;      RoundRobinTime = ?RTX_TIMESHARING
IF (TIMESHARING)
		MOV	?RTX_ROBINTIME,#TIMESHARING
ENDIF
         
;       if (STATE[current].st & K_ROBIN)  goto RobinOn;
		MOV	A,?RTX_CURRENTTASK
		RL	A
		ADD	A,#?RTX?TASKSTATE?S+1
		MOV	R0,A
		MOV	R7,#SIG_EVENT
		CLR	EA
		MOV	A,@R0
IF (TIMESHARING)
		JBC	ACC.B_ROBIN,RobinOn
ENDIF
;       if ((STATE[current].st & K_SIG) && (STATE[current].st & SIG_EVENT)
;          goto SignalOn;
                JNB	ACC.B_WAITSIG,SignalOff
		JBC	ACC.B_SIGNAL,SignalOn
SignalOff:
;       if ((STATE[current].st & K_TMO) && (STATE[current].st & TMO_EVENT)
;          goto TimeOutOn;
                MOV     R7,#0		; No Event
		JNB	ACC.B_WAITTIM,NoEvent
		JNB	ACC.B_TIMEOUT,NoEvent
TimeOutOn:	
		MOV	R7,#TMO_EVENT
		ANL	A,#0F4H
SignalOn:
NoEvent:	CLR	ACC.B_RDY	; Clear RDY bit
		XCH	A,@R0
		SETB	EA

		ANL	A,#K_RDY
		ORL	AR7,A
IF (TIMESHARING <> 0)
  IF (CODE_BANKING)
                POP	ACC
		CALL	?B_RESTORE_BANK
  ENDIF
		CLR	?RTX_TS_DELAY
		RET
ELSE
  IF (CODE_BANKING)
                POP	ACC
		JMP	?B_RESTORE_BANK
  ENDIF
		RET
ENDIF
		
		

;------------------------------------------------
IF (TIMESHARING <> 0)
RobinOn:	MOV	@R0,A
		SETB	EA
IF (CODE_BANKING)
		POP	ACC
		CALL	?B_RESTORE_BANK
ENDIF
		POP	AR7
		POP	AR6
		POP	AR5
		POP	AR4
		POP	AR3
		POP	AR2
		POP	AR1
		POP	AR0
		POP	DPL
		POP	DPH
		POP	B
		POP	PSW
		POP	ACC
		CLR	?RTX_TS_DELAY
		RET			; Restart Task
ENDIF
;    }
;  }



;------------------------------------------------
; Start RTX-51 Tiny Kernel
;------------------------------------------------

EXTRN CODE (?C_STARTUP)
PUBLIC	main

main:	MOV	R0,#?RTX?TASKSP?S
		MOV	@R0,SP
		MOV	A,#?RTX_MAXTASKN
		JZ	main2
		MOV	R7,A
main1:		INC	R0
		MOV	@R0,#RAMTOP
		DJNZ	R7,main1
main2:		MOV	R7,#?RTX_MAXTASKN+1
		CLR	A
		MOV	R0,#?RTX?TASKSTATE?S
main1x:		MOV	@R0,A
		INC	R0
		MOV	@R0,A
		INC	R0
		DJNZ	R7,main1x
		MOV	R0,#?RTX?TASKSTATE?S+1
		MOV	@R0,#K_ACTIVE+K_READY
		MOV	DPTR,#?RTX?TASKENT?S
		MOV	A,#1
		MOVC	A,@A+DPTR
		PUSH	ACC
		CLR	A
		MOVC	A,@A+DPTR
		PUSH	ACC
IF (TIMESHARING <> 0)
		MOV	?RTX_ROBINTIME,#TIMESHARING
ENDIF
		ORL	TMOD,#01H	; Timer 0 Mode 1
		MOV	TL0,#LOW (?RTX_CLOCK)
		MOV	TH0,#HIGH (?RTX_CLOCK)
		SETB	TR0
		SETB	EA
		SETB	ET0
		RET		; Start Task 0


;------------------------------------------------

PUBLIC ?RTX_TASKIDX
?RTX_TASKIDX:	DB	?RTX_MAXTASKN		; for Debugging

                END