Commodore KERNAL History

If you have ever written 6502 code for the Commodore 64, you may remember using “JSR $FFD2” to print a character on the screen. You may have read that the jump table at the end of the KERNAL ROM was designed to allow applications to run on a all Commodore 8 bit computers from the PET to the C128 (and the C65!) – but that is a misconception. This article will show how

• the first version of the jump table in the PET was designed to only hook up BASIC to the system’s features
• it wasn’t until the VIC-20 that the jump table was generalized for application development (and the vector table introduced)
• all later machines add their own calls, but later machines don’t necessary support older calls.

KIM-1 (1976)

The KIM-1 was originally meant as a computer development board for the MOS 6502 CPU. Commodore acquired MOS in 1976 and kept selling the KIM-1. It contained a 2 KB ROM (“TIM”, “Terminal Interface Monitor”), which included functions to read characters from ($1E5A) and write characters to ($1EA0) a serial terminal, as well as code to load from and save to tape and support for the hex keyboard and display.

Commodore asked Microsoft to port their BASIC for 6502 to it, which interfaced with the monitor only through the two character in and out functions. The original source of BASIC shows how Microsoft adapted it to work with the KIM-1 by defining CZGETL and OUTCH to point to the monitor routines:

IFE     REALIO-1,<GETCMD==1
        DISKO==1
        OUTCH=^O17240                   ;1EA0
        ROMLOC==^O20000
        RORSW==0
        CZGETL=^O17132>

(The values are octal, since the assembler Microsoft used did not support hexadecimal.)

The makers of the KIM-1 never intended to change the ROM, so there was no need to have a jump table for these calls. Applications just hardcoded their offsets in ROM.

PET (1977)

The PET was Commodore’s first complete computer, with a keyboard, a display and a built-in tape drive. The system ROM (“KERNAL”) was now 4 KB and included a powerful file I/O system for tape and IEEE-488 (for printers and disk drives) as well as timekeeping logic. Another 2 KB ROM (“EDITOR”) handled screen output and character input. Microsoft BASIC was included in ROM and was marketed – with the name “COMMODORE BASIC” – as the actual operating system, making the KERNAL and the editor merely a device driver package.

Like with the KIM-1, Commodore asked Microsoft to port BASIC to the PET, and provided them with addresses of a jump table in the KERNAL ROM for interfacing with it. These are the symbol definitions in Microsoft’s source:

        CQOPEN=^O177700
        CQCLOS=^O177703
        CQOIN= ^O177706         ;OPEN CHANNEL FOR INPUT
        CQOOUT=^O177711         ;FILL FOR COMMO.
        CQCCHN=^O177714
        CQINCH=^O177717         ;INCHR'S CALL TO GET A CHARACTER
        OUTCH= ^O177722
        CQLOAD=^O177725
        CQSAVE=^O177730
        CQVERF=^O177733
        CQSYS= ^O177736
        ISCNTC=^O177741
        CZGETL=^O177744         ;CALL POINT FOR "GET"
        CQCALL=^O177747         ;CLOSE ALL CHANNELS

(The meaning of the CQ prefix is left as an exercise to the reader.)

In hex and with Commodore’s names, these are the KERNAL calls used by BASIC:

• $FFC0: OPEN
• $FFC3: CLOSE
• $FFC6: CHKIN
• $FFC9: CHKOUT
• $FFCC: CLRCHN
• $FFCF: BASIN
• $FFD2: BSOUT
• $FFD5: LOAD
• $FFD8: SAVE
• $FFDB: VERIFY
• $FFDE: SYS
• $FFE1: STOP
• $FFE4: GETIN
• $FFE7: CLALL
• $FFEA: UDTIM (advance clock; not used by BASIC)

At first sight, this jump table looks very similar to the one known from the C64, but it is indeed very different, and it is not generally compatible.

The following eight KERNAL routines are called from within the implementation of BASIC commands to deal with character I/O and the keyboard:

• $FFC6: CHKIN – set channel for character input
• $FFC9: CHKOUT – set channel for character output
• $FFCC: CLRCHN – restore character I/O to screen/keyboard
• $FFCF: BASIN – get character
• $FFD2: BSOUT – write character
• $FFE1: STOP – test for STOP key
• $FFE4: GETIN – get character from keyboard
• $FFE7: CLALL – close all channels

But the remaining six calls are not library calls at all, but full-fledged implementations of BASIC commands:

• $FFC0: OPEN – open a channel
• $FFC3: CLOSE – close a channel
• $FFD5: LOAD – load a file into memory
• $FFD8: SAVE – save a file from memory
• $FFDB: VERIFY – compare a file with memory
• $FFDE: SYS – run machine code

When compiled for the PET, Microsoft BASIC detects the extra commands “OPEN”, “CLOSE” etc., but does not provide an implementation for them. Instead, it calls out to these KERNAL functions when these commands are encountered. So these KERNAL calls have to parse the BASIC arguments, check for errors, and update BASIC’s internal data structures.

These 6 KERNAL calls are actually BASIC command extensions, and they are not useful for any other programs in machine code. After all, the whole jump table was not meant as an abstraction of the machine, but as an interface especially for Microsoft BASIC.

PET BASIC V4 (1980)

Version 4 of the ROM set, which came with significant improvements to BASIC and shipped by default with the 4000 and 8000 series, contained several additions to the KERNAL – all of which were additional BASIC commands.

• $FF93: CONCAT
• $FF96: DOPEN
• $FF99: DCLOSE
• $FF9C: RECORD
• $FF9F: HEADER
• $FFA2: COLLECT
• $FFA5: BACKUP
• $FFA8: COPY
• $FFAB: APPEND
• $FFAE: DSAVE
• $FFB1: DLOAD
• $FFB4: CATALOG/DIRECTORY
• $FFB7: RENAME
• $FFBA; SCRATCH
• $FFBD: DS$ (disk status)

Even though Commodore was doing all development on their fork of BASIC after version 2, command additions were still kept separate and developed as part of the KERNAL. In fact, for all Commodore 8-bit computers from the PET to the C65, BASIC and KERNAL were built separately, and the KERNAL jump table was their interface.

VIC-20 (1981)

The VIC-20 was Commodore’s first low-cost home computer. In order to keep the cost down, the complete ROM had to fit into 16 KB, which meant the BASIC V4 features and the machine language monitor had to be dropped and the editor was merged into the KERNAL. While reorganizing the ROM, the original BASIC command extensions (OPEN, CLOSE, …) were moved into the BASIC ROM (so the KERNAL calls for the BASIC command implementations were no longer needed).

The VIC-20 KERNAL is the first one to have a proper system call interface, which does not only include all calls required so BASIC is hardware-independent, but also additional calls not used by BASIC but intended for applications written in machine code. The VIC-20 Programmer’s Reference Manual documents these, making this the first time that machine code applications could be written for the Commodore 8 bit series in a forward-compatible way.

Old PET Calls

The following PET KERNAL calls are generally useful and therefore still supported on the VIC-20:

• $FFC6: CHKIN
• $FFC9: CHKOUT
• $FFCC: CLRCHN
• $FFCF: BASIN
• $FFD2: BSOUT
• $FFE1: STOP
• $FFE4: GETIN
• $FFE7: CLALL
• $FFEA: UDTIM

Channel I/O

The calls for the BASIC commands OPEN, CLOSE, LOAD and SAVE have been replaced by generic functions that can be called from machine code:

• $FFC0: OPEN
• $FFC3: CLOSE
• $FFD5: LOAD
• $FFD8: SAVE

(There is no separate call for VERIFY, since the LOAD function can perform this function based on its inputs.)

OPEN, LOAD and SAVE take more arguments (LA, FA, SA, filename) than fit into the 6502 registers, so two more calls take these and store them temporarily.

• $FFBA: SETLFS – set LA, FA and SA
• $FFBD: SETNAM – set filename

Two more additions allow reading the status of the last operation and to set the verbosity of messages/errors:

• $FFB7: READST – return status byte
• $FF90: SETMSG – set verbosity

BASIC uses all these functions to implement the commands OPEN, CLOSE, LOAD, SAVE and VERIFY. It basically parses the arguments and then calls the KERNAL functions.

IEC

The KERNAL also exposes a complete low-level interface to the serial IEC (IEEE-488) bus used to connect printers and disk drives. None of these calls are used by BASIC though, which talks to these devices on a higher level (OPEN, CHKIN, BASIN etc.).

• $FFB4: TALK – send TALK command
• $FFB1: LISTEN – send LISTEN command
• $FFAE: UNLSN – send UNLISTEN command
• $FFAB: UNTLK – send UNTALK command
• $FFA8: IECOUT – send byte to serial bus
• $FFA5: IECIN – read byte from serial bus
• $FFA2: SETTMO – set timeout
• $FF96: TKSA – send TALK secondary address
• $FF93: SECOND – send LISTEN secondary address

(SETTMO is only useful on systems with an IEEE-488 bus (PET/CBM, as well as serial IEC computers with an IEEE-488 cartridge). On all other systems, it only sets a flag that is never used anywhere.)

Memory

BASIC needs to know where usable RAM starts and where it ends, which is what the MEMTOP and MEMBOT function are for. They also allow setting these values.

• $FF9C: MEMBOT – read/write address of start of usable RAM
• $FF99: MEMTOP – read/write address of end of usable RAM

Time

BASIC supports the TI and TI$ variables to access the system clock. The RDTIM and SETTIM KERNAL calls allow reading and writing this clock.

• $FFDE: RDTIM – read system clock
• $FFDB: SETTIM – write system clock

These functions use the addresses that used to be the BASIC commands SYS and VERIFY on the PET.

Screen

Machine code applications may want to know the size of the text screen (SCREEN) and be able to read or set the cursor position (PLOT). The latter is used by BASIC to align text on tab positions.

• $FFED: SCREEN – get the screen resolution
• $FFF0: PLOT – read/write cursor position

I/O

On the PET, the BASIC’s random number generator for the RND command was directly reading the timers in THE VIA 6522 controller. Since the VIC-20, this is abstracted: The IOBASE function returns the start address of the VIA in memory, and BASIC reads from the indexes 4, 5, 8 and 9 to access the timer values.

• $FFF3: IOBASE – return start of I/O area

The VIC-20 Programmer’s Reference Guide states: “This routine exists to provide compatibility between the VIC 20 and future models of the VIC. If the I/O locations for a machine language program are set by a call to this routine, they should still remain compatible with future versions of the VIC, the KERNAL and BASIC.”

Vectors

The PET already allowed the user to override the following vectors in RAM to hook into some KERNAL functions:

• $00E9: input from keyboard
• $00EB: output to screen
• $0090: IRQ handler
• $0092: BRK handler
• $0094: NMI handler

The VIC-20 ROM replaces these vectors with a more extensive table of addresses in RAM at $0300 to hook core BASIC and KERNAL functions. The KERNAL ones start at $0314. The first three can be used to hook IRQ, BRK and NMI:

• $0314: CINV – IRQ handler
• $0316: CBINV – BRK handler
• $0318: NMINV – NMI handler

The others allow overriding the core set of KERNAL calls

• $031A: IOPEN – indirect entry to OPEN ($FFC0)
• $031C: ICLOSE – indirect entry to CLOSE ($FFC3)
• $031E: ICHKIN – indirect entry to CHKIN ($FFC6)
• $0320: ICKOUT – indirect entry to CHKOUT ($FFC9)
• $0322: ICLRCH – indirect entry to CLRCHN ($FFCC)
• $0324: IBASIN – indirect entry to CHRIN ($FFCF)
• $0326: IBSOUT – indirect entry to CHROUT ($FFD2)
• $0328: ISTOP – indirect entry to STOP ($FFE1)
• $032A: IGETIN – indirect entry to GETIN ($FFE4)
• $032C: ICLALL – indirect entry to CLALL ($FFE7)
• $032E: USRCMD – “User-Defined Vector”
• $0330: ILOAD – indirect entry to LOAD ($FFD5)
• $0332: ISAVE – indirect entry to SAVE ($FFD8)

The “USRCMD” vector is interesting: It’s unused on the VIC-20 and C64. On all later machines, this vector is documented as “EXMON” and allows hooking the machine code monitor’s command entry. The vector was presumably meant for the monitor from the beginning, but this feature was cut from these two machines.

The KERNAL documentation warns against changing these vectors by hand. Instead, the VECTOR call allows the application to copy the complete set of KERNAL vectors ($0314-$0333) from and to private memory. The RESTOR command sets the default values.

• $FF8D: VECTOR – read/write KERNAL vectors
• $FF8A: RESTOR – set KERNAL vectors to defaults

Custom IRQ Handlers

If an application hooks the IRQ vector, it could just insert itself and call code originally pointed to by the vector, or completely replace the IRQ code (and return with pulling the registers and RTI). In the latter case, it may still want the keyboard and the system clock to work. The PET already had the UDTIM ($FFEA) call to update the clock in the IRQ context. The VIC-20 adds SCNKEY to handle the keyboard and populating the keyboard buffer.

• $FF9F: SCNKEY – keyboard driver

CBM-II (1982)

The CBM-II series of computers was meant as a successor of the PET 4000/8000 series. The KERNAL’s architecture was based on the VIC-20.

The vector table in RAM is compatible except for ILOAD, ISAVE and USRCMD (which is now used), whose order was changed:

• $032E: ILOAD – indirect entry to LOAD ($FFD5)
• $0330: ISAVE – indirect entry to SAVE ($FFD8)
• $0332: USRCMD – machine code monitor command input

There are two new keyboard-related vectors:

• $0334: ESCVEC – ESC key vector
• $0336: CTLVEC – CONTROL key vector (unused)

And all IEEE-488 KERNAL calls except ACPTR can be hooked:

• $0346: ITALK – indirect entry to TALK ($FFB4)
• $0344: ILISTN – indirect entry to LISTEN ($FFB1)
• $0342: IUNLSN – indirect entry to UNLSN ($FFAE)
• $0340: IUNTLK – indirect entry to UNTLK ($FFAB)
• $033E: ICIOUT – indirect entry to CIOUT ($FFA8)
• $033C: IACPTR – indirect entry to ACPTR ($FFA5)
• $033A: ITKSA – indirect entry to TKSA ($FF96)
• $0338: ISECND – indirect entry to SECOND ($FF93)

For no apparent reason, the VECTOR and RESTOR calls have moved to different addresses:

• $FF84: VECTOR – read/write KERNAL vectors
• $FF87: RESTOR – set KERNAL vectors to defaults

And there are several new calls. All machines since the VIC-20 have a way to hand control to ROM cartridges instead of BASIC on system startup. At this point, no system initialization whatsoever has been done by the KERNAL, so the application or game on the cartridge can start up as quickly as possible. Applications that want to be forward-compatible can call into the following new KERNAL calls to initialize different parts of the system:

• $FF7B: IOINIT – initialize I/O and enable timer IRQ
• $FF7E: CINT – initialize text screen

The LKUPLA and LKUPSA calls are used by BASIC to find unused logical and secondary addresses for channel I/O, so its built-in disk commands can open channels even if the user has currently open channels – logical addresses have to be unique on the computer side, and secondary addresses have to be unique on the disk drive side.

• $FF8D: LKUPLA – search tables for given LA
• $FF8A: LKUPSA – search tables for given SA

It also added 6 generally useful calls:

• $FF6C: TXJMP – jump across banks
• $FF6F: VRESET – power-on/off vector reset
• $FF72: IPCGO – loop for other processor
• $FF75: FUNKEY – list/program function key
• $FF78: IPRQST – send IPC request
• $FF81: ALOCAT – allocate memory from MEMTOP down

C64 (1982)

Both the KERNAL and the BASIC ROM of the C64 are derived from the VIC-20, so both the KERNAL calls and the vectors are fully compatible with it, but some extensions from the CBM-II carried over: The IOINIT and CINT calls to initialize I/O and the text screen exist, but at different addresses, and a new RAMTAS call has been added, which is also useful for startup from a ROM cartridge.

• $FF87: RAMTAS – test and initialize RAM
• $FF84: IOINIT – initialize I/O and enable timer IRQ
• $FF81: CINT – initialize text screen

The other CBM-II additions are missing, since they are not needed, e.g. because BASIC doesn’t have the V4 disk commands (LKUPLA, LKUPSA) and because there is only one RAM bank (TXJMP, ALOCAT).

Plus/4 (264 Series, 1985)

The next Commodore 8 bit computers in historical order are the 264 series: the C16, the C116 and the Plus/4, which share the same general architecture, BASIC and KERNAL. But they are neither meant as successors of the C64, nor to the CBM-II series – they are more like spiritual successors of the VIC-20. Nevertheless, the KERNAL jump table and vectors are based on the C64.

Since the 264 machines don’t have an NMI, the NMI vector is missing, and the remaining vectors have been moved in memory. This makes most of the vector table incompatible with their predecessors:

• $0314: CINV – IRQ handler
• $0316: CBINV – BRK handler
• (NMI removed)
• $0318: IOPEN
• $031A: ICLOSE
• $031C: ICHKIN
• $031E: ICKOUT
• $0320: ICLRCH
• $0322: IBASIN
• $0324: IBSOUT
• $0326: ISTOP
• $0328: IGETIN
• $032A: ICLALL
• $032C: USRCMD
• $032E: ILOAD
• $0330: ISAVE

The Plus/4 is the first machine from the home computer series to include the machine code monitor, so the USRCMD vector is now used for command input in the monitor.

And there is one new vector, ITIME, which is called one every frame during vertical blank.

• $0312: ITIME – vertical blank IRQ

The Plus/4 supports all C64 KERNAL calls, plus some additions. The RESET call has been added to the very end of the table:

• $FFF6: RESET – restart machine

There are nine more undocumented entries, which are located at lower addresses so that there is an (unused) gap between them and the remaining calls. Since the area $FFD0 to $FF3F is occupied by the I/O area, these vectors are split between the areas just below and just above it. These two sets are known as the “banking routine table” and the “unofficial jump table”.

• $FCF1: CARTRIDGE_IRQ
• $FCF4: PHOENIX
• $FCF7: LONG_FETCH
• $FCFA: LONG_JUMP
• $FCFD: LONG_IRQ
• $FF49: DEFKEY – program function key
• $FF4C: PRINT – print string
• $FF4F: PRIMM – print string following the caller’s code
• $FF52: MONITOR – enter machine code monitor

The DEFKEY call has the same functionality as FUNKEY ($FF75) call of the CBM-II series, but the two take different arguments.

C128 (1985)

The Commodore 128 is the successor of the C64. Next to a 100% compatible C64 mode that used the original ROMs, it has a native C128 mode, which is based on the C64 (not the CBM-II or the 264), so all KERNAL vectors and calls are compatible with the C64, but there are additions.

The KERNAL vectors are the same as on the C64, but again, the USRCMD vector (at the VIC-20/C64 location of $032E) is used for command input in the machine code monitor. There are additional vectors starting at $0334 for hooking editor logic as well as pointers to keyboard decode tables, but these are not part of the KERNAL vectors, since the VECTOR and RESTOR calls don’t include them.

The set of KERNAL calls has been extended by 19 entries. The LKUPLA and LKUPSA calls from the CBM-II exist (because BASIC has disk commands), but they are at different locations:

• $FF59: LKUPLA
• $FF5C: LKUPSA

There are also several calls known from the Plus/4, but at different addresses:

• $FF65: PFKEY – program a function key
• $FF7D: PRIMM – print string following the caller’s code
• $FF56: PHOENIX – init function cartridges

And there are another 14 completely new ones:

• $FF47: SPIN_SPOUT – setup fast serial ports for I/O
• $FF4A: CLOSE_ALL – close all files on a device
• $FF4D: C64MODE – reconfigure system as a C64
• $FF50: DMA_CALL – send command to DMA device
• $FF53: BOOT_CALL – boot load program from disk
• $FF5F: SWAPPER – switch between 40 and 80 columns
• $FF62: DLCHR – init 80-col character RAM
• $FF68: SETBNK – set bank for I/O operations
• $FF6B: GETCFG – lookup MMU data for given bank
• $FF6E: JSRFAR – gosub in another bank
• $FF71: JMPFAR – goto another bank
• $FF74: INDFET – LDA (fetvec),Y from any bank
• $FF77: INDSTA – STA (stavec),Y to any bank
• $FF7A: INDCMP – CMP (cmpvec),Y to any bank

Interestingly, the C128 Programmer’s Reference Guide states that all calls since the C64 “are specifically for the C128 and as such should not be considered as permanent additions to the standard jump table.“

C65 (1991)

The C65 (also known as the C64X) was a planned successor of the C64 line of computers. Several hundred prerelease devices were built, but it was never released as a product. Like the C128, it has a C64 mode, but it is not backwards-compatible with the C128. Nevertheless, the KERNAL of the native C65 mode is based on the C128 KERNAL.

Like the CBM-II, but at different addresses, all IEE-488/IEC functions can be hooked with these 8 new vectors:

• $0335: ITALK – indirect entry to TALK ($FFB4)
• $0338: ILISTEN – indirect entry to LISTEN ($FFB1)
• $033B: ITALKSA – indirect entry to TKSA ($FF96)
• $033E: ISECND – indirect entry to SECOND ($FF93)
• $0341: IACPTR – indirect entry to ACPTR ($FFA5)
• $0344: ICIOUT – indirect entry to CIOUT ($FFA8)
• $0347: IUNTLK – indirect entry to UNTLK ($FFAB)
• $034A: IUNLSN – indirect entry to UNLSN ($FFAE)

The C128 additions of the jump table are basically supported, but three calls have been removed and one has been added. The removed ones are DMA_CALL (REU support), DLCHR (VDC support) and GETCFG (MMU support). All three are C128-specific and would make no sense on the C65. The one addition is:

• $FF56: MONITOR_CALL – enter machine code monitor

The removals and addition causes the addresses of the following calls to change:

• $FF4D: SPIN_SPOUT
• $FF50: CLOSE_ALL
• $FF53: C64MODE
• $FF59: BOOT_CALL
• $FF5C: PHOENIX
• $FF5F: LKUPLA
• $FF62: LKUPSA
• $FF65: SWAPPER
• $FF68: PFKEY
• $FF6B: SETBNK

The C128-added KERNAL calls on the C65 can in no way be called compatible with the C128, since several of the calls take different arguments, e.g. the INDFET, INDSTA, INDCMP calls take the bank number in the 65CE02’s Z register. This shows again that the C65 is no way a successor of the C128, but another successor of the C64.

Relationship Graph

The successorship of the Commodore 8 bit computers is messy. Most were merely spiritual successors and rarely truly compatible. The KERNAL source code and the features of the jump table mostly follow the successorship path, but some KERNAL features and jump table calls carried over between branches.

Which entries are safe?

If you want to write code that works on multiple Commodore 8 bit machines, this table will help:

	PET	VIC-20	C64 C128 C65 Plus4	CBM-II
$FF80	–		KERNAL Version	–
$FF81	–		CINT	–
$FF84	–		IOINIT	–
$FF87	–		RAMTAS	–
$FF8A	–	RESTOR		–
$FF8D	–	VECTOR		–
$FF90	–	SETMSG
$FF93	–	SECOND
$FF96	–	TKSA
$FF99	–	MEMTOP
$FF9C	–	MEMBOT
$FF9F	–	SCNKEY
$FFA2	–	SETTMO
$FFA5	–	IECIN
$FFA8	–	IECOUT
$FFAB	–	UNTLK
$FFAE	–	UNLSN
$FFB1	–	LISTEN
$FFB4	–	TALK
$FFB7	–	READST
$FFBA	–	SETLFS
$FFBD	–	SETNAM
$FFC0	–	OPEN
$FFC3	–	CLOSE
$FFC6	CHKIN
$FFC9	CHKOUT
$FFCC	CLRCHN
$FFCF	BASIN
$FFD2	BSOUT
$FFD5	–	LOAD
$FFD8	–	SAVE
$FFDB	–	SETTIM
$FFDE	–	RDTIM
$FFE1	STOP
$FFE4	GETIN
$FFE7	CLALL
$FFEA	UDTIM
$FFED	–	SCREEN
$FFF0	–	PLOT
$FFF3	–	IOBASE

Code that must work on all Commodore 8 bit computers (without detecting the specific machine) is limited to the following KERNAL calls that are supported from the first PET up to the C65:

• $FFCF: BASIN – get character
• $FFD2: BSOUT – write character
• $FFE1: STOP – test for STOP key
• $FFE4: GETIN – get character from keyboard

The CHKIN, CHKOUT, CLRCHN, CLALL and UDTIM would be available, but they are not useful, since they are missing their counterparts (opening a file, hooking an interrupt) on the PET. The UDTIM call would be available too, but there is no standard way to hook the timer interrupt if you include the PET.

Nevertheless, the four basic calls are enough for any text mode application that doesn’t care where the line breaks are. Note that the PETSCII graphical character set and the basic PETSCII command codes e.g. for moving the cursor are supported across the whole family.

If you are limiting yourself to the VIC-20 and above (i.e. excluding the PET but including the CBM-II), you can use the basic of 34 calls starting at $FF90.

You can only use these two vectors though – if you’re okay with changing them manually without going through the VECTOR call in order to support the CBM-II:

• $0314: CINV – IRQ handler
• $0316: CBINV – BRK handler

VECTOR and RESTOR are supported on the complete home computer series (i.e. if you exclude the PET and the CBM-II), and the complete set of 16 vectors can be used on all home computers except the Plus/4.

The initialization calls (CINT, IOINIT, RAMTAS) exist on all home computers since the C64. In addition, all these machines contain the version of the KERNAL at $FF80.

References

• KIM-1 Original Source Code
• Microsoft BASIC for 6502 Original Source Code [1978]
• PET ROM Disassembly by André Fachat
• VIC-20 ROM Disassembly by Lee Davison
• C16 ROM Dissasembly by Mike Dailly
• Comparative C64 ROM Disassembly Study Guide
• Commodore plus/4 and Commodore 16 Memory Map by Cameron Kaiser
• C64DX System Specification
• VIC-20 Programmer’s Reference Guide
• Addressed Listing of KERNAL Routines
• B128 KERNAL Routines, in: Transactor Vol 7 Issue 1, p. 45