372 lines
7.2 KiB
ArmAsm
372 lines
7.2 KiB
ArmAsm
// #LAYOUT# STD * #TAKE
|
|
// #LAYOUT# * BASIC_0 #TAKE
|
|
// #LAYOUT# * * #IGNORE
|
|
|
|
|
|
// Well-known BASIC routine, described in:
|
|
//
|
|
// - [CM64] Computes Mapping the Commodore 64 - page 102
|
|
// - https://sta.c64.org/cbm64basconv.html
|
|
//
|
|
// Output:
|
|
// - VALTYP - $00 = floating number, $FF = string
|
|
// - for float: FAC1
|
|
// - for string: __FAC1 + 0 = length, __FAC1 + 1 = pointer to string
|
|
//
|
|
// Idea:
|
|
// - use a stack to reorder operations, so that they can be executed
|
|
// in a correct order
|
|
//
|
|
|
|
// XXX finish the implementation: invoking functions, fetching floats
|
|
|
|
|
|
FRMEVL:
|
|
|
|
// Push the sentinel to the stack
|
|
|
|
lda #$00
|
|
pha
|
|
|
|
// FALLTROUGH
|
|
|
|
FRMEVL_loop:
|
|
|
|
// At this point there are 4 valid possibilities:
|
|
// - a string, a float, pi, or a variable (in short: a value to fetch)
|
|
// - a token (whichj means function to execute)
|
|
// - an unary operator
|
|
// - an opening bracket
|
|
|
|
// Check if end of statement, fetch the character
|
|
|
|
jsr is_end_of_statement
|
|
bcs_16 do_SYNTAX_error
|
|
jsr fetch_character
|
|
|
|
// Check for a string or opening bracket
|
|
|
|
cmp #$22 // check for opening quote
|
|
beq FRMEVL_fetch_string
|
|
cmp #$28 // check for opening bracket
|
|
beq FRMEVL_handle_bracket
|
|
|
|
// Check for unary operators
|
|
|
|
cmp #$AB // check for unary minus
|
|
beq_16 FRMEVL_unary_minus
|
|
cmp #$A8 // check for NOT
|
|
beq_16 FRMEVL_unary_not
|
|
|
|
// Check for the PI
|
|
|
|
cmp #$FF // check for PI
|
|
beq_16 FRMEVL_fetch_PI
|
|
|
|
// If not a PI and not an unary operator, than everything above
|
|
// $7F has to be a function
|
|
|
|
cmp #$80 // check for a token
|
|
bcs FRMEVL_execute_function
|
|
|
|
// Check for a variable
|
|
|
|
#if !HAS_OPCODES_65CE02
|
|
jsr unconsume_character
|
|
#else
|
|
dew TXTPTR
|
|
#endif
|
|
jsr fetch_variable
|
|
bcs FRMEVL_fetch_float
|
|
|
|
// Found the variable - copy descriptor to FAC1
|
|
|
|
#if CONFIG_MEMORY_MODEL_60K
|
|
|
|
ldx #<VARPNT
|
|
|
|
ldy #$00
|
|
jsr peek_under_roms
|
|
sta __FAC1+0
|
|
iny
|
|
jsr peek_under_roms
|
|
sta __FAC1+1
|
|
iny
|
|
jsr peek_under_roms
|
|
sta __FAC1+2
|
|
|
|
#elif CONFIG_MEMORY_MODEL_46K || CONFIG_MEMORY_MODEL_50K
|
|
|
|
jsr helper_frmevl_strdesccpy
|
|
|
|
#else // CONFIG_MEMORY_MODEL_38K
|
|
|
|
ldy #$00
|
|
lda (VARPNT),y
|
|
sta __FAC1+0
|
|
iny
|
|
lda (VARPNT),y
|
|
sta __FAC1+1
|
|
iny
|
|
lda (VARPNT),y
|
|
sta __FAC1+2
|
|
|
|
#endif
|
|
|
|
jmp_8 FRMEVL_got_value
|
|
|
|
//
|
|
// This subroutine handles the situation when we have to execute a BASIC function
|
|
// in place when parser normally expects a value
|
|
//
|
|
|
|
FRMEVL_execute_function:
|
|
|
|
// XXX implement this - use function_jumptable*
|
|
|
|
jmp do_NOT_IMPLEMENTED_error
|
|
|
|
//
|
|
// These two subroutines handles the situation when we got an unary operator
|
|
// in place when parser normally expects a value
|
|
//
|
|
|
|
FRMEVL_unary_not:
|
|
|
|
ldy #$0D // our code for unary NOT
|
|
skip_2_bytes_trash_nvz
|
|
|
|
// FALLTROUGH
|
|
|
|
FRMEVL_unary_minus:
|
|
|
|
ldy #$0E // our code for unary NOT
|
|
jmp FRMEVL_push_operator_address
|
|
|
|
//
|
|
// This subroutine handle brackets - it just calls FRMEVL recursively
|
|
// and consumes the closing bracket afterwards
|
|
//
|
|
|
|
FRMEVL_handle_bracket:
|
|
|
|
jsr FRMEVL
|
|
jsr fetch_character
|
|
cmp #$29 // closing bracket
|
|
beq FRMEVL_got_value
|
|
|
|
jmp do_SYNTAX_error
|
|
|
|
//
|
|
// This subroutine handles the situation when our value to fetch is PI
|
|
//
|
|
|
|
FRMEVL_fetch_PI:
|
|
|
|
lda #<const_PI
|
|
ldy #>const_PI
|
|
jsr mov_MEM_FAC1
|
|
|
|
jmp_8 FRMEVL_got_value_float
|
|
|
|
//
|
|
// This subroutine fetches the floating point value from the 'outside world'
|
|
//
|
|
|
|
FRMEVL_fetch_float:
|
|
|
|
// XXX implement this
|
|
|
|
jmp do_NOT_IMPLEMENTED_error
|
|
|
|
// FALLTROUGH
|
|
|
|
FRMEVL_got_value_float:
|
|
|
|
lda #$00
|
|
sta VALTYP
|
|
beq FRMEVL_got_value
|
|
|
|
//
|
|
// This subroutine fetches the string value from the 'outside world'
|
|
//
|
|
|
|
FRMEVL_fetch_string:
|
|
|
|
// Mark return value as a string, set initial length as 0
|
|
|
|
ldx #$FF
|
|
stx VALTYP
|
|
|
|
inx
|
|
stx __FAC1 + 0
|
|
|
|
// Set pointer to start of the string
|
|
|
|
ldx TXTPTR + 0
|
|
stx __FAC1 + 1
|
|
ldx TXTPTR + 1
|
|
stx __FAC1 + 2
|
|
!:
|
|
// Search for closing quote
|
|
|
|
jsr fetch_character
|
|
cmp #$22
|
|
beq FRMEVL_got_value
|
|
cmp #$00
|
|
beq !+
|
|
|
|
inc __FAC1 + 0
|
|
bne !-
|
|
|
|
jmp do_STRING_TOO_LONG_error
|
|
!:
|
|
// No closing quote, but end of the data
|
|
|
|
#if !HAS_OPCODES_65CE02
|
|
jsr unconsume_character
|
|
#else
|
|
dew TXTPTR
|
|
#endif
|
|
|
|
// FALLTROUGH
|
|
|
|
|
|
//
|
|
// This subroutine handles the situation after fetching the value from 'outside world':
|
|
// - either there is nothing sane remaining there; if so, this value is or final result
|
|
// - or there is an operator following the value; in such case we have much more work to do;
|
|
// we push the current value and the operator to the stack and we proceed to fetch the next
|
|
// value (which is mandatory)
|
|
// small catch: if the priority of the new operator is not higher than priority of the last
|
|
// operator on the stack (sentinel is considered as the lowest priority operator) we first
|
|
// compute what currently is present on the stack - this enforces proper operator precedence
|
|
//
|
|
|
|
FRMEVL_got_value:
|
|
|
|
jsr is_end_of_statement
|
|
bcs FRMEVL_compute_all // compute the stack if expression ended
|
|
|
|
// FALLTROUGH
|
|
|
|
FRMEVL_fetch_operator:
|
|
|
|
// We have a value, but this is not the end of expression. Check if
|
|
// there is an operator waiting to be served
|
|
|
|
jsr fetch_operator
|
|
bcs FRMEVL_compute_all // if operator not recognized, compute what we have
|
|
// on stack and quit
|
|
|
|
// Move the new operator ID to .Y
|
|
|
|
tay
|
|
|
|
// Compare the priority of the last operator with the new one
|
|
|
|
pla
|
|
pha
|
|
|
|
cmp operator_priorities, y
|
|
bcc FRMEVL_push_value_operator
|
|
|
|
// Here the priority is not higher - so compute what we already have on stack
|
|
// but do not finish proccessing
|
|
|
|
sty OPPTR+1 // store .Y, we want to preserve it
|
|
lda #$FF // mark that we want to return here
|
|
sta OPPTR+0
|
|
!:
|
|
jmp FRMEVL_compute_partial
|
|
|
|
FRMEVL_compute_partial_return:
|
|
|
|
pla
|
|
pha
|
|
bne !-
|
|
|
|
ldy OPPTR+1
|
|
|
|
// FALLTROUGH
|
|
|
|
FRMEVL_push_value_operator:
|
|
|
|
// Push the value from FAC1
|
|
|
|
ldx VALTYP
|
|
bmi FRMEVL_push_string
|
|
|
|
// Push float
|
|
|
|
// XXX implement this
|
|
|
|
FRMEVL_push_string:
|
|
|
|
// Push string - length, address, type
|
|
|
|
lda __FAC1+0
|
|
pha
|
|
|
|
lda __FAC1+1
|
|
pha
|
|
lda __FAC1+2
|
|
pha
|
|
|
|
txa
|
|
pha
|
|
|
|
// FALLTROUGH
|
|
|
|
FRMEVL_push_operator_address:
|
|
|
|
// Check if there is enough stack space; this could not have been done earlier,
|
|
// as this is the place where unary operator support calls
|
|
|
|
jsr check_stack_space
|
|
|
|
// Push the operator address to stack, in a form
|
|
// suitable for RTS
|
|
|
|
lda operator_jumptable_hi, y
|
|
pha
|
|
lda operator_jumptable_lo, y
|
|
pha
|
|
|
|
// Push operator priority
|
|
|
|
lda operator_priorities, y
|
|
pha
|
|
|
|
// Continue
|
|
|
|
jmp FRMEVL_loop
|
|
|
|
//
|
|
// This part serves two purposes:
|
|
// - it is an exit point for the concrete operator implementations
|
|
// - it causes computation of everything which is stored on the stack
|
|
//
|
|
|
|
FRMEVL_compute_all:
|
|
|
|
lda #$00
|
|
sta OPPTR+0
|
|
|
|
// FALLTROUGH
|
|
|
|
FRMEVL_continue:
|
|
|
|
lda OPPTR+0
|
|
bne FRMEVL_compute_partial_return
|
|
|
|
// FALLTROUGH
|
|
|
|
FRMEVL_compute_partial:
|
|
|
|
// Now, we have to compute operation; at this point we should have a value
|
|
// in FAC1 and (most likely) operator on a stack
|
|
|
|
pla // priority does not matter here, get rid of it
|
|
rts // this either jumps to operator, or quits FRMEVL
|