Stack overflow while using H.KEYI hook

1. You should not disable and enable interrupts. Interrupts during H.KEYI are already disabled and should remain disabled. If you enable them, any non-V9990 interrupt (e.g. the V9938’s) will retrigger immediately after the ei / ret before the rest of the ISR is processed, causing a stack overflow.
2. You should move your ISR to page 3 (C000H and up). There is no guarantee about what slot or mapper segment is selected in page 2 at the moment the ISR is called.
3. You should preserve the old hook and call it at the end of your ISR when the interrupt was different from the one you meant to handle.
4. You do not need to preserve any registers in H.KEYI, so the push af / pop af is unnecessary. (You do need to preserve AF in H.TIMI.)

Point 1 is the one which caused your issue, but you should also address points 2 and 3 for proper hook handling.

Wow, that's the price you pay for leaving a project 4 years untouched...

ROUTINE:
    org #C000
    in a,(#66)
    bit 1,a
    jr z,SPLIT
    bit 0,a
    jr z,REFRESH
    ret
    
SPLIT:
    ld a,2
    out (#66),a
    ld a,13
    out (#64),a
    ld a,4
    out (#63),a
    ret

REFRESH:
    ld a,1
    out (#66),a
    ld a,13
    out (#64),a
    ld a,0
    out (#63),a
    ret

    
INICIO:
    di
    ld a,10
    out (#64),a
    ld a,32
    out (#63),a
    ld a,11
    out (#64),a
    ld a,0
    out (#63),a
    ld a,9
    out (#64),a
    ld a,2
    out (#63),a
    
    ld hl,#fd9a
    ld (hl),#cd
    inc hl
    ld (hl),#00
    inc hl
    ld (hl),#c0
    ei
    ret

    end INICIO

got a DI;HALT. Will investigate later.

More specific, you can put your ISR into another pages, but considering the possibilities:

- If working for 64KB system, put the full inter-slot jump at hook.
- For memory mapped systems, put an entry point to a page 3 intermediate caller that sets the slot and segment, call the ISR, and restores them.

This in the case you want to preserve the page 3 memory. Maybe for large ISR that are called eventually in response to some events. No feasible for ISR called often or if performance is required.

Yeah, that was an overlook
That specific ISR must be put on highest memory address available to user, because it will perform background animations, and doing so I will be able to use BASIC on this early development stage. But i took it from there (it was originally at #DC00 IIRC) because apparently GBASIC was messing with it (didn't investigated further)

Also, I already knew about interslot calls on hooks (RST30) but it wouldn't be pratical atm (I need to keep it simple for my own sanity)

Thiago, this code might help you, first to register into HKEY_I hook:

	ramad1		equ	0xF342

	di
	ld		(intr_handler+1), hl	; Replace in intr_handler the address
	;	save hookint 
	ld		hl, #hookint
	ld		de, #backup_hookint
	ld		bc, #5
	ldir
		
	ld		a, #0xF7				; RST_30 (interslot call both dos and bios)
	ld		(hookint), a
	ld		a, (ramad1)
	ld		(hookint+1), a
	ld		hl, #intr_handler
	ld		(hookint+2), hl
	ld		a, #0xc9
	ld		(hookint+4), a
	ei

backup_hookint:
	.ds		5

This might help you, even though it is intended to use interslot call, you can replace it by call to a P3 address if your routine is there, instead of using it, then you won't need ramad1 (slot of ram in page 1, which is the program ram in case of DOS, you might want to change to ramad2 depending on your needs, i.e.: if it is something running in BASIC, it will be running on page 2). It is important to backup the original hook 5 bytes so you can call it after doing your interrupt, you need to chain in this way, otherwise, it won't be nice to any other piece of BIOS/ROM/DRIVER that is hooking there and will no longer get called on interrupts... By the way, this code assumes HL has the address of your HKEY_I routine...

At the end of your program, you can try to get yourself out of the hook by doing this, but only if you are running a program, if you are doing resident stuff (i.e.: allocating a system mapper segment that gets called) this might not work as there is a good chance you are no longer the last to hook:

	di
	ld		hl, #backup_hookint
	ld		de, #hookint
	ld		bc, #5
	ldir
	ei
	ret

intr_handler:
	call	dummy_handler		; This will be replaced by user routine address
dummy_handler:
	jp		backup_hookint		; And continue processing interrupt hooks
	ret

And this is your code executing whenever an interrupt is called... As you can see, this is as generic as can be (this was my proposition, which I had help from DarkSchneider, for functions to register a SDCC function to HKEY_I interrupt). In your case, you might just erase the first LD after DI in the install routine, and below intr_handler put all your interrupt code, just make sure it ends with jp backup_hookint to execute the previous hook and has a ret below, so you will return after the backup hook returns...

This works quite well with SDCC and should work on your code as well.