The following FLOS kernal routines can be executed simply by using a “CALL name” instruction, with registers pre-set to the routines requirements (Remember to INCLUDE the labels definitions from the equates folder.)

EG:

---------------------------------------------------------------------------------

         LD HL,  my_text
         CALL    kjt_print_string

         [rest of program..]
	
my_text  DB "HELLO WORLD!",0

----------------------------------------------------------------------------------

Notes

• Kernal calls should not be made when the Video RAM is paged in. The only routine that is guaranteed to work in that situation is “kjt_page_out_video”
• It should be assumed that Kernal calls trash all registers, unless a routine's documentation says otherwise.

Some Details:

There are two main ways to load a file, a simple single-call approach and a more flexible random-access approach.

To do a simple file load, set HL to a zero terminated ASCII filename string, IX to the destination address and B to the destination bank, then call “kjt_load_file” Check the return code - see table below - if the zero flag is set, everything is OK.

The more flexible way to load file data is as follows: Set HL to a zero terminated ASCII filename string and call “kjt_open_file”. If the zero flag is set on return, the file was found and the length of the file will be in IX:IY (if the zero flag is not set, check the error code).

Next, the following two routines can be called *if required*

“kjt_set_file_pointer” - This allows data to be read from anywhere within a file, instead of right from the start. Registers required:

• IX:IY = Offset in bytes from start of file
  

“kjt_set_read_length” - This allows the length of transfer to be set. Registers required:

• IX:IY = Bytes to load
  

Finally, call “kjt_read_from_file” to transfer the data to memory. Registers required:

• HL = Load address
  
• B = Bank of load address
  

Again, on return, if the zero flag is set then the operation completed OK.

The file pointer is automatically incremented by the number of bytes transferred, therefore it is not necessary call “kjt_set_file_pointer” each time if chunks of a file are required sequentially. Attempting to read beyond the end of a file will return an error (code $1B). The load length MUST be set for each read (and load address and bank set appropriately each call).

To maintain speed, a fresh seek from the start of the file is not performed each time “kjt_read_from_file” is called unless the file pointer has been changed. Internal variables must be maintained, therefore do not perform any other disk / serial operations (or anything that changes the sector buffer) between successive calls to this routine.

Whenever a disk file transfer reaches address $FFFF, it wraps around to $8000 and continues on into the next bank.

Most of the file system kernal calls return one of these standard error codes:

• If the zero flag is set, the operation was a success
  
• If the zero flag is not set, there was an error. A = error code:
  

Advanced:

In FLOS v599 the following routines were added to allow external programs to hook into the filesystem variables used by FLOS:

kjt_get_fs_vars_location

The data at the returned location (see link for format) can be backed up and restored by a user program, allowing multiple open files to managed etc.

Notes:

• When restoring altered variable data, the first byte “fs_filepointer_valid” should always be cleared so that filesystem correctly re-seeks from the start of files.
• The current volume number must be handled seperarately if files on multiple volumes are to be handled.

Additionally, the following two new routines were added:

kjt_continue_file_read
kjt_set_load_address

The normal file read call kjt_read_from_file requires the bank and address to be specified, which may be a nuisance when working with multiple files. With the kjt_continue_file_read routine, the file bytes are written to an address from the end of the last read operation. kjt_set_load_address sets the address and bank to a specific location.

Action: Checks if current volume is available and formatted to FAT16

Input Registers :

• None
  

Output Registers :

• Standard error codes
  

Action: Selects a new volume (the directory will be that which was last selected in the new volume)

Input Registers :

• A = volume to select

Output Registers :

• Standard error codes

Note: Will not allow a change to an invalid Volume (non-FAT16 etc)

Action: Formats a device (entire drive as single partition, no MBR)

Input Registers :

• A = Device to format (0 = DEV0: (SD_Card), 1 = DEV1: (user driver 1)
• HL = Address of desired disk label ASCII string

Output Registers :

• Standard error codes

Note: It is highly recommended that “kjt_mount_volumes” is called after this routine.

Action: Creates a new sub directory in current directory

Input Registers :

• HL = zero terminated dir name

Output Registers :

• Standard error codes

Action: Change to subdirectory

Input Registers :

• HL = zero terminated dir name

Output Registers :

• Standard error codes

Action: Move up a directory level

Input Registers :

• None

Output Registers :

• Standard error codes

Action: Go to root directory of volume

Input Registers :

• None

Output Registers :

• Standard error codes

Action: Deletes an (empty) subdirectory

Input Registers :

• HL = zero terminated dir name

Output Registers :

• Standard error codes

Action: Deletes a file in the current directory

Input Registers:

• HL = zero terminated file name

Output Registers :

• Standard error codes

Action: Returns total sectors on current volume

Input Registers :

• none

Output Registers :

• C:DE = number of sectors
  

Action: Loads the specified file from current directory in its entirity to the specifed address.

Input registers :

• IX = address to load to
• B = bank to load to
• HL = zero terminated filename

Output registers :

• Standard error codes

Note: This routine both opens a file and reads all the data to RAM - for more flexibility use “kjt_open_file”, “kjt_set_file_pointer”, “kjt_set_read_length” and “kjt_read_file_data“

Action: Saves a file to current directory.

Input registers:

• IX = Source data start address
• B = bank to save data from
• C:DE = number of bytes to save
• HL = zero terminated filename

Output registers:

• Standard error codes

Note: This routine both creates a new file and saves data to it - it cannot be used append new data to an existing file (will return “file already exists” error if attempted).

Action: Looks for a file in current directory and sets internal registers ready for ”kjt_read_from_file” call.

Input Registers :

• HL = pointer to zero terminated filename to look for
  

Output Registers :
If the Zero Flag is set: All OK. Registers are:

• IX:IY = Length of file
• DE = First disk cluster used by file

If zero flag is not set: standard error codes.

Note: File pointer is set to 0, default transfer length = total file size

Action: Moves the read point from the start of a file

Input Registers :

• IX:IY = Offset in bytes from start of file.

Output Registers :

• none

Note: Use after “kjt_open_file” (if required)

Action: Forces the read length of the file transfer to a certain value

Input Registers :

• IX:IY = Bytes to load

Output Registers :

• none

Note: Use after kjt_find_file (if desired)

Action: Loads data (from the previously opened file) to a specified address.

Input Registers :

• HL = Destination address
• B = Destination bank

Output Registers :

• Standard error codes
  

Notes

• “kjt_open_file” MUST be called first before using this routine.
• Whenever a disk file transfer reaches address $FFFF, it wraps around to $8000 and continues onto the next bank.

Action: Makes a file stub for a new file in current directory.

Input Registers :

• HL = address of zero-terminated filename

Output Registers :

• Standard error codes

Action: Appends new data to an existing file in current directory.

Input Registers :

• HL = null-terminated ascii filename of file to be appended to
• IX = address of source data
• B = bank of source data
• C:DE = number of bytes to write

Output Registers :

• Standard error codes

Note: Returns “file not found” error if the file has not been previously created with “kjt_create_file” or “kjt_save_file“

Action: Finds the first listing of current directory, returns info.

Input registers:

• None

Output registers:
If zero flag is set:

• HL = Location of null terminated filename string
• IX:IY = Length of file (if applicable)
• B = File flag (1 = directory, 0 = file)

If zero flag is not set, standard error codes (EG: $24 = Reached end of directory)

Action: Returns data about the entry at the current position in the directory list.

Input registers :

• None

Output registers :
If zero flag is set:

• HL = Location of null terminated filename string
• IX:IY = Length of file (if applicable)
• B = File flag (1 = directory, 0 = file)

If zero flag is not set, standard error codes (EG: $24 = Reached end of directory)

Action: Moves the internal directory list pointer to the next entry and returns details about the entry found

Input registers :

• None

Output registers:
If zero flag is set:

• HL = Location of null terminated filename string
• IX:IY = Length of file (if applicable)
• B = File flag (1 = directory, 0 = file)

If zero flag is not set, standard error codes (EG: $24 = Reached end of directory)

Action: Returns ascii string of current directory name (null terminated)

Input registers :

• None

Output registers :
If zero flag set:

• HL = ascii string

If zero flag is not set, standard error codes

Action: Reinitializes the drives and mount list

Input registers :

• If A = 1, mount quietly (no text output)
  

Output registers :

• None

Note: Also attempts to create the assign Envar 'EX0' for VOL0:COMMANDS (FLOS v609+)

Action: Returns info about the volumes mounted.

Input Registers :

• None

Output Registers :

• HL = address of volume mount list
• B = Number of volumes mounted
• A = currently Selected volume

Action: Returns info from the device list.

Input Registers :

• None

Output Registers :

• HL = address of device info table
• DE = address of driver table
• B = number of devices initialized
• A = current active driver number

Action: Returns the location of the directory cluster

Input Registers :

• None

Output Registers :

• DE = cluster pointed at by current directory

Action: Sets the directory cluster (for use with above command)

Input Registers :

• DE = desired cluster number to be used as current dir

Output Registers :

• None

Note: The routine attempts to validate the dir by looking for the directory name, if this fails, the dir is set to ROOT and error code $23 is returned (DIR not found).

Action: Rename files / folders.

Input Registers :

• HL = Pointer to filename to change (null terminated ASCII)
• DE = Pointer to replacement filename (null terminated ASCII)

Output Registers :

• Standard error codes

Action: Sets HL to the address of the filesystem's control variables.

Input Registers :

• None

Output Registers :

• HL = location of the following data structure:
  

Note: When restoring altered data, the first byte “fs_filepointer_valid” should always be cleared. This causes the read operations to cleanly seek from the beginning of files when file transfer (re)commences. (Access will be noticeably slower than a single continuous load.)

Action: Same as kjt_read_from_file except this does not set the load address/bank

Input Registers :

• None

Output Registers :

• Standard error codes

Action: Specifies the load address and bank for a file read (when using kjt_continue_file_read)

Input Registers :

• HL = Z80 address where data should load
• B = FLOS bank where data should load

Output Registers :

• None

(added in FLOS v607)

Action: Changes volume and directory according to the path string supplied. This is basically the same as the “CD” command.

Input Registers :

• HL = Address of path string

Output Registers :

• Standard error codes

Note: If the path is invalid (dir or volume not found) an error code is returned and the dir remains unchanged.

Action: Loads a 512 byte sector from the device and address selected to the sector buffer

Input registers :

• A = Device number to access (normally 0)
• BC:DE = absolute LBA address for desired sector

Output registers :

• Standard error codes (relevant errrors: $1e, $22)

Action: Writes a 512 byte sector from the sector buffer to the device and address selected

Input registers :

• A = Device number to access (normally 0)
• BC:DE = absolute LBA address for desired sector

Output registers :

• Standard error codes (relevant errrors: $1e, $22)

Action: Retrieves the location of the (next) disk sector that a file occupies.

Input registers:

• A = Sector offset (within current cluster)
• DE = Cluster number

Output registers:

• A = Next sector offset
• DE = Updated cluster
• HL = Memory address of LSB of 4 byte sector location

How to use:

To obtain the list of sectors that a file uses, first call ”kjt_find_file” with the filename in HL as normal. On exit, DE will be equal the first cluster that the file occupies. Clear the accumulator (as we're starting at the first sector of this cluster), and call “kjt_file_sector_list”. On return A and DE are updated to the values required for the next time the routine is called and HL points to the lowest significant byte of the sector address (LBA0). Next, copy the 4 bytes from HL to HL+3 to your sector list buffer and loop around, calling “kjt_file_sector_list” for as many sectors as are used by the file (simply subtract 512 from a variable holding the file size every call until variable is = < 0)

Action: Returns the address of the selected drive's sector read routine, also LBA variable and sector_location_variable

Input Registers :

• A = Device to access (normally 0)

Output Registers :

• HL = Address of sector read routine
• DE = Address of the LSB of the 32bit LBA variable
• BC = Address of the sector buffer location variable

Notes

• This routine can be used to allow programs to read sectors directly to an arbitrary location in memory (IE: A program can write to the sector LBA and sector buffer location variables, and then call the low-level sector read routine using the data obtained).

• The sector buffer location is automatically reset to the location that the OS requires whenever a filesystem routine is called (this includes the KJT read/write sector calls above.) Similarly, altering the LBA variable manually should not affect normal operation of the filesystem.

To load a file serially you would call: kjt_serial_receive_header, setting A and HL as appropriate (see docs below). Once it has been received, kjt_serial_receive_file may be called (setting B and HL appropriately).

As with the disk routines, whenever a serial file transfer command reaches address $FFFF, it wraps around to $8000 and continues onto the next bank.

Action: Waits for a file header from serial port.

Input Registers :

• HL = Location of null terminated filename (filename can be “*” if any file is to be accepted).
• A = described in following table
  

Output Registers :
Zero Flag: If set, all OK

• IX = location of serial file header (see Serial Link Info for details)

If Zero Flag is NOT set, A = serial error code:

Action: Receives serial file data

Input Registers :

• HL = Address to load file to
• B = Bank to load file into

Output Registers :
Zero Flag: If set, all OK

• IX = location of of serial file header

If Zero Flag is NOT set, A = serial error code:

Note: “kjt_serial_receive_header” MUST be called before this routine!

Action: Sends a file to serial port (Serial Link App format)

Input Registers :

• HL = filename
• C:DE = length of file
• B = Bank number that file starts in
• IX = Start address

Output Registers :
Zero flag, set if all OK.

If zero flag not set, A = serial error code:

Action: Wait for a byte from serial port

Input Registers :

• A. Bits described in following table:
  

Output Registers :
If Carry flag is clear all OK, A = byte received.

If Carry flag is set, error code in A as follows:
A = $14 - Timed out
A = $2A - Aborted with key

Note: All registers except A are preserved.

Action: Send a byte to serial port

Input Registers :

• none

Output Registers :

• A = byte to send

Note: All registers except A preserved.

Action: Pauses until a key is pressed (and returns value)

Input Registers :

• None

Output Registers :

• A = Scancode of key pressed
• B = ASCII code (B=$00 if no valid ascii char equivalent.)

Note: ASCII code is modified by shift / Alt key status

Action: Returns value of key, if one has been pressed (does not wait)

Input Registers :

• None

Output Registers :

• A = Scancode of key pressed (A = $00 if no key pressed)
• B = ASCII code (B=$00 if no valid ascii char equivalent.)

Note: ASCII code is modified by shift / Alt key status

Action: Returns current status of key modifiers

Input Registers :

• None

Output Registers :

• A, bits:

Action: Keyboard IRQ handler.

When a custom interrupt handler is set up but kernal-based keyboard handling is required, this routine can be called when the keyboard IRQ flag is set. The above kernal keyboard routines will then still work. (The call clears the relevant IRQ flag).

Action: Activates mouse pointer (called by MOUSE.EXE) and sets x/y boundaries

Input Registers :

• HL = Window size X
• DE = Window size Y

Output Registers :

• None

Action: Returns absolute mouse position and button data

Input Registers : none

Output Registers : Zero Flag - If not set, the mouse driver was not enabled, otherwise: HL = x coordinate DE = y coordinate A = buttons status

The x and y coordinates cannot overflow from the boundaries set with “kjt_enable_mouse“

Note: the mouse driver is currently somewhat primative - it may become out of sync with the three-byte packets that the mouse sends if say, interrupts are disabled)

Action: Returns relative mouse motion and button data

Input Registers :

• none

Output Registers :
Zero Flag: if not set, the mouse driver was not enabled, Otherwise:

• HL = x motion since last called
• DE = y motion since last called
• A = buttons status

Note: the mouse driver is currently somewhat primitive - it may become out of sync with the three-byte packets that the mouse sends if say, interrupts are disabled

Action: Mouse IRQ handler

When a custom interrupt handler is set up but kernal-based mouse handling is required, this routine can be called when the mouse IRQ flag is set. The above kernal mouse routines will then still work. (The call clears the relevant IRQ flag).

Action: Returns values for monitoring the keyboard buffer

Input Registers :

• None

Output Registers :
* HL = Location of the keyboard buffer WRITE index variable (The actual keyboard buffer starts 32 bytes lower in memory) * A = The value of the keyboard READ index variable.

Note: On return, if A = (HL) no key has been pressed (IE: the keyboard buffer is empty)

Under FLOS, Z80 Address space $5000-$FFFF is available for user programs. FLOS allows the upper 32KB of Z80 address space ($8000-$FFFF) to be paged. 15 pages of system RAM can appear in this region, starting at system RAM address $08000 (FLOS does not normally allow the first 32KB of system RAM to be paged into $8000-$FFFF). Therefore, when using the KJT routines for bank management, the figures are as follows:

(Notice that the figures are different to the values used if writing directly to the bank selection hardware port: sys_mem_select).

Action: Changes the currently selected upper RAM page

Input Registers : A = bank number $00 to $0e

Output Registers : none

Trashes: A

Action: Returns the upper bank number in A

Input Registers : none

Output Registers : A = current bank number ($00 to $0e)

Trashes: none

Action: change to the next bank

Input Registers : none

Output Registers : If Zero flag set: all OK, If Zero is not set: A = $08 - bank out of range

Action: Pages 8KB of video memory specified by (hardware register vreg_vidpage) into Z80 address space $2000-$3FFF.

CAUTION: This area is used by part of FLOS so ideally no other FLOS call should be made until kjt_page_out_video is called.

Input Registers :

• none

Output Registers :

• none

Trashes :

• A

Action: Pages normal system memory (part of the FLOS!) back into $2000-$3FFF

Input Registers :

• none

Output Registers :

• none

Trashes :

• A

Action: Reads system memory in a flat, linear addressing mode

Input Registers :

• E:HL = $00000 - $7FFFF (address to read)

Output Registers :

• A (byte read from address)

Trashes :

• BC
• DE
• HL

Notes

• The routine saves and restores the entire port byte ”sys_mem_select” around the read so make sure any interrupt service routine is in unpaged memory (<$8000) or disable interrupts to avoid problems.
• As this routine is very slow, only use if convenience is more important than speed.

Action: Writes to system memory in a flat, linear addressing mode

Input Registers :

• E:HL = $00000 - $7FFFF (address to write),
• A = byte to write

Output Registers :

• None (but see below)

Trashes :

• BC
• DE
• HL

Notes

• The routine saves and restores the entire port byte “sys_mem_select” around the write so make sure any interrupt service routine is in unpaged memory (<$8000) or disable interrupts to avoid problems.

• As this routine is not fast, only use if convenience is more important than speed.

Action: Reads a byte from system memory (allows programs in paged RAM (8000-FFFF) to easily read data from a different bank)

Input Registers :

• B = Bank
• HL = Address

Output registers :

• A = byte from memory location specified

Notes

• The routine saves and restores the entire port byte “sys_mem_select” around the read so make sure any interrupt service routine is in unpaged memory (<$8000) or disable interrupts to avoid problems.
• As this routine is not fast, only use if convenience is more important than speed.

Action: Writes a byte to system memory, allows programs in paged RAM (8000-FFFF) to write data to a different bank

Input Registers :

• B = Bank
• HL = Address
• A = Byte to writes

Output Registers :

• None

Notes

• The routine saves and restores the entire port byte “sys_mem_select” around the write so make sure any interrupt service routine is in unpaged memory (<$8000) or disable interrupts to avoid problems.
• As this routine is not fast, only use if convenience is more important than speed.
• Hardware support for writing to alternative pages in provided via the port sys_alt_write_page (see hardware manual)
  

Action: Returns the value of the bank being used by FLOS before the current command executed.

This is useful when a location header places a program in paged memory ($8000-$FFFF) thus changing the bank selection to that of the program, but the program wants to act on the memory in the bank selected by FLOS as if it were an internal command.

Input Registers :

• None

Output Registers :

• A - The bank which FLOS was referencing.

Action: Prints null-terminated ASCII text string at cursor position

Input Registers :

• HL address of string (zero terminated)

Output Registers :

• None

Notes

• ASCII Char $0a = Line Feed
• ASCII Char $0d = Carriage Return
• ASCII Char $0b = Line Feed and Carriage return
• HL returns pointing to the zero byte at end of the string

All other registers are preserved by this routine.

This routine moves the current cursor position.

Action: clears OS screen and set cursor position to top left (0,0)

Input Registers :

• None

Output Registers :

• None

Action: Prints ASCII character at supplied coordinates using current pen colours

Input Registers :

• A = ASCII character
• B = x coord
• C = y coord

Output Registers :

• None

Notes

• Plot_char does not change the current cursor position.
• If a coordinate is outside the window, it is taken as zero

Action: Returns current pen colour

Input Registers :

• None

Output Registers :

• A = $nm where “n” is the background and “m” is the foreground colour (see table)

Available (default) colours:

Action: Changes current pen colour

Input Registers :

• A = $nm where “n” is the background and “m” is the foreground colour (see table)

Available (default) colours:

Output Registers :

• None

Action: Returns the location of the FLOS colour list.

Input registers :

• none

Output registers :

• HL = location of colour list: 18 words (RGB values).

Colour List :
+$00 - Paper
+$02 - Border
+$04 - Cursor
+$06 - 15 pen colours starting with pen 1

Note: FLOS stores its colour list under the hardware registers so system memory needs to paged into that region if writing directly to the address returned from this call. (Simply reading the list poses no such problem). In all cases, kjt_set_colours needs to be called to actually change the palette (unless writing directly to the Hardware Palette Registers)

Action: Sets FLOS border, paper and cursor colours and updates the pen colour list

Input registers :

• HL = location of the colour palette list (18 RGB words)

Colour List :
+$00 - Paper
+$02 - Border
+$04 - Cursor
+$06 - 15 pen colours starting with pen 1

Output registers :

• None

Input registers are trashed.

Note: Changes persist until FLOS restarts (whereas any changes made with the FLOS command “COLOUR” are permanent until reset)

Action: Draws (or removes) the cursor at the current cursor position

Input Registers :

• HL = Offset of cursor char image within VRAM font data:

 EG: 

 HL = $0000 : No data, IE: Delete the cursor
 HL = $085f : Underscore cursor ($800-$8ff = top line of  ASCII chars 0-255)
 HL=  $1800 : Solid block cursor

Output Registers :

• None

Note: Remember, kjt_print_string moves the cursor position so the cursor image should be deleted before that routine is called.

Action: waits for user to enter a string of characters followed by Enter (characters appear on screen)

Input Registers :

• A - maximum characters allowed (set to 255 if dont care)

Output Registers :

• HL = string location (zero terminated)
• A = number of characters of entered string (zero if aborted by pressing ESCAPE)

Action: Repositions the text printing (cursor) position. If a coordinate is out of range it will be set to 0.

Input Registers :

• B = X coord
• C = Y coord

Output Registers :

• Zero flag set if all OK
• If zero flag not set: Invalid coordinates

Action: Returns the current cursor position

Input Registers :

• None

Output registers :

• B = x coord
• C = y coord

Action: Scrolls the screen (and character map) up a line, inserting a blank line at the bottom of the screen.

Input Registers :

• None

Output registers :

• None

Action: Returns size of OS_window.

Input registers :

• None

Output registers :

• B = x width (usually 40)
• C = y height (usually 25)

Note: All other registers preserved.

Action: Returns the charmap address of the character at coordinates x,y

Input registers :

• B = x coord
• C = y coord

Output registers :

• HL = character map address of coords

Note: All other registers are preserved.

Action: Wait for last scanline of display

Input Registers :

• none

Output Registers :

• none

Trashes:

• A

Action: Change an individual character in the FLOS font.

Input registers :

• A = char number (must be 0-255, but note: Some chars < 32 are unprintable using “kjt_print_string")
• HL = address of new character pattern (8 bytes)

Output registers :

• None

Action: puts ASCII version of the hex byte value in A at HL (two chars), HL=HL+2

Input Registers :

• A = Hex number to convert

Output Registers :

• None

Note: HL=HL+2

Trashes :

• A

Action: converts text string version of hex number at HL to actual hex word in DE

Input Registers :

• HL = source text (the routine scans from this location to the first character that is not a space)

Output Registers :

• DE = result
• HL = If result OK, location of first space character after the hex string (IE: usually a space or null character)

• Zero Flag = set if all OK (also A=$00), Else:

Action: converts text string version of hex number at HL to actual hex word in BC:DE

Input Registers :

• HL = source text (the routine scans from this location to the first character that is not a space)

Output Registers :

• BC:DE = Result
• HL = If result OK, location of first space character after the hex string (IE: usually a space or null character)
• Zero Flag = set if all OK (also A=$00), Else:

Action: Prevents the OS from noting the register values when a program exits and returns to OS.

Input Registers :

• None

Output Registers :

• None

Trashes :

• A

Action: Returns FLOS / OSCA / BOOTCODE version values (also reports the V6Z80P PCB version if OSCA > version $673.)

Input Registers :

• none

Output Registers :

• HL = OS version word
• DE = Hardware version word
• B = V6Z80P PCB version

Also, if C = 0:

• IX = Location of bootcode info data structure:

If C <> 0 : FLOS < 610 = data not available

Action: Compares two ASCII strings (not case sensitive)

Input Registers :

• DE = address of string 1
• HL = address of string 2
• B = maximum number characters to compare

Output Registers :

• Carry flag: Only set if strings are the same.

Notes

• Both strings should be zero terminated.
• Compare fails if string lengths are different unless count is reached first.
• Original HL/DE values are preserved.

Action: Fill memory with value in accumulator

Input Registers :

• HL = start address
• BC = number of bytes to write
• A = value to write

Output Registers :

• none

Trashes :

• HL
• BC
• A

Note: Does NOT overflow from $FFFF into next bank.

Action: Waits n x 16 microseconds and returns.

Input Registers :

• A = number of 16 microsecond periods to wait

Output Registers:

• None

Note: Preserves all registers except A

Action: Sets a “permanent” command string that is to be launched when progams exit

Input Registers :

• HL = location of command string (40 chars max)

Output Registers :

• None

Notes\

• The string at HL will be parsed as a command whenever a program exits back to FLOS unless that program specifically tells FLOS to launch some other program (with A=$FE on exit). In this case, the commander program will eventually launch when controlis passed back to FLOS (IE: A <> $FE on exit)
• To remove the commander string, point HL at a null string (a zero byte in memory) and call the routine.
• To cancel the commander, press CTRL+C

Action: Restores the video registers and IRQ vectors/enables to the state used by the OS. Also clears the keyboard buffer. Can be called by programs that have changed the display mode etc before exit so that FLOS does not have to be completely restarted.

Note: This does not restore the data in the Video RAM area used by FLOS ($10000-$1ffff).

Input registers :

• None

Output registers :

• None

Action: Sets an environment variable (or updates a variable if it already exists)

Input Registers :

• HL = name of variable (4 chars max, zero-termination required if less than 4 chars)
• DE = address of data for variable (4 bytes)

Output Registers :

• Zero Flag = set if all OK, not set if no space for new variable (A = $2c)

Action: gets (address of) value of an environment variable

Input Registers :

• HL = name of variable (4 chars max, zero-termination required if less than 4 chars)

Output Registers :

• Zero Flag = Set : all OK, HL = address of data for variable (4 bytes)
• Zero Flag = Not set: variable was not found, (A = $2b, hl = location of envar list, b = max envars)

Action: deletes an environment variable

Input Registers :

• HL = name of variable (4 chars max, zero-termination required if less than 4 chars)

Output Registers :

• Zero flag = set if all OK, not set if named variable not found