6502/cc65
1
0
Fork 0
mirror of https://github.com/cc65/cc65.git synced 2024-12-27 15:29:46 +00:00
Code Issues Projects Releases Wiki Activity
1c26b1cf1b
cc65/libsrc/apple2/targetutil/loader.s

233 lines
6.2 KiB
ArmAsm
Raw Normal View History

Updated LOADER.SYSTEM to the current version targeted at cc65 binaries only. git-svn-id: svn://svn.cc65.org/cc65/trunk@5417 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 13:05:26 +00:00
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; ;
; LOADER.SYSTEM - an Apple][ ProDOS 8 loader for cc65 programs (Oliver Schmidt) ;
; ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
A1L := $3C
A1H := $3D
STACK := $0100
BUF := $0200
PATHNAME := $0280
MLI := $BF00
VERSION := $FBB3
RDKEY := $FD0C
PRBYTE := $FDDA
COUT := $FDED
QUIT_CALL = $65
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
GET_FILE_INFO_CALL = $C4
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
OPEN_CALL = $C8
READ_CALL = $CA
CLOSE_CALL = $CC
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
FILE_NOT_FOUND_ERR = $46
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
; ------------------------------------------------------------------------
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
.import __CODE_0300_SIZE__, __DATA_0300_SIZE__
.import __CODE_0300_LOAD__, __CODE_0300_RUN__
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
; ------------------------------------------------------------------------
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
.segment "DATA_2000"
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
GET_FILE_INFO_PARAM:
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
.byte $0A ;PARAM_COUNT
.addr PATHNAME ;PATHNAME
.byte $00 ;ACCESS
.byte $00 ;FILE_TYPE
FILE_INFO_ADDR: .word $0000 ;AUX_TYPE
.byte $00 ;STORAGE_TYPE
.word $0000 ;BLOCKS_USED
.word $0000 ;MOD_DATE
.word $0000 ;MOD_TIME
.word $0000 ;CREATE_DATE
.word $0000 ;CREATE_TIME
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
OPEN_PARAM:
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
.byte $03 ;PARAM_COUNT
.addr PATHNAME ;PATHNAME
.addr MLI - 1024 ;IO_BUFFER
OPEN_REF: .byte $00 ;REF_NUM
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
LOADING:
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
.byte $0D
.asciiz "Loading "
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
ELLIPSES:
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
.byte " ...", $0D, $0D, $00
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
; ------------------------------------------------------------------------
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
.segment "DATA_0300"
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
READ_PARAM:
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
.byte $04 ;PARAM_COUNT
READ_REF: .byte $00 ;REF_NUM
READ_ADDR: .addr $0000 ;DATA_BUFFER
.word $FFFF ;REQUEST_COUNT
.word $0000 ;TRANS_COUNT
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
CLOSE_PARAM:
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
.byte $01 ;PARAM_COUNT
CLOSE_REF: .byte $00 ;REF_NUM
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
QUIT_PARAM:
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
.byte $04 ;PARAM_COUNT
.byte $00 ;QUIT_TYPE
.word $0000 ;RESERVED
.byte $00 ;RESERVED
.word $0000 ;RESERVED
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
FILE_NOT_FOUND:
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
.asciiz "... File Not Found"
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
ERROR_NUMBER:
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
.asciiz "... Error $"
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
PRESS_ANY_KEY:
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
.asciiz " - Press Any Key "
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
; ------------------------------------------------------------------------
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
.segment "CODE_2000"
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
jmp :+
.byte $EE
.byte $EE
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
.byte $7F
STARTUP:.res $7F
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
; Reset stack
: ldx #$FF
txs
; Relocate CODE_0300 and DATA_0300
ldx #<(__CODE_0300_SIZE__ + __DATA_0300_SIZE__)
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
: lda __CODE_0300_LOAD__-1,x
sta __CODE_0300_RUN__-1,x
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
dex
bne :-
; Remove ".SYSTEM" from pathname
lda PATHNAME
sec
sbc #.strlen(".SYSTEM")
sta PATHNAME
; Add trailing '\0' to pathname
tax
lda #$00
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
sta PATHNAME+1,x
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
; Copy ProDOS startup filename and trailing '\0' to stack
ldx STARTUP
lda #$00
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
beq :++ ; Branch always
: lda STARTUP+1,x
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
: sta STACK,x
dex
Allow up 127 chars of cmdline for programs started by the loader.
2015-04-19 19:16:43 +00:00
bpl :--
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
; Provide some user feedback
lda #<LOADING
ldx #>LOADING
jsr PRINT
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
lda #<(PATHNAME+1)
ldx #>(PATHNAME+1)
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
jsr PRINT
lda #<ELLIPSES
ldx #>ELLIPSES
jsr PRINT
jsr MLI
.byte GET_FILE_INFO_CALL
.word GET_FILE_INFO_PARAM
bcc :+
jmp ERROR
: jsr MLI
.byte OPEN_CALL
.word OPEN_PARAM
bcc :+
jmp ERROR
; Copy file reference number
: lda OPEN_REF
sta READ_REF
sta CLOSE_REF
; Get load address from aux-type
lda FILE_INFO_ADDR
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
ldx FILE_INFO_ADDR+1
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
sta READ_ADDR
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
stx READ_ADDR+1
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
; It's high time to leave this place
jmp __CODE_0300_RUN__
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
; ------------------------------------------------------------------------
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
.segment "CODE_0300"
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
jsr MLI
.byte READ_CALL
.word READ_PARAM
bcs ERROR
jsr MLI
.byte CLOSE_CALL
.word CLOSE_PARAM
bcs ERROR
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
; Copy REM and startup filename to BASIC input buffer
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
ldx #$00
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
lda #$B2 ; REM token
bne :++ ; Branch always
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
: inx
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
lda a:STACK-1,x
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
: sta BUF,x
bne :--
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
; Go for it ...
jmp (READ_ADDR)
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
PRINT:
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
sta A1L
stx A1H
ldx VERSION
ldy #$00
: lda (A1L),y
beq :++
cpx #$06 ; //e ?
beq :+
cmp #$60 ; lowercase ?
bcc :+
and #$5F ; -> uppercase
: ora #$80
jsr COUT
iny
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
bne :-- ; Branch always
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
: rts
Added old obsolete version of LOADER.SYSTEM in order to retain the history. This version implemented the BASIC warmstart/coldstart hooks and was therefore fully compatible with any DOS 3.3 binary running under ProDOS. However later the Apple2 C library startup code was extended to not rely on the BASIC hooks when running under ProDOS without BASIC.SYSTEM. Therefore the hook functionality became obsolete and was later removed. This limits LOADER.SYSTEM to cc65 binaries - but it surely wasn't used for anything else anyway ;-) git-svn-id: svn://svn.cc65.org/cc65/trunk@5416 b7a2c559-68d2-44c3-8de9-860c34a00d81
2012-01-21 12:59:43 +00:00
ERROR:
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
cmp #FILE_NOT_FOUND_ERR
bne :+
lda #<FILE_NOT_FOUND
ldx #>FILE_NOT_FOUND
jsr PRINT
Added cmdline support to exec(). The starting point is the CALL2051:REM <cmdline> approach. It uses the BASIC input buffer at $200. ProDOS stores the name of the loaded program at $280 (which we want for argv[0]) leaving us with 128 char buffer. If we run the program via exec() we don't need the CALL2051 but only the REM token (which is just one char). So have a maximum cmdline length of 126 (plus a terminating zero). There's no specification for ProDOS BIN file cmdline parameters so exec() just supports the CALL2051:REM <cmdline> approach. In contrast ProDOS SYS files allow for a 'startup filename'. A ProDOS filename is short than 126 chars so having exec() general cut the cmdline after 126 chars seems reasonable. If the SYS file we exec() allows for less we cut the cmdline further. Our 'loader.system' SYS file however allows for an unusually 126 char long "startup filename" as it is targeted towards cc65 BIN porgrams with their 126 cmdline length.
2015-04-26 12:01:36 +00:00
beq :++ ; Branch always
Removed (pretty inconsistently used) tab chars from source code base.
2013-05-09 11:56:54 +00:00
: pha
lda #<ERROR_NUMBER
ldx #>ERROR_NUMBER
jsr PRINT
pla
jsr PRBYTE
: lda #<PRESS_ANY_KEY
ldx #>PRESS_ANY_KEY
jsr PRINT
jsr RDKEY
jsr MLI
.byte QUIT_CALL
.word QUIT_PARAM
Reference in New Issue Copy Permalink