mirror of
https://gitlab.com/camelot/kickc.git
synced 2024-09-29 03:56:15 +00:00
769 lines
18 KiB
NASM
769 lines
18 KiB
NASM
// Tests the speed of printf()
|
|
/// @file
|
|
/// Functions for performing input and output.
|
|
// Commodore 64 PRG executable file
|
|
.file [name="printf-speed.prg", type="prg", segments="Program"]
|
|
.segmentdef Program [segments="Basic, Code, Data"]
|
|
.segmentdef Basic [start=$0801]
|
|
.segmentdef Code [start=$80d]
|
|
.segmentdef Data [startAfter="Code"]
|
|
.segment Basic
|
|
:BasicUpstart(__start)
|
|
.const LIGHT_BLUE = $e
|
|
.const OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS = 1
|
|
.const OFFSET_STRUCT_TIME_OF_DAY_SEC = 1
|
|
.const OFFSET_STRUCT_TIME_OF_DAY_MIN = 2
|
|
.const OFFSET_STRUCT_TIME_OF_DAY_HOURS = 3
|
|
.const OFFSET_STRUCT_MOS6526_CIA_TIMER_A_CONTROL = $e
|
|
.const OFFSET_STRUCT_MOS6526_CIA_TIMER_B_CONTROL = $f
|
|
.const OFFSET_STRUCT_MOS6526_CIA_TOD_HOURS = $b
|
|
.const OFFSET_STRUCT_MOS6526_CIA_TOD_MIN = $a
|
|
.const OFFSET_STRUCT_MOS6526_CIA_TOD_SEC = 9
|
|
.const OFFSET_STRUCT_MOS6526_CIA_TOD_10THS = 8
|
|
.const SIZEOF_STRUCT_PRINTF_BUFFER_NUMBER = $c
|
|
/// Color Ram
|
|
.label COLORRAM = $d800
|
|
/// Default address of screen character matrix
|
|
.label DEFAULT_SCREEN = $400
|
|
/// The CIA#1: keyboard matrix, joystick #1/#2
|
|
.label CIA1 = $dc00
|
|
// The number of bytes on the screen
|
|
// The current cursor x-position
|
|
.label conio_cursor_x = 8
|
|
// The current cursor y-position
|
|
.label conio_cursor_y = 9
|
|
// The current text cursor line start
|
|
.label conio_line_text = $a
|
|
// The current color cursor line start
|
|
.label conio_line_color = $c
|
|
.segment Code
|
|
__start: {
|
|
// __ma char conio_cursor_x = 0
|
|
lda #0
|
|
sta.z conio_cursor_x
|
|
// __ma char conio_cursor_y = 0
|
|
sta.z conio_cursor_y
|
|
// __ma char *conio_line_text = CONIO_SCREEN_TEXT
|
|
lda #<DEFAULT_SCREEN
|
|
sta.z conio_line_text
|
|
lda #>DEFAULT_SCREEN
|
|
sta.z conio_line_text+1
|
|
// __ma char *conio_line_color = CONIO_SCREEN_COLORS
|
|
lda #<COLORRAM
|
|
sta.z conio_line_color
|
|
lda #>COLORRAM
|
|
sta.z conio_line_color+1
|
|
// #pragma constructor_for(conio_c64_init, cputc, clrscr, cscroll)
|
|
jsr conio_c64_init
|
|
jsr main
|
|
rts
|
|
}
|
|
// Set initial cursor position
|
|
conio_c64_init: {
|
|
// Position cursor at current line
|
|
.label BASIC_CURSOR_LINE = $d6
|
|
// char line = *BASIC_CURSOR_LINE
|
|
ldx BASIC_CURSOR_LINE
|
|
// if(line>=CONIO_HEIGHT)
|
|
cpx #$19
|
|
bcc __b1
|
|
ldx #$19-1
|
|
__b1:
|
|
// gotoxy(0, line)
|
|
jsr gotoxy
|
|
// }
|
|
rts
|
|
}
|
|
main: {
|
|
.label i = 2
|
|
// tod_init(TOD_ZERO)
|
|
lda TOD_ZERO
|
|
sta.z tod_init.tod_TENTHS
|
|
lda TOD_ZERO+OFFSET_STRUCT_TIME_OF_DAY_SEC
|
|
sta.z tod_init.tod_SEC
|
|
ldx TOD_ZERO+OFFSET_STRUCT_TIME_OF_DAY_MIN
|
|
ldy TOD_ZERO+OFFSET_STRUCT_TIME_OF_DAY_HOURS
|
|
jsr tod_init
|
|
lda #<0
|
|
sta.z i
|
|
sta.z i+1
|
|
__b1:
|
|
// for(unsigned int i=0;i<10000;i++)
|
|
lda.z i+1
|
|
cmp #>$2710
|
|
bcc __b2
|
|
bne !+
|
|
lda.z i
|
|
cmp #<$2710
|
|
bcc __b2
|
|
!:
|
|
// gotoxy(0, 22)
|
|
ldx #$16
|
|
jsr gotoxy
|
|
// tod_read()
|
|
jsr tod_read
|
|
sta.z tod_read.return_MIN
|
|
lda.z tod_read.return_HOURS
|
|
// tod_str(tod_read())
|
|
sty.z tod_str.tod_TENTHS
|
|
stx.z tod_str.tod_SEC
|
|
ldy.z tod_read.return_MIN
|
|
tax
|
|
jsr tod_str
|
|
// printf("time: %s",tod_str(tod_read()))
|
|
lda #<s
|
|
sta.z cputs.s
|
|
lda #>s
|
|
sta.z cputs.s+1
|
|
jsr cputs
|
|
// printf("time: %s",tod_str(tod_read()))
|
|
jsr printf_string
|
|
// }
|
|
rts
|
|
__b2:
|
|
// i&0x7f
|
|
lda #$7f
|
|
and.z i
|
|
// if((i&0x7f) == 0)
|
|
cmp #0
|
|
bne __b4
|
|
// gotoxy(0,16)
|
|
ldx #$10
|
|
jsr gotoxy
|
|
// printf("%u",i)
|
|
jsr printf_uint
|
|
// gotoxy(0,0)
|
|
ldx #0
|
|
jsr gotoxy
|
|
__b4:
|
|
// printf("qwe ")
|
|
lda #<s1
|
|
sta.z cputs.s
|
|
lda #>s1
|
|
sta.z cputs.s+1
|
|
jsr cputs
|
|
// for(unsigned int i=0;i<10000;i++)
|
|
inc.z i
|
|
bne !+
|
|
inc.z i+1
|
|
!:
|
|
jmp __b1
|
|
.segment Data
|
|
s: .text "time: "
|
|
.byte 0
|
|
s1: .text "qwe "
|
|
.byte 0
|
|
}
|
|
.segment Code
|
|
// Set the cursor to the specified position
|
|
// gotoxy(byte register(X) y)
|
|
gotoxy: {
|
|
.label __5 = $14
|
|
.label __6 = $10
|
|
.label __7 = $10
|
|
.label line_offset = $10
|
|
.label __8 = $12
|
|
.label __9 = $10
|
|
// if(y>CONIO_HEIGHT)
|
|
cpx #$19+1
|
|
bcc __b2
|
|
ldx #0
|
|
__b2:
|
|
// conio_cursor_x = x
|
|
lda #0
|
|
sta.z conio_cursor_x
|
|
// conio_cursor_y = y
|
|
stx.z conio_cursor_y
|
|
// (unsigned int)y*CONIO_WIDTH
|
|
txa
|
|
sta.z __7
|
|
lda #0
|
|
sta.z __7+1
|
|
// unsigned int line_offset = (unsigned int)y*CONIO_WIDTH
|
|
lda.z __7
|
|
asl
|
|
sta.z __8
|
|
lda.z __7+1
|
|
rol
|
|
sta.z __8+1
|
|
asl.z __8
|
|
rol.z __8+1
|
|
clc
|
|
lda.z __9
|
|
adc.z __8
|
|
sta.z __9
|
|
lda.z __9+1
|
|
adc.z __8+1
|
|
sta.z __9+1
|
|
asl.z line_offset
|
|
rol.z line_offset+1
|
|
asl.z line_offset
|
|
rol.z line_offset+1
|
|
asl.z line_offset
|
|
rol.z line_offset+1
|
|
// CONIO_SCREEN_TEXT + line_offset
|
|
lda.z line_offset
|
|
clc
|
|
adc #<DEFAULT_SCREEN
|
|
sta.z __5
|
|
lda.z line_offset+1
|
|
adc #>DEFAULT_SCREEN
|
|
sta.z __5+1
|
|
// conio_line_text = CONIO_SCREEN_TEXT + line_offset
|
|
lda.z __5
|
|
sta.z conio_line_text
|
|
lda.z __5+1
|
|
sta.z conio_line_text+1
|
|
// CONIO_SCREEN_COLORS + line_offset
|
|
lda.z __6
|
|
clc
|
|
adc #<COLORRAM
|
|
sta.z __6
|
|
lda.z __6+1
|
|
adc #>COLORRAM
|
|
sta.z __6+1
|
|
// conio_line_color = CONIO_SCREEN_COLORS + line_offset
|
|
lda.z __6
|
|
sta.z conio_line_color
|
|
lda.z __6+1
|
|
sta.z conio_line_color+1
|
|
// }
|
|
rts
|
|
}
|
|
// Initialize time-of-day clock
|
|
// This uses the MOS6526 CIA#1
|
|
// tod_init(byte zp($f) tod_TENTHS, byte zp($e) tod_SEC, byte register(X) tod_MIN, byte register(Y) tod_HOURS)
|
|
tod_init: {
|
|
.label tod_TENTHS = $f
|
|
.label tod_SEC = $e
|
|
// CIA1->TIMER_A_CONTROL |= 0x80
|
|
// Set 50hz (this assumes PAL!) (bit7=1)
|
|
lda #$80
|
|
ora CIA1+OFFSET_STRUCT_MOS6526_CIA_TIMER_A_CONTROL
|
|
sta CIA1+OFFSET_STRUCT_MOS6526_CIA_TIMER_A_CONTROL
|
|
// CIA1->TIMER_B_CONTROL &= 0x7f
|
|
// Writing TOD clock (bit7=0)
|
|
lda #$7f
|
|
and CIA1+OFFSET_STRUCT_MOS6526_CIA_TIMER_B_CONTROL
|
|
sta CIA1+OFFSET_STRUCT_MOS6526_CIA_TIMER_B_CONTROL
|
|
// CIA1->TOD_HOURS = tod.HOURS
|
|
// Reset TOD clock
|
|
// Writing sequence is important. TOD stops when hours is written and starts when 10ths is written.
|
|
sty CIA1+OFFSET_STRUCT_MOS6526_CIA_TOD_HOURS
|
|
// CIA1->TOD_MIN = tod.MIN
|
|
stx CIA1+OFFSET_STRUCT_MOS6526_CIA_TOD_MIN
|
|
// CIA1->TOD_SEC = tod.SEC
|
|
lda.z tod_SEC
|
|
sta CIA1+OFFSET_STRUCT_MOS6526_CIA_TOD_SEC
|
|
// CIA1->TOD_10THS = tod.TENTHS
|
|
lda.z tod_TENTHS
|
|
sta CIA1+OFFSET_STRUCT_MOS6526_CIA_TOD_10THS
|
|
// }
|
|
rts
|
|
}
|
|
// Read time of day
|
|
tod_read: {
|
|
.label return_HOURS = $16
|
|
.label return_MIN = $e
|
|
// char hours = CIA1->TOD_HOURS
|
|
// Reading sequence is important. TOD latches on reading hours until 10ths is read.
|
|
lda CIA1+OFFSET_STRUCT_MOS6526_CIA_TOD_HOURS
|
|
sta.z return_HOURS
|
|
// char mins = CIA1->TOD_MIN
|
|
lda CIA1+OFFSET_STRUCT_MOS6526_CIA_TOD_MIN
|
|
// char secs = CIA1->TOD_SEC
|
|
ldx CIA1+OFFSET_STRUCT_MOS6526_CIA_TOD_SEC
|
|
// char tenths = CIA1->TOD_10THS
|
|
ldy CIA1+OFFSET_STRUCT_MOS6526_CIA_TOD_10THS
|
|
// }
|
|
rts
|
|
}
|
|
// Convert time of day to a human-readable string "hh:mm:ss:10"
|
|
// tod_str(byte zp($16) tod_TENTHS, byte zp($f) tod_SEC, byte register(Y) tod_MIN, byte register(X) tod_HOURS)
|
|
tod_str: {
|
|
.label tod_TENTHS = $16
|
|
.label tod_SEC = $f
|
|
// tod.HOURS>>4
|
|
txa
|
|
lsr
|
|
lsr
|
|
lsr
|
|
lsr
|
|
// '0'+(tod.HOURS>>4)
|
|
clc
|
|
adc #'0'
|
|
// tod_buffer[0] = '0'+(tod.HOURS>>4)
|
|
sta tod_buffer
|
|
// tod.HOURS&0x0f
|
|
txa
|
|
and #$f
|
|
// '0'+(tod.HOURS&0x0f)
|
|
clc
|
|
adc #'0'
|
|
// tod_buffer[1] = '0'+(tod.HOURS&0x0f)
|
|
sta tod_buffer+1
|
|
// tod.MIN>>4
|
|
tya
|
|
lsr
|
|
lsr
|
|
lsr
|
|
lsr
|
|
// '0'+(tod.MIN>>4)
|
|
clc
|
|
adc #'0'
|
|
// tod_buffer[3] = '0'+(tod.MIN>>4)
|
|
sta tod_buffer+3
|
|
// tod.MIN&0x0f
|
|
tya
|
|
and #$f
|
|
// '0'+(tod.MIN&0x0f)
|
|
clc
|
|
adc #'0'
|
|
// tod_buffer[4] = '0'+(tod.MIN&0x0f)
|
|
sta tod_buffer+4
|
|
// tod.SEC>>4
|
|
lda.z tod_SEC
|
|
lsr
|
|
lsr
|
|
lsr
|
|
lsr
|
|
// '0'+(tod.SEC>>4)
|
|
clc
|
|
adc #'0'
|
|
// tod_buffer[6] = '0'+(tod.SEC>>4)
|
|
sta tod_buffer+6
|
|
// tod.SEC&0x0f
|
|
lda #$f
|
|
and.z tod_SEC
|
|
// '0'+(tod.SEC&0x0f)
|
|
clc
|
|
adc #'0'
|
|
// tod_buffer[7] = '0'+(tod.SEC&0x0f)
|
|
sta tod_buffer+7
|
|
// tod.TENTHS>>4
|
|
lda.z tod_TENTHS
|
|
lsr
|
|
lsr
|
|
lsr
|
|
lsr
|
|
// '0'+(tod.TENTHS>>4)
|
|
clc
|
|
adc #'0'
|
|
// tod_buffer[9] = '0'+(tod.TENTHS>>4)
|
|
sta tod_buffer+9
|
|
// tod.TENTHS&0x0f
|
|
lda #$f
|
|
and.z tod_TENTHS
|
|
// '0'+(tod.TENTHS&0x0f)
|
|
clc
|
|
adc #'0'
|
|
// tod_buffer[10] = '0'+(tod.TENTHS&0x0f)
|
|
sta tod_buffer+$a
|
|
// }
|
|
rts
|
|
}
|
|
// Output a NUL-terminated string at the current cursor position
|
|
// cputs(const byte* zp(4) s)
|
|
cputs: {
|
|
.label s = 4
|
|
__b1:
|
|
// while(c=*s++)
|
|
ldy #0
|
|
lda (s),y
|
|
inc.z s
|
|
bne !+
|
|
inc.z s+1
|
|
!:
|
|
cmp #0
|
|
bne __b2
|
|
// }
|
|
rts
|
|
__b2:
|
|
// cputc(c)
|
|
jsr cputc
|
|
jmp __b1
|
|
}
|
|
// Print a string value using a specific format
|
|
// Handles justification and min length
|
|
printf_string: {
|
|
// cputs(str)
|
|
lda #<tod_buffer
|
|
sta.z cputs.s
|
|
lda #>tod_buffer
|
|
sta.z cputs.s+1
|
|
jsr cputs
|
|
// }
|
|
rts
|
|
}
|
|
// Print an unsigned int using a specific format
|
|
// printf_uint(word zp(2) uvalue)
|
|
printf_uint: {
|
|
.label uvalue = 2
|
|
// printf_buffer.sign = format.sign_always?'+':0
|
|
// Handle any sign
|
|
lda #0
|
|
sta printf_buffer
|
|
// utoa(uvalue, printf_buffer.digits, format.radix)
|
|
lda.z uvalue
|
|
sta.z utoa.value
|
|
lda.z uvalue+1
|
|
sta.z utoa.value+1
|
|
// Format number into buffer
|
|
jsr utoa
|
|
// printf_number_buffer(printf_buffer, format)
|
|
lda printf_buffer
|
|
// Print using format
|
|
jsr printf_number_buffer
|
|
// }
|
|
rts
|
|
}
|
|
// Output one character at the current cursor position
|
|
// Moves the cursor forward. Scrolls the entire screen if needed
|
|
// cputc(byte register(A) c)
|
|
cputc: {
|
|
// if(c=='\n')
|
|
cmp #'\n'
|
|
beq __b1
|
|
// conio_line_text[conio_cursor_x] = c
|
|
ldy.z conio_cursor_x
|
|
sta (conio_line_text),y
|
|
// conio_line_color[conio_cursor_x] = conio_textcolor
|
|
lda #LIGHT_BLUE
|
|
sta (conio_line_color),y
|
|
// if(++conio_cursor_x==CONIO_WIDTH)
|
|
inc.z conio_cursor_x
|
|
lda #$28
|
|
cmp.z conio_cursor_x
|
|
bne __breturn
|
|
// cputln()
|
|
jsr cputln
|
|
__breturn:
|
|
// }
|
|
rts
|
|
__b1:
|
|
// cputln()
|
|
jsr cputln
|
|
rts
|
|
}
|
|
// Converts unsigned number value to a string representing it in RADIX format.
|
|
// If the leading digits are zero they are not included in the string.
|
|
// - value : The number to be converted to RADIX
|
|
// - buffer : receives the string representing the number and zero-termination.
|
|
// - radix : The radix to convert the number to (from the enum RADIX)
|
|
// utoa(word zp(4) value, byte* zp($19) buffer)
|
|
utoa: {
|
|
.const max_digits = 5
|
|
.label digit_value = $17
|
|
.label buffer = $19
|
|
.label digit = $f
|
|
.label value = 4
|
|
lda #<printf_buffer+OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS
|
|
sta.z buffer
|
|
lda #>printf_buffer+OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS
|
|
sta.z buffer+1
|
|
ldx #0
|
|
txa
|
|
sta.z digit
|
|
__b1:
|
|
// for( char digit=0; digit<max_digits-1; digit++ )
|
|
lda.z digit
|
|
cmp #max_digits-1
|
|
bcc __b2
|
|
// *buffer++ = DIGITS[(char)value]
|
|
ldx.z value
|
|
lda DIGITS,x
|
|
ldy #0
|
|
sta (buffer),y
|
|
// *buffer++ = DIGITS[(char)value];
|
|
inc.z buffer
|
|
bne !+
|
|
inc.z buffer+1
|
|
!:
|
|
// *buffer = 0
|
|
lda #0
|
|
tay
|
|
sta (buffer),y
|
|
// }
|
|
rts
|
|
__b2:
|
|
// unsigned int digit_value = digit_values[digit]
|
|
lda.z digit
|
|
asl
|
|
tay
|
|
lda RADIX_DECIMAL_VALUES,y
|
|
sta.z digit_value
|
|
lda RADIX_DECIMAL_VALUES+1,y
|
|
sta.z digit_value+1
|
|
// if (started || value >= digit_value)
|
|
cpx #0
|
|
bne __b5
|
|
cmp.z value+1
|
|
bne !+
|
|
lda.z digit_value
|
|
cmp.z value
|
|
beq __b5
|
|
!:
|
|
bcc __b5
|
|
__b4:
|
|
// for( char digit=0; digit<max_digits-1; digit++ )
|
|
inc.z digit
|
|
jmp __b1
|
|
__b5:
|
|
// utoa_append(buffer++, value, digit_value)
|
|
jsr utoa_append
|
|
// utoa_append(buffer++, value, digit_value)
|
|
// value = utoa_append(buffer++, value, digit_value)
|
|
// value = utoa_append(buffer++, value, digit_value);
|
|
inc.z buffer
|
|
bne !+
|
|
inc.z buffer+1
|
|
!:
|
|
ldx #1
|
|
jmp __b4
|
|
}
|
|
// Print the contents of the number buffer using a specific format.
|
|
// This handles minimum length, zero-filling, and left/right justification from the format
|
|
// printf_number_buffer(byte register(A) buffer_sign)
|
|
printf_number_buffer: {
|
|
.label buffer_digits = printf_buffer+OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS
|
|
// if(buffer.sign)
|
|
cmp #0
|
|
beq __b2
|
|
// cputc(buffer.sign)
|
|
jsr cputc
|
|
__b2:
|
|
// cputs(buffer.digits)
|
|
lda #<buffer_digits
|
|
sta.z cputs.s
|
|
lda #>buffer_digits
|
|
sta.z cputs.s+1
|
|
jsr cputs
|
|
// }
|
|
rts
|
|
}
|
|
// Print a newline
|
|
cputln: {
|
|
// conio_line_text += CONIO_WIDTH
|
|
lda #$28
|
|
clc
|
|
adc.z conio_line_text
|
|
sta.z conio_line_text
|
|
bcc !+
|
|
inc.z conio_line_text+1
|
|
!:
|
|
// conio_line_color += CONIO_WIDTH
|
|
lda #$28
|
|
clc
|
|
adc.z conio_line_color
|
|
sta.z conio_line_color
|
|
bcc !+
|
|
inc.z conio_line_color+1
|
|
!:
|
|
// conio_cursor_x = 0
|
|
lda #0
|
|
sta.z conio_cursor_x
|
|
// conio_cursor_y++;
|
|
inc.z conio_cursor_y
|
|
// cscroll()
|
|
jsr cscroll
|
|
// }
|
|
rts
|
|
}
|
|
// Used to convert a single digit of an unsigned number value to a string representation
|
|
// Counts a single digit up from '0' as long as the value is larger than sub.
|
|
// Each time the digit is increased sub is subtracted from value.
|
|
// - buffer : pointer to the char that receives the digit
|
|
// - value : The value where the digit will be derived from
|
|
// - sub : the value of a '1' in the digit. Subtracted continually while the digit is increased.
|
|
// (For decimal the subs used are 10000, 1000, 100, 10, 1)
|
|
// returns : the value reduced by sub * digit so that it is less than sub.
|
|
// utoa_append(byte* zp($19) buffer, word zp(4) value, word zp($17) sub)
|
|
utoa_append: {
|
|
.label buffer = $19
|
|
.label value = 4
|
|
.label sub = $17
|
|
.label return = 4
|
|
ldx #0
|
|
__b1:
|
|
// while (value >= sub)
|
|
lda.z sub+1
|
|
cmp.z value+1
|
|
bne !+
|
|
lda.z sub
|
|
cmp.z value
|
|
beq __b2
|
|
!:
|
|
bcc __b2
|
|
// *buffer = DIGITS[digit]
|
|
lda DIGITS,x
|
|
ldy #0
|
|
sta (buffer),y
|
|
// }
|
|
rts
|
|
__b2:
|
|
// digit++;
|
|
inx
|
|
// value -= sub
|
|
lda.z value
|
|
sec
|
|
sbc.z sub
|
|
sta.z value
|
|
lda.z value+1
|
|
sbc.z sub+1
|
|
sta.z value+1
|
|
jmp __b1
|
|
}
|
|
// Scroll the entire screen if the cursor is beyond the last line
|
|
cscroll: {
|
|
// if(conio_cursor_y==CONIO_HEIGHT)
|
|
lda #$19
|
|
cmp.z conio_cursor_y
|
|
bne __breturn
|
|
// memcpy(CONIO_SCREEN_TEXT, CONIO_SCREEN_TEXT+CONIO_WIDTH, CONIO_BYTES-CONIO_WIDTH)
|
|
lda #<DEFAULT_SCREEN
|
|
sta.z memcpy.destination
|
|
lda #>DEFAULT_SCREEN
|
|
sta.z memcpy.destination+1
|
|
lda #<DEFAULT_SCREEN+$28
|
|
sta.z memcpy.source
|
|
lda #>DEFAULT_SCREEN+$28
|
|
sta.z memcpy.source+1
|
|
jsr memcpy
|
|
// memcpy(CONIO_SCREEN_COLORS, CONIO_SCREEN_COLORS+CONIO_WIDTH, CONIO_BYTES-CONIO_WIDTH)
|
|
lda #<COLORRAM
|
|
sta.z memcpy.destination
|
|
lda #>COLORRAM
|
|
sta.z memcpy.destination+1
|
|
lda #<COLORRAM+$28
|
|
sta.z memcpy.source
|
|
lda #>COLORRAM+$28
|
|
sta.z memcpy.source+1
|
|
jsr memcpy
|
|
// memset(CONIO_SCREEN_TEXT+CONIO_BYTES-CONIO_WIDTH, ' ', CONIO_WIDTH)
|
|
ldx #' '
|
|
lda #<DEFAULT_SCREEN+$19*$28-$28
|
|
sta.z memset.str
|
|
lda #>DEFAULT_SCREEN+$19*$28-$28
|
|
sta.z memset.str+1
|
|
jsr memset
|
|
// memset(CONIO_SCREEN_COLORS+CONIO_BYTES-CONIO_WIDTH, conio_textcolor, CONIO_WIDTH)
|
|
ldx #LIGHT_BLUE
|
|
lda #<COLORRAM+$19*$28-$28
|
|
sta.z memset.str
|
|
lda #>COLORRAM+$19*$28-$28
|
|
sta.z memset.str+1
|
|
jsr memset
|
|
// conio_line_text -= CONIO_WIDTH
|
|
sec
|
|
lda.z conio_line_text
|
|
sbc #$28
|
|
sta.z conio_line_text
|
|
lda.z conio_line_text+1
|
|
sbc #0
|
|
sta.z conio_line_text+1
|
|
// conio_line_color -= CONIO_WIDTH
|
|
sec
|
|
lda.z conio_line_color
|
|
sbc #$28
|
|
sta.z conio_line_color
|
|
lda.z conio_line_color+1
|
|
sbc #0
|
|
sta.z conio_line_color+1
|
|
// conio_cursor_y--;
|
|
dec.z conio_cursor_y
|
|
__breturn:
|
|
// }
|
|
rts
|
|
}
|
|
// Copy block of memory (forwards)
|
|
// Copies the values of num bytes from the location pointed to by source directly to the memory block pointed to by destination.
|
|
// memcpy(void* zp(6) destination, void* zp($19) source)
|
|
memcpy: {
|
|
.label src_end = $17
|
|
.label dst = 6
|
|
.label src = $19
|
|
.label source = $19
|
|
.label destination = 6
|
|
// char* src_end = (char*)source+num
|
|
lda.z source
|
|
clc
|
|
adc #<$19*$28-$28
|
|
sta.z src_end
|
|
lda.z source+1
|
|
adc #>$19*$28-$28
|
|
sta.z src_end+1
|
|
__b1:
|
|
// while(src!=src_end)
|
|
lda.z src+1
|
|
cmp.z src_end+1
|
|
bne __b2
|
|
lda.z src
|
|
cmp.z src_end
|
|
bne __b2
|
|
// }
|
|
rts
|
|
__b2:
|
|
// *dst++ = *src++
|
|
ldy #0
|
|
lda (src),y
|
|
sta (dst),y
|
|
// *dst++ = *src++;
|
|
inc.z dst
|
|
bne !+
|
|
inc.z dst+1
|
|
!:
|
|
inc.z src
|
|
bne !+
|
|
inc.z src+1
|
|
!:
|
|
jmp __b1
|
|
}
|
|
// Copies the character c (an unsigned char) to the first num characters of the object pointed to by the argument str.
|
|
// memset(void* zp(6) str, byte register(X) c)
|
|
memset: {
|
|
.label end = $19
|
|
.label dst = 6
|
|
.label str = 6
|
|
// char* end = (char*)str + num
|
|
lda #$28
|
|
clc
|
|
adc.z str
|
|
sta.z end
|
|
lda #0
|
|
adc.z str+1
|
|
sta.z end+1
|
|
__b2:
|
|
// for(char* dst = str; dst!=end; dst++)
|
|
lda.z dst+1
|
|
cmp.z end+1
|
|
bne __b3
|
|
lda.z dst
|
|
cmp.z end
|
|
bne __b3
|
|
// }
|
|
rts
|
|
__b3:
|
|
// *dst = c
|
|
txa
|
|
ldy #0
|
|
sta (dst),y
|
|
// for(char* dst = str; dst!=end; dst++)
|
|
inc.z dst
|
|
bne !+
|
|
inc.z dst+1
|
|
!:
|
|
jmp __b2
|
|
}
|
|
.segment Data
|
|
// The digits used for numbers
|
|
DIGITS: .text "0123456789abcdef"
|
|
// Values of decimal digits
|
|
RADIX_DECIMAL_VALUES: .word $2710, $3e8, $64, $a
|
|
// The buffer used by tod_str()
|
|
tod_buffer: .text "00:00:00:00"
|
|
.byte 0
|
|
// Buffer used for stringified number being printed
|
|
printf_buffer: .fill SIZEOF_STRUCT_PRINTF_BUFFER_NUMBER, 0
|
|
/// Time of Day 00:00:00:00
|
|
TOD_ZERO: .byte 0, 0, 0, 0
|