Appledog

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
= VC-3 System Interrupt Table
The VC-3 is a system, running on the SD-8516.

== Introduction
I guess this interrupt system is part of the KERNAL, so should be more "VC-3" as it is system software. What follows is a simple list of the interrupt, what it does, it's calling parameters and it's return codes. I guess this should be called "Stellar BIOS V1" or "VC-3 KERNAL ROM" could be a nice name.

== Calling Convention
Each INT subsystem has it's own convention. However, the INT 05h system was done first so it represents a general convention you can expect going forward.

=== Parameters
* Function number: AH
* Small values such as char can go in AL. Otherwise, inputs can go in B. 
* Pointers: ELM, ELD

=== Returns
* Values: B, and C if needed
* Status: Carry flag
* Pointers: ELM, ELD (see calling convention)

=== Example Code
<codify armasm>
LDAL #'A'
LDB #1234
LDAH $11        ; VAR_SET
INT $05

LDELD @string
LDAH $62        ; IO_GETNUM  
INT $05
; B has parsed number
</codify>

== INT 05h - Pao Alto Tiny Basic
=== Memory Map
    ; PATB System Memory ($01ED00-$01EDFF, 256 bytes available)
    .equ PATB_VARIABLES     $01ED00   ; 26 vars × 2 bytes = 52 bytes ($01ED00-$01ED33)
    .equ PATB_EXPR_STACK    $01ED40   ; Expression stack, 64 bytes ($01ED40-$01ED7F)
    .equ PATB_EXPR_SP       $01ED80   ; Expression stack pointer (2 bytes)
    .equ PATB_GOSUB_STACK   $01ED82   ; GOSUB stack, 32 bytes (16 levels × 2 bytes)
    .equ PATB_GOSUB_SP      $01EDA2   ; GOSUB stack pointer (2 bytes)
    .equ PATB_FOR_STACK     $01EDA4   ; FOR stack, 40 bytes (8 levels × 5 bytes)
    .equ PATB_FOR_SP        $01EDCC   ; FOR stack pointer (2 bytes)
    .equ PATB_PROGRAM_PTR   $01EDCE   ; Current program line pointer (3 bytes)
    .equ PATB_IL_PTR        $01EDD1   ; Current IL instruction pointer (3 bytes)
    .equ PATB_INPUT_PTR     $01EDD4   ; Current input pointer (3 bytes)
    .equ PATB_RANDSEED      $01EDD7   ; Random seed (2 bytes)
    .equ PATB_STATUS        $01EDD9   ; Status flags (1 byte)
                                      ; Bit 0: Running (1) / Stopped (0)
                                      ; Bit 1: Error flag
                                      ; Bit 2: Break flag
    .equ PATB_PROGRAM_BASE  $030100   ; Start of program storage (Bank 3, offset $100)
    .equ PATB_PROGRAM_END   $03FFFF   ; End (almost 64KB for programs)

=== Function Dispatch
    ; === EXECUTION CONTROL (AH=$00-$0F) ===
    ;   AH=$00: RUN_PROGRAM    - Start execution from line number or beginning
    ;   AH=$01: STOP_PROGRAM   - Stop execution
    ;   AH=$02: CONTINUE       - Continue from current position
    ;   AH=$03: EXEC_IL_STEP   - Execute one IL instruction
    ;   AH=$04: EXEC_IL_CONT   - Execute IL until completion
    ;   AH=$05: GET_STATUS     - Get interpreter status
    ;   AH=$06: SET_STATUS     - Set interpreter status flags
    ;   AH=$07: RESET_INTERP   - Reset interpreter state
    ;
    ; === VARIABLE MANAGEMENT (AH=$10-$1F) ===
    ;   AH=$10: VAR_GET        - Get variable value by letter
    ;   AH=$11: VAR_SET        - Set variable value by letter
    ;   AH=$12: VAR_CLEAR_ALL  - Clear all variables to 0
    ;   AH=$13: VAR_GET_ADDR   - Get address of variable storage
    ;
    ; === EXPRESSION STACK (AH=$20-$2F) ===
    ;   AH=$20: EXPR_PUSH      - Push value to expression stack
    ;   AH=$21: EXPR_POP       - Pop value from expression stack
    ;   AH=$22: EXPR_PEEK      - Peek at top of stack
    ;   AH=$23: EXPR_CLEAR     - Clear expression stack
    ;   AH=$24: EXPR_DEPTH     - Get current stack depth
    ;
    ; === PROGRAM LINE MANAGEMENT (AH=$30-$3F) ===
    ; $30-$37: Search/Navigate
    ;   $30: LINE_FIND          - Find line by number (forward)
    ;   $31: LINE_NEXT          - Get next line
    ;   $32: LINE_FIND_REVERSE  - Find line by number (backward)
    ;   $33: LINE_PREV          - Get previous line
    ; $36-$39: Modify
    ;   $36: LINE_INSERT        - Insert or replace line
    ;   $37: LINE_DELETE        - Delete line by number
    ;   $38: LINE_REMOVE_SPACE  - Add space for new program line
    ;   $39: LINE_MAKE_SPACE    - remove unused line space
    ; $3A-$3F: Utility
    ;   $3A: LINE_FIRST         - Get first line
    ;   $3B: LINE_CLEAR_ALL     - Clear entire program (NEW)
    ;   $3C: LINE_COUNT         - Count total lines
    ;   $3F: PROGRAM_END        - ELM points to end of program
    ;
    ; === GOSUB/RETURN STACK (AH=$40-$4F) ===
    ;   AH=$40: GOSUB_PUSH     - Push return address for GOSUB
    ;   AH=$41: GOSUB_POP      - Pop return address for RETURN
    ;   AH=$42: GOSUB_CLEAR    - Clear GOSUB stack
    ;
    ; === FOR/NEXT STACK (AH=$50-$5F) ===
    ;   AH=$50: FOR_PUSH       - Push FOR loop context
    ;   AH=$51: FOR_POP        - Pop FOR loop context
    ;   AH=$52: FOR_PEEK       - Peek at current FOR loop
    ;   AH=$53: FOR_CLEAR      - Clear FOR stack
    ;   AH=$54: FOR_FIND_VAR   - Find FOR loop by variable letter
    ;
    ; === INPUT/OUTPUT HELPERS (AH=$60-$6F) ===
    ;   AH=$60: IO_GETCHAR     - Get next character from input buffer
    ;   AH=$61: IO_PUTCHAR     - Output character to screen
    ;   AH=$62: IO_GETNUM      - Parse number from input
    ;   AH=$63: IO_PUTNUM      - Output number to screen
    ;   AH=$64: IO_NEWLINE     - Output CR/LF
    ;   AH=$65: IO_GETLINE     - Get line of input from user
    ;   AH=$66: IO_PRINT_STR   - Print string at pointer
    ;
    ; === STRING/TOKEN HELPERS (AH=$70-$8F) ===
    ;   AH=$70: STR_COMPARE    - Compare strings for keyword matching
    ;   AH=$71: STR_TO_UPPER   - Convert string to uppercase
    ;   AH=$72: STR_SKIP_SPACE - Skip whitespace in ELM string
    ;   AH=$73: STR_IS_DIGIT   - Check if character is digit
    ;   AH=$74: STR_IS_ALPHA   - Check if character is letter
    ;   AH=$75: STR_LENGTH     - Get string length
    ;   AH=$76: STR_COPY       - Copy string from src to dst
    ;   AH=$77: STR_CONCAT     - Concatenate two strings
    ;   AH=$78: STR_LEFT       - Extract left N characters (LEFT$)
    ;   AH=$79: STR_RIGHT      - Extract right N characters (RIGHT$)
    ;   AH=$7A: STR_MID        - Extract middle substring (MID$)
    ;   AH=$7B: STR_CHR        - Convert byte to character (CHR$)
    ;   AH=$7C: STR_ASC        - Convert character to byte (ASC)
    ;   AH=$7D: STR_VAL        - Convert string to number (VAL)
    ;   AH=$7E: STR_STR        - Convert number to string (STR$)
    ;   AH=$7F: STR_FIND       - Find substring within string (INSTR)
    ;   AH=$80: STR_LTRIM      - Trim leading whitespace
    ;   AH=$81: STR_RTRIM      - Trim trailing whitespace
    ;   AH=$82: STR_TRIM       - Trim both leading and trailing whitespace
    ;   AH=$83: STR_REVERSE    - Reverse a string
    ;   AH=$84: STR_REPEAT     - Repeat character N times (STRING$)
    ;   AH=$85: STR_SPLIT      - Split string at delimiter
    ;   AH=$86: STR_REPLACE    - Replace substring with another
    ;   AH=$87-$8F: (Reserved for future string operations)
    ;
    ; === ARITHMETIC/LOGIC HELPERS (AH=$90-$9F) ===
    ;   AH=$90: MATH_ADD       - Pop two values, push sum
    ;   AH=$91: MATH_SUB       - Pop two values, push difference
    ;   AH=$92: MATH_MUL       - Pop two values, push product
    ;   AH=$93: MATH_DIV       - Pop two values, push quotient
    ;   AH=$94: MATH_NEG       - Negate top of stack
    ;   AH=$95: MATH_RND       - Generate random number
    ;   AH=$96-$9F: (Reserved)
    ;
    ; === COMPARISON HELPERS (AH=$A0-$AF) ===
    ;   AH=$A0: CMP_EQ         - Compare equal
    ;   AH=$A1: CMP_NE         - Compare not equal
    ;   AH=$A2: CMP_LT         - Compare less than
    ;   AH=$A3: CMP_GT         - Compare greater than
    ;   AH=$A4: CMP_LE         - Compare less than or equal
    ;   AH=$A5: CMP_GE         - Compare greater than or equal
    ;   AH=$A6-$AF: (Reserved)
    ;
    ; === ERROR HANDLING (AH=$B0-$BF) ===
    ;   AH=$B0: ERROR_SET      - Set error flag and message
    ;   AH=$B1: ERROR_GET      - Get current error code
    ;   AH=$B2: ERROR_CLEAR    - Clear error flag
    ;   AH=$B3: ERROR_PRINT    - Print error message
    ;   AH=$B4-$BF: (Reserved)
    ;
    ; === IL INTERPRETER CORE (AH=$F0-$FF) ===
    ;   AH=$F0: IL_INIT        - Initialize IL interpreter
    ;   AH=$F1: IL_LOAD        - Load IL code into memory
    ;   AH=$F2: IL_FETCH       - Fetch next IL instruction
    ;   AH=$F3: IL_DISPATCH    - Dispatch IL instruction
    ; ============================================================================



== INT 10h - Terminal Services
; ============================================================================
; INT 10h - KEYBOARD / TERMINAL SERVICES
; PC BIOS-style keyboard interrupt handler
; ============================================================================
; Function dispatch via AH register:
;   AH=00h: Read character (non-blocking)
;   AH=01h: Check if key available (in keyboar buffer)
;   AH=02h: Read character (blocking)
;   AH=03h: Get keyboard flags/shift state
;   AH=04h: Clear keyboard buffer
;   AH=05h: Push character into buffer

;   AH=10h: Clear screen (blank characters only)
;   AH=11h: Write character at cursor location
;   AH=12h: Read character at cursor location
;   AH=13h: Set color data at cursor location
;   Ah=14h: Get color data at cursor location
;   AH=15h: Set cursor position
;   AH=16h: Get cursor position
;   AH=17h: Write character at cursor (teletype)
;   AH=18h: Write string at cursor
;   Ah=19h: Read string between X,Y and cursor
;   AH=1Ah: Carriage Return
;   AH=1Bh: Issue Linefeed
;   AH=1Ch: Scroll screen up (linefeed_push forced linefeed)

;   AL=20h: Cursor Left (move cursor left one column)
;   AL=21h: Cursor Right (move cursor right one column)
;   AL=22h: Cursor Up (move cursor up one row)
;   AL=23h: Cursor Down (move cursor down one row)
;   AL=24h: Bell (audible beep - optional)
;   AL=25h: Backspace (move left and erase character)
;   AL=26h: Delete (pull line left from cursor to end of line)
;   AL=27h: Tab (move to next tab stop)
;   AL=29h: Home (move cursor to 0,0)

;   AL=30h: Clear to End of Line (erase from cursor to end of line)
;   AL=31h: Clear to End of Screen (erase from cursor to end of screen)
;   AL=32h: Insert Line (insert blank line at cursor row)
;   AL=33h: Delete Line (delete line at cursor row)

;   AH=40h: Set video mode
;   AH=41h: Get current video mode
;   AH=42h: Get video parameters (rows, cols)

=== Keyboard Services
NOTE: call numbers have been changed, update pending. See table above for the current call numbers.

=== AH=00h: Read character (non-blocking)
* returns character code in AL and keyboard flags in BL.

=== AH=01h: Read character (blocking)
* returns character code in AL, keyboard flags in BL, and time spent waiting in ms in C

=== AH=02h: Get keyboard flags
* returns keyboard flags in AL.

=== AH=03h: Check if key available
* returns the number of keys waiting in AL. I.E. 0=no keys available, 1+= has keys waiting.

=== AH=01h: Set cursor shape
=== AH=02h: Set cursor position
=== AH=03h: Get cursor position
=== AH=0Eh: Write character (teletype)
=== AH=13h: Write string


=== AH=40h: Set video mode
* Returns: AL is 00 on success, 01 if the mode failed to init.

Available modes:
* Mode 0: 22x23 console
* Mode 1: 40x25 console
* Mode 2: 80x25 console
* Mode 3: still thinking, graphics, or superterminal? 1280x800 "128x40"font via 10x20 charset??



== INT 12h - String Services
* [[INT 12h String Services]]

== INT 13h - Math Services
=== AH=00h: Multiply 16-bit
=== AH=01h: Divide 16-bit
=== AH=02h: Random number
=== AH=03h: Absolute value

== INT 14h - Memory Services
=== AH=00h: memcpy
=== AH=01h: memset
=== AH=02h: memcmp

== INT 15h - File/Storage (future)