6502/kickc
1
0
Fork 0
mirror of https://gitlab.com/camelot/kickc.git synced 2025-04-05 07:40:39 +00:00
Code Issues Projects Releases Wiki Activity

Added circle chars test.

Browse Source
This commit is contained in:
Jesper Gravgaard 2020-05-06 22:36:46 +02:00
parent 1aa1551ea8
commit a6d0f4a541
7 changed files with 9568 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/test/java/dk/camelot64/kickc/test/TestPrograms.java
View File

@ -40,6 +40,11 @@ public class TestPrograms {
public TestPrograms() {
}
@Test
public void testCircleChars() throws IOException, URISyntaxException {
compileAndCompare("circlechars.c");
}
@Test
public void testPolygon() throws IOException, URISyntaxException {
compileAndCompare("complex/polygon/polygon.c");

28
src/test/kc/circlechars.c Normal file
View File

@ -0,0 +1,28 @@
// Plot a r=9 circle on the screen using chars - count how many chars are used
#include <string.h>
#include <multiply.h>
#include <conio.h>
#include <stdio.h>
char* const SCREEN = 0x0400;
void main() {
memset(SCREEN, ' ', 1000);
unsigned int count = 0;
char* sc = SCREEN;
for(char y=0;y<25;y++) {
for(char x=0;x<40;x++) {
signed char xd = (signed char)x*2-39;
signed char yd = (signed char)y*2-24;
signed int dist_sq = mul8s(xd,xd) + mul8s(yd,yd);
if(dist_sq<2*9*2*9) {
*sc = '*';
count++;
}
sc++;
}
}
gotoxy(0,0);
printf("%u chars",count);
}

2
src/test/kc/printf-13.c
View File

@ -20,7 +20,7 @@ void main() {
printf("%%03d '%03d' '%03d' '%03d' '%3d'\n", 1, 11, 111, 1111);
// octal
printf("%%o '%o' '%o' '%o' '%o'\n", 1, 11, 111, 1111);
// hexadecimal
// hexadecimals
printf("%%x '%x' '%x' '%x' '%x'\n", 1, 11, 111, 1111);
// hexadecimal upper-case
printf("%%X '%X' '%X' '%X' '%X'\n", 1, 11, 111, 1111);

701
src/test/ref/circlechars.asm Normal file
View File

@ -0,0 +1,701 @@
// Plot a r=9 circle on the screen using chars - count how many chars are used
.pc = $801 "Basic"
:BasicUpstart(__bbegin)
.pc = $80d "Program"
// The default text color
.const CONIO_TEXTCOLOR_DEFAULT = $e
.const OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS = 1
.const SIZEOF_STRUCT_PRINTF_BUFFER_NUMBER = $c
// The screen width
// The screen height
// The screen bytes
// The text screen address
.label CONIO_SCREEN_TEXT = $400
// The color screen address
.label CONIO_SCREEN_COLORS = $d800
.label SCREEN = $400
.label conio_cursor_x = $b
.label conio_cursor_y = $c
.label conio_cursor_text = $d
.label conio_cursor_color = $f
__bbegin:
// conio_cursor_x = 0
// The current cursor x-position
lda #0
sta.z conio_cursor_x
// conio_cursor_y = 0
// The current cursor y-position
sta.z conio_cursor_y
// conio_cursor_text = CONIO_SCREEN_TEXT
// The current cursor address
lda #<CONIO_SCREEN_TEXT
sta.z conio_cursor_text
lda #>CONIO_SCREEN_TEXT
sta.z conio_cursor_text+1
// conio_cursor_color = CONIO_SCREEN_COLORS
// The current cursor address
lda #<CONIO_SCREEN_COLORS
sta.z conio_cursor_color
lda #>CONIO_SCREEN_COLORS
sta.z conio_cursor_color+1
jsr main
rts
main: {
.label __9 = $12
.label __10 = 6
.label yd = $11
.label dist_sq = $12
.label y = $b
.label sc = 4
.label x = $c
.label count = 2
// memset(SCREEN, ' ', 1000)
ldx #' '
lda #<SCREEN
sta.z memset.str
lda #>SCREEN
sta.z memset.str+1
lda #<$3e8
sta.z memset.num
lda #>$3e8
sta.z memset.num+1
jsr memset
lda #<SCREEN
sta.z sc
lda #>SCREEN
sta.z sc+1
lda #<0
sta.z count
sta.z count+1
sta.z y
__b1:
// for(char y=0;y<25;y++)
lda.z y
cmp #$19
bcc __b2
// gotoxy(0,0)
jsr gotoxy
// printf("%u chars",count)
jsr printf_uint
// printf("%u chars",count)
lda #<s
sta.z cputs.s
lda #>s
sta.z cputs.s+1
jsr cputs
// }
rts
__b2:
lda #0
sta.z x
__b3:
// for(char x=0;x<40;x++)
lda.z x
cmp #$28
bcc __b4
// for(char y=0;y<25;y++)
inc.z y
jmp __b1
__b4:
// (signed char)x*2
lda.z x
asl
// xd = (signed char)x*2-39
tax
axs #$27
// (signed char)y*2
lda.z y
asl
// yd = (signed char)y*2-24
sec
sbc #$18
sta.z yd
// mul8s(xd,xd)
stx.z mul8s.a
txa
tay
jsr mul8s
// mul8s(xd,xd)
lda.z mul8s.m
sta.z __9
lda.z mul8s.m+1
sta.z __9+1
// mul8s(yd,yd)
lda.z yd
sta.z mul8s.a
ldy.z yd
jsr mul8s
// mul8s(yd,yd)
// dist_sq = mul8s(xd,xd) + mul8s(yd,yd)
lda.z dist_sq
clc
adc.z __10
sta.z dist_sq
lda.z dist_sq+1
adc.z __10+1
sta.z dist_sq+1
// if(dist_sq<2*9*2*9)
lda.z dist_sq
cmp #<2*9*2*9
lda.z dist_sq+1
sbc #>2*9*2*9
bvc !+
eor #$80
!:
bpl __b6
// *sc = '*'
lda #'*'
ldy #0
sta (sc),y
// count++;
inc.z count
bne !+
inc.z count+1
!:
__b6:
// sc++;
inc.z sc
bne !+
inc.z sc+1
!:
// for(char x=0;x<40;x++)
inc.z x
jmp __b3
s: .text " chars"
.byte 0
}
// Multiply of two signed chars to a signed int
// Fixes offsets introduced by using unsigned multiplication
// mul8s(signed byte zp($a) a, signed byte register(Y) b)
mul8s: {
.label m = 6
.label a = $a
// mul8u((char)a, (char) b)
ldx.z a
tya
jsr mul8u
// m = mul8u((char)a, (char) b)
// if(a<0)
lda.z a
cmp #0
bpl __b1
// >m
lda.z m+1
// >m = (>m)-(char)b
sty.z $ff
sec
sbc.z $ff
sta.z m+1
__b1:
// if(b<0)
cpy #0
bpl __b2
// >m
lda.z m+1
// >m = (>m)-(char)a
sec
sbc.z a
sta.z m+1
__b2:
// }
rts
}
// Perform binary multiplication of two unsigned 8-bit chars into a 16-bit unsigned int
// mul8u(byte register(X) a, byte register(A) b)
mul8u: {
.label mb = 8
.label res = 6
.label return = 6
// mb = b
sta.z mb
lda #0
sta.z mb+1
sta.z res
sta.z res+1
__b1:
// while(a!=0)
cpx #0
bne __b2
// }
rts
__b2:
// a&1
txa
and #1
// if( (a&1) != 0)
cmp #0
beq __b3
// res = res + mb
lda.z res
clc
adc.z mb
sta.z res
lda.z res+1
adc.z mb+1
sta.z res+1
__b3:
// a = a>>1
txa
lsr
tax
// mb = mb<<1
asl.z mb
rol.z mb+1
jmp __b1
}
// Output a NUL-terminated string at the current cursor position
// cputs(byte* zp(8) s)
cputs: {
.label s = 8
__b1:
// c=*s++
ldy #0
lda (s),y
// while(c=*s++)
inc.z s
bne !+
inc.z s+1
!:
cmp #0
bne __b2
// }
rts
__b2:
// cputc(c)
jsr cputc
jmp __b1
}
// 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_cursor_text++ = c
ldy #0
sta (conio_cursor_text),y
// *conio_cursor_text++ = c;
inc.z conio_cursor_text
bne !+
inc.z conio_cursor_text+1
!:
// *conio_cursor_color++ = conio_textcolor
lda #CONIO_TEXTCOLOR_DEFAULT
ldy #0
sta (conio_cursor_color),y
// *conio_cursor_color++ = conio_textcolor;
inc.z conio_cursor_color
bne !+
inc.z conio_cursor_color+1
!:
// if(++conio_cursor_x==CONIO_WIDTH)
inc.z conio_cursor_x
lda #$28
cmp.z conio_cursor_x
bne __breturn
// conio_cursor_x = 0
lda #0
sta.z conio_cursor_x
// ++conio_cursor_y;
inc.z conio_cursor_y
// cscroll()
jsr cscroll
__breturn:
// }
rts
__b1:
// cputln()
jsr cputln
rts
}
// Print a newline
cputln: {
.label __1 = $d
.label __2 = $f
.label ln_offset = $16
// ln_offset = CONIO_WIDTH - conio_cursor_x
sec
lda #$28
sbc.z conio_cursor_x
sta.z ln_offset
lda #0
sbc #0
sta.z ln_offset+1
// conio_cursor_text + ln_offset
lda.z __1
clc
adc.z ln_offset
sta.z __1
lda.z __1+1
adc.z ln_offset+1
sta.z __1+1
// conio_cursor_text = conio_cursor_text + ln_offset
// conio_cursor_color + ln_offset
lda.z __2
clc
adc.z ln_offset
sta.z __2
lda.z __2+1
adc.z ln_offset+1
sta.z __2+1
// conio_cursor_color = conio_cursor_color + ln_offset
// conio_cursor_x = 0
lda #0
sta.z conio_cursor_x
// conio_cursor_y++;
inc.z conio_cursor_y
// cscroll()
jsr cscroll
// }
rts
}
// Scroll the entire screen if the cursor is beyond the last line
cscroll: {
.label __7 = $d
.label __8 = $f
// 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 #<CONIO_SCREEN_TEXT
sta.z memcpy.destination
lda #>CONIO_SCREEN_TEXT
sta.z memcpy.destination+1
lda #<CONIO_SCREEN_TEXT+$28
sta.z memcpy.source
lda #>CONIO_SCREEN_TEXT+$28
sta.z memcpy.source+1
jsr memcpy
// memcpy(CONIO_SCREEN_COLORS, CONIO_SCREEN_COLORS+CONIO_WIDTH, CONIO_BYTES-CONIO_WIDTH)
lda #<CONIO_SCREEN_COLORS
sta.z memcpy.destination
lda #>CONIO_SCREEN_COLORS
sta.z memcpy.destination+1
lda #<CONIO_SCREEN_COLORS+$28
sta.z memcpy.source
lda #>CONIO_SCREEN_COLORS+$28
sta.z memcpy.source+1
jsr memcpy
// memset(CONIO_SCREEN_TEXT+CONIO_BYTES-CONIO_WIDTH, ' ', CONIO_WIDTH)
ldx #' '
lda #<CONIO_SCREEN_TEXT+$19*$28-$28
sta.z memset.str
lda #>CONIO_SCREEN_TEXT+$19*$28-$28
sta.z memset.str+1
lda #<$28
sta.z memset.num
lda #>$28
sta.z memset.num+1
jsr memset
// memset(CONIO_SCREEN_COLORS+CONIO_BYTES-CONIO_WIDTH, conio_textcolor, CONIO_WIDTH)
ldx #CONIO_TEXTCOLOR_DEFAULT
lda #<CONIO_SCREEN_COLORS+$19*$28-$28
sta.z memset.str
lda #>CONIO_SCREEN_COLORS+$19*$28-$28
sta.z memset.str+1
lda #<$28
sta.z memset.num
lda #>$28
sta.z memset.num+1
jsr memset
// conio_cursor_text-CONIO_WIDTH
lda.z __7
sec
sbc #<$28
sta.z __7
lda.z __7+1
sbc #>$28
sta.z __7+1
// conio_cursor_text = conio_cursor_text-CONIO_WIDTH
// conio_cursor_color-CONIO_WIDTH
lda.z __8
sec
sbc #<$28
sta.z __8
lda.z __8+1
sbc #>$28
sta.z __8+1
// conio_cursor_color = conio_cursor_color-CONIO_WIDTH
// conio_cursor_y--;
dec.z conio_cursor_y
__breturn:
// }
rts
}
// Copies the character c (an unsigned char) to the first num characters of the object pointed to by the argument str.
// memset(void* zp($16) str, byte register(X) c, word zp($12) num)
memset: {
.label end = $12
.label dst = $16
.label num = $12
.label str = $16
// if(num>0)
lda.z num
bne !+
lda.z num+1
beq __breturn
!:
// end = (char*)str + num
lda.z end
clc
adc.z str
sta.z end
lda.z end+1
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
__breturn:
// }
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
}
// 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($16) destination, void* zp($12) source)
memcpy: {
.label src_end = $14
.label dst = $16
.label src = $12
.label source = $12
.label destination = $16
// 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
}
// 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)
// Format number into buffer
jsr utoa
// printf_number_buffer(printf_buffer, format)
lda printf_buffer
// Print using format
jsr printf_number_buffer
// }
rts
}
// 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
}
// 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(2) value, byte* zp($12) buffer)
utoa: {
.const max_digits = 5
.label digit_value = $16
.label buffer = $12
.label digit = $a
.label value = 2
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]
lda.z value
tay
lda DIGITS,y
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:
// 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
}
// 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($12) buffer, word zp(2) value, word zp($16) sub)
utoa_append: {
.label buffer = $12
.label value = 2
.label sub = $16
.label return = 2
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
}
// Set the cursor to the specified position
gotoxy: {
.const x = 0
.const y = 0
// conio_cursor_x = x
lda #x
sta.z conio_cursor_x
// conio_cursor_y = y
lda #y
sta.z conio_cursor_y
// conio_cursor_text = CONIO_SCREEN_TEXT + offset
lda #<CONIO_SCREEN_TEXT
sta.z conio_cursor_text
lda #>CONIO_SCREEN_TEXT
sta.z conio_cursor_text+1
// conio_cursor_color = CONIO_SCREEN_COLORS + offset
lda #<CONIO_SCREEN_COLORS
sta.z conio_cursor_color
lda #>CONIO_SCREEN_COLORS
sta.z conio_cursor_color+1
// }
rts
}
// The digits used for numbers
DIGITS: .text "0123456789abcdef"
// Values of decimal digits
RADIX_DECIMAL_VALUES: .word $2710, $3e8, $64, $a
// Buffer used for stringified number being printed
printf_buffer: .fill SIZEOF_STRUCT_PRINTF_BUFFER_NUMBER, 0

392
src/test/ref/circlechars.cfg Normal file
View File

@ -0,0 +1,392 @@
@begin: scope:[] from
[0] phi()
to:@1
@1: scope:[] from @begin
[1] (byte) conio_cursor_x ← (byte) 0
[2] (byte) conio_cursor_y ← (byte) 0
[3] (byte*) conio_cursor_text ← (const nomodify byte*) CONIO_SCREEN_TEXT
[4] (byte*) conio_cursor_color ← (const nomodify byte*) CONIO_SCREEN_COLORS
to:@2
@2: scope:[] from @1
[5] phi()
[6] call main
to:@end
@end: scope:[] from @2
[7] phi()
(void()) main()
main: scope:[main] from @2
[8] phi()
[9] call memset
to:main::@1
main::@1: scope:[main] from main main::@5
[10] (byte*) main::sc#8 ← phi( main::@5/(byte*) main::sc#10 main/(const nomodify byte*) SCREEN )
[10] (word) main::count#11 ← phi( main::@5/(word) main::count#10 main/(word) 0 )
[10] (byte) main::y#2 ← phi( main::@5/(byte) main::y#1 main/(byte) 0 )
[11] if((byte) main::y#2<(byte) $19) goto main::@3
to:main::@2
main::@2: scope:[main] from main::@1
[12] phi()
[13] call gotoxy
to:main::@8
main::@8: scope:[main] from main::@2
[14] (word) printf_uint::uvalue#0 ← (word) main::count#11
[15] call printf_uint
to:main::@9
main::@9: scope:[main] from main::@8
[16] phi()
[17] call cputs
to:main::@return
main::@return: scope:[main] from main::@9
[18] return
to:@return
main::@3: scope:[main] from main::@1 main::@6
[19] (word) main::count#10 ← phi( main::@1/(word) main::count#11 main::@6/(word) main::count#12 )
[19] (byte*) main::sc#10 ← phi( main::@1/(byte*) main::sc#8 main::@6/(byte*) main::sc#1 )
[19] (byte) main::x#2 ← phi( main::@1/(byte) 0 main::@6/(byte) main::x#1 )
[20] if((byte) main::x#2<(byte) $28) goto main::@4
to:main::@5
main::@5: scope:[main] from main::@3
[21] (byte) main::y#1 ← ++ (byte) main::y#2
to:main::@1
main::@4: scope:[main] from main::@3
[22] (signed byte~) main::$5 ← (signed byte)(byte) main::x#2 << (byte) 1
[23] (signed byte) main::xd#0 ← (signed byte~) main::$5 - (signed byte) $27
[24] (signed byte~) main::$7 ← (signed byte)(byte) main::y#2 << (byte) 1
[25] (signed byte) main::yd#0 ← (signed byte~) main::$7 - (signed byte) $18
[26] (signed byte) mul8s::a#0 ← (signed byte) main::xd#0
[27] (signed byte) mul8s::b#0 ← (signed byte) main::xd#0
[28] call mul8s
to:main::@10
main::@10: scope:[main] from main::@4
[29] (signed word~) main::$9 ← (signed word)(word) mul8s::m#4
[30] (signed byte) mul8s::a#1 ← (signed byte) main::yd#0
[31] (signed byte) mul8s::b#1 ← (signed byte) main::yd#0
[32] call mul8s
to:main::@11
main::@11: scope:[main] from main::@10
[33] (signed word~) main::$10 ← (signed word)(word) mul8s::m#4
[34] (signed word) main::dist_sq#0 ← (signed word~) main::$9 + (signed word~) main::$10
[35] if((signed word) main::dist_sq#0>=(signed word)(number) 2*(number) 9*(number) 2*(number) 9) goto main::@6
to:main::@7
main::@7: scope:[main] from main::@11
[36] *((byte*) main::sc#10) ← (byte) '*'
[37] (word) main::count#1 ← ++ (word) main::count#10
to:main::@6
main::@6: scope:[main] from main::@11 main::@7
[38] (word) main::count#12 ← phi( main::@11/(word) main::count#10 main::@7/(word) main::count#1 )
[39] (byte*) main::sc#1 ← ++ (byte*) main::sc#10
[40] (byte) main::x#1 ← ++ (byte) main::x#2
to:main::@3
(signed word()) mul8s((signed byte) mul8s::a , (signed byte) mul8s::b)
mul8s: scope:[mul8s] from main::@10 main::@4
[41] (signed byte) mul8s::b#2 ← phi( main::@10/(signed byte) mul8s::b#1 main::@4/(signed byte) mul8s::b#0 )
[41] (signed byte) mul8s::a#2 ← phi( main::@10/(signed byte) mul8s::a#1 main::@4/(signed byte) mul8s::a#0 )
[42] (byte) mul8u::a#1 ← (byte)(signed byte) mul8s::a#2
[43] (byte) mul8u::b#0 ← (byte)(signed byte) mul8s::b#2
[44] call mul8u
[45] (word) mul8u::return#2 ← (word) mul8u::res#2
to:mul8s::@5
mul8s::@5: scope:[mul8s] from mul8s
[46] (word) mul8s::m#0 ← (word) mul8u::return#2
[47] if((signed byte) mul8s::a#2>=(signed byte) 0) goto mul8s::@1
to:mul8s::@3
mul8s::@3: scope:[mul8s] from mul8s::@5
[48] (byte~) mul8s::$6 ← > (word) mul8s::m#0
[49] (byte~) mul8s::$11 ← (byte~) mul8s::$6 - (byte)(signed byte) mul8s::b#2
[50] (word) mul8s::m#1 ← (word) mul8s::m#0 hi= (byte~) mul8s::$11
to:mul8s::@1
mul8s::@1: scope:[mul8s] from mul8s::@3 mul8s::@5
[51] (word) mul8s::m#5 ← phi( mul8s::@3/(word) mul8s::m#1 mul8s::@5/(word) mul8s::m#0 )
[52] if((signed byte) mul8s::b#2>=(signed byte) 0) goto mul8s::@2
to:mul8s::@4
mul8s::@4: scope:[mul8s] from mul8s::@1
[53] (byte~) mul8s::$9 ← > (word) mul8s::m#5
[54] (byte~) mul8s::$12 ← (byte~) mul8s::$9 - (byte)(signed byte) mul8s::a#2
[55] (word) mul8s::m#2 ← (word) mul8s::m#5 hi= (byte~) mul8s::$12
to:mul8s::@2
mul8s::@2: scope:[mul8s] from mul8s::@1 mul8s::@4
[56] (word) mul8s::m#4 ← phi( mul8s::@1/(word) mul8s::m#5 mul8s::@4/(word) mul8s::m#2 )
to:mul8s::@return
mul8s::@return: scope:[mul8s] from mul8s::@2
[57] return
to:@return
(word()) mul8u((byte) mul8u::a , (byte) mul8u::b)
mul8u: scope:[mul8u] from mul8s
[58] (word) mul8u::mb#0 ← (word)(byte) mul8u::b#0
to:mul8u::@1
mul8u::@1: scope:[mul8u] from mul8u mul8u::@3
[59] (word) mul8u::mb#2 ← phi( mul8u/(word) mul8u::mb#0 mul8u::@3/(word) mul8u::mb#1 )
[59] (word) mul8u::res#2 ← phi( mul8u/(word) 0 mul8u::@3/(word) mul8u::res#6 )
[59] (byte) mul8u::a#2 ← phi( mul8u/(byte) mul8u::a#1 mul8u::@3/(byte) mul8u::a#0 )
[60] if((byte) mul8u::a#2!=(byte) 0) goto mul8u::@2
to:mul8u::@return
mul8u::@return: scope:[mul8u] from mul8u::@1
[61] return
to:@return
mul8u::@2: scope:[mul8u] from mul8u::@1
[62] (byte~) mul8u::$1 ← (byte) mul8u::a#2 & (byte) 1
[63] if((byte~) mul8u::$1==(byte) 0) goto mul8u::@3
to:mul8u::@4
mul8u::@4: scope:[mul8u] from mul8u::@2
[64] (word) mul8u::res#1 ← (word) mul8u::res#2 + (word) mul8u::mb#2
to:mul8u::@3
mul8u::@3: scope:[mul8u] from mul8u::@2 mul8u::@4
[65] (word) mul8u::res#6 ← phi( mul8u::@2/(word) mul8u::res#2 mul8u::@4/(word) mul8u::res#1 )
[66] (byte) mul8u::a#0 ← (byte) mul8u::a#2 >> (byte) 1
[67] (word) mul8u::mb#1 ← (word) mul8u::mb#2 << (byte) 1
to:mul8u::@1
(void()) cputs((to_nomodify byte*) cputs::s)
cputs: scope:[cputs] from main::@9 printf_number_buffer::@2
[68] (to_nomodify byte*) cputs::s#4 ← phi( main::@9/(const byte*) main::s printf_number_buffer::@2/(const byte*) printf_number_buffer::buffer_digits#0 )
to:cputs::@1
cputs::@1: scope:[cputs] from cputs cputs::@2
[69] (to_nomodify byte*) cputs::s#3 ← phi( cputs/(to_nomodify byte*) cputs::s#4 cputs::@2/(to_nomodify byte*) cputs::s#0 )
[70] (byte) cputs::c#1 ← *((to_nomodify byte*) cputs::s#3)
[71] (to_nomodify byte*) cputs::s#0 ← ++ (to_nomodify byte*) cputs::s#3
[72] if((byte) 0!=(byte) cputs::c#1) goto cputs::@2
to:cputs::@return
cputs::@return: scope:[cputs] from cputs::@1
[73] return
to:@return
cputs::@2: scope:[cputs] from cputs::@1
[74] (byte) cputc::c#0 ← (byte) cputs::c#1
[75] call cputc
to:cputs::@1
(void()) cputc((byte) cputc::c)
cputc: scope:[cputc] from cputs::@2 printf_number_buffer::@3
[76] (byte) cputc::c#3 ← phi( cputs::@2/(byte) cputc::c#0 printf_number_buffer::@3/(byte) cputc::c#2 )
[77] if((byte) cputc::c#3==(byte) '
') goto cputc::@1
to:cputc::@2
cputc::@2: scope:[cputc] from cputc
[78] *((byte*) conio_cursor_text) ← (byte) cputc::c#3
[79] (byte*) conio_cursor_text ← ++ (byte*) conio_cursor_text
[80] *((byte*) conio_cursor_color) ← (const nomodify byte) CONIO_TEXTCOLOR_DEFAULT
[81] (byte*) conio_cursor_color ← ++ (byte*) conio_cursor_color
[82] (byte) conio_cursor_x ← ++ (byte) conio_cursor_x
[83] if((byte) conio_cursor_x!=(byte) $28) goto cputc::@return
to:cputc::@3
cputc::@3: scope:[cputc] from cputc::@2
[84] (byte) conio_cursor_x ← (byte) 0
[85] (byte) conio_cursor_y ← ++ (byte) conio_cursor_y
[86] call cscroll
to:cputc::@return
cputc::@return: scope:[cputc] from cputc::@1 cputc::@2 cputc::@3
[87] return
to:@return
cputc::@1: scope:[cputc] from cputc
[88] phi()
[89] call cputln
to:cputc::@return
(void()) cputln()
cputln: scope:[cputln] from cputc::@1
[90] (word) cputln::ln_offset#0 ← (byte) $28 - (byte) conio_cursor_x
[91] (byte*~) cputln::$1 ← (byte*) conio_cursor_text + (word) cputln::ln_offset#0
[92] (byte*) conio_cursor_text ← (byte*~) cputln::$1
[93] (byte*~) cputln::$2 ← (byte*) conio_cursor_color + (word) cputln::ln_offset#0
[94] (byte*) conio_cursor_color ← (byte*~) cputln::$2
[95] (byte) conio_cursor_x ← (byte) 0
[96] (byte) conio_cursor_y ← ++ (byte) conio_cursor_y
[97] call cscroll
to:cputln::@return
cputln::@return: scope:[cputln] from cputln
[98] return
to:@return
(void()) cscroll()
cscroll: scope:[cscroll] from cputc::@3 cputln
[99] if((byte) conio_cursor_y!=(byte) $19) goto cscroll::@return
to:cscroll::@1
cscroll::@1: scope:[cscroll] from cscroll
[100] phi()
[101] call memcpy
to:cscroll::@2
cscroll::@2: scope:[cscroll] from cscroll::@1
[102] phi()
[103] call memcpy
to:cscroll::@3
cscroll::@3: scope:[cscroll] from cscroll::@2
[104] phi()
[105] call memset
to:cscroll::@4
cscroll::@4: scope:[cscroll] from cscroll::@3
[106] phi()
[107] call memset
to:cscroll::@5
cscroll::@5: scope:[cscroll] from cscroll::@4
[108] (byte*~) cscroll::$7 ← (byte*) conio_cursor_text - (byte) $28
[109] (byte*) conio_cursor_text ← (byte*~) cscroll::$7
[110] (byte*~) cscroll::$8 ← (byte*) conio_cursor_color - (byte) $28
[111] (byte*) conio_cursor_color ← (byte*~) cscroll::$8
[112] (byte) conio_cursor_y ← -- (byte) conio_cursor_y
to:cscroll::@return
cscroll::@return: scope:[cscroll] from cscroll cscroll::@5
[113] return
to:@return
(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
memset: scope:[memset] from cscroll::@3 cscroll::@4 main
[114] (byte) memset::c#5 ← phi( cscroll::@3/(byte) ' ' cscroll::@4/(const nomodify byte) CONIO_TEXTCOLOR_DEFAULT main/(byte) ' ' )
[114] (void*) memset::str#4 ← phi( cscroll::@3/(void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(word)(number) $19*(number) $28-(byte) $28 cscroll::@4/(void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(word)(number) $19*(number) $28-(byte) $28 main/(void*)(const nomodify byte*) SCREEN )
[114] (word) memset::num#3 ← phi( cscroll::@3/(byte) $28 cscroll::@4/(byte) $28 main/(word) $3e8 )
[115] if((word) memset::num#3<=(byte) 0) goto memset::@return
to:memset::@1
memset::@1: scope:[memset] from memset
[116] (byte*) memset::end#0 ← (byte*)(void*) memset::str#4 + (word) memset::num#3
[117] (byte*) memset::dst#4 ← (byte*)(void*) memset::str#4
to:memset::@2
memset::@2: scope:[memset] from memset::@1 memset::@3
[118] (byte*) memset::dst#2 ← phi( memset::@1/(byte*) memset::dst#4 memset::@3/(byte*) memset::dst#1 )
[119] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@3
to:memset::@return
memset::@return: scope:[memset] from memset memset::@2
[120] return
to:@return
memset::@3: scope:[memset] from memset::@2
[121] *((byte*) memset::dst#2) ← (byte) memset::c#5
[122] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2
to:memset::@2
(void*()) memcpy((void*) memcpy::destination , (void*) memcpy::source , (word) memcpy::num)
memcpy: scope:[memcpy] from cscroll::@1 cscroll::@2
[123] (void*) memcpy::destination#2 ← phi( cscroll::@1/(void*)(const nomodify byte*) CONIO_SCREEN_TEXT cscroll::@2/(void*)(const nomodify byte*) CONIO_SCREEN_COLORS )
[123] (void*) memcpy::source#2 ← phi( cscroll::@1/(void*)(const nomodify byte*) CONIO_SCREEN_TEXT+(byte) $28 cscroll::@2/(void*)(const nomodify byte*) CONIO_SCREEN_COLORS+(byte) $28 )
[124] (byte*) memcpy::src_end#0 ← (byte*)(void*) memcpy::source#2 + (word)(number) $19*(number) $28-(number) $28
[125] (byte*) memcpy::src#4 ← (byte*)(void*) memcpy::source#2
[126] (byte*) memcpy::dst#4 ← (byte*)(void*) memcpy::destination#2
to:memcpy::@1
memcpy::@1: scope:[memcpy] from memcpy memcpy::@2
[127] (byte*) memcpy::dst#2 ← phi( memcpy/(byte*) memcpy::dst#4 memcpy::@2/(byte*) memcpy::dst#1 )
[127] (byte*) memcpy::src#2 ← phi( memcpy/(byte*) memcpy::src#4 memcpy::@2/(byte*) memcpy::src#1 )
[128] if((byte*) memcpy::src#2!=(byte*) memcpy::src_end#0) goto memcpy::@2
to:memcpy::@return
memcpy::@return: scope:[memcpy] from memcpy::@1
[129] return
to:@return
memcpy::@2: scope:[memcpy] from memcpy::@1
[130] *((byte*) memcpy::dst#2) ← *((byte*) memcpy::src#2)
[131] (byte*) memcpy::dst#1 ← ++ (byte*) memcpy::dst#2
[132] (byte*) memcpy::src#1 ← ++ (byte*) memcpy::src#2
to:memcpy::@1
(void()) printf_uint((word) printf_uint::uvalue , (byte) printf_uint::format_min_length , (byte) printf_uint::format_justify_left , (byte) printf_uint::format_sign_always , (byte) printf_uint::format_zero_padding , (byte) printf_uint::format_upper_case , (byte) printf_uint::format_radix)
printf_uint: scope:[printf_uint] from main::@8
[133] phi()
to:printf_uint::@1
printf_uint::@1: scope:[printf_uint] from printf_uint
[134] *((byte*)&(struct printf_buffer_number) printf_buffer) ← (byte) 0
[135] (word) utoa::value#1 ← (word) printf_uint::uvalue#0
[136] call utoa
to:printf_uint::@2
printf_uint::@2: scope:[printf_uint] from printf_uint::@1
[137] (byte) printf_number_buffer::buffer_sign#0 ← *((byte*)&(struct printf_buffer_number) printf_buffer)
[138] call printf_number_buffer
to:printf_uint::@return
printf_uint::@return: scope:[printf_uint] from printf_uint::@2
[139] return
to:@return
(void()) printf_number_buffer((byte) printf_number_buffer::buffer_sign , (byte*) printf_number_buffer::buffer_digits , (byte) printf_number_buffer::format_min_length , (byte) printf_number_buffer::format_justify_left , (byte) printf_number_buffer::format_sign_always , (byte) printf_number_buffer::format_zero_padding , (byte) printf_number_buffer::format_upper_case , (byte) printf_number_buffer::format_radix)
printf_number_buffer: scope:[printf_number_buffer] from printf_uint::@2
[140] phi()
to:printf_number_buffer::@1
printf_number_buffer::@1: scope:[printf_number_buffer] from printf_number_buffer
[141] if((byte) 0==(byte) printf_number_buffer::buffer_sign#0) goto printf_number_buffer::@2
to:printf_number_buffer::@3
printf_number_buffer::@3: scope:[printf_number_buffer] from printf_number_buffer::@1
[142] (byte) cputc::c#2 ← (byte) printf_number_buffer::buffer_sign#0
[143] call cputc
to:printf_number_buffer::@2
printf_number_buffer::@2: scope:[printf_number_buffer] from printf_number_buffer::@1 printf_number_buffer::@3
[144] phi()
[145] call cputs
to:printf_number_buffer::@return
printf_number_buffer::@return: scope:[printf_number_buffer] from printf_number_buffer::@2
[146] return
to:@return
(void()) utoa((word) utoa::value , (byte*) utoa::buffer , (byte) utoa::radix)
utoa: scope:[utoa] from printf_uint::@1
[147] phi()
to:utoa::@1
utoa::@1: scope:[utoa] from utoa utoa::@4
[148] (byte*) utoa::buffer#11 ← phi( utoa::@4/(byte*) utoa::buffer#14 utoa/(byte*)&(struct printf_buffer_number) printf_buffer+(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS )
[148] (byte) utoa::started#2 ← phi( utoa::@4/(byte) utoa::started#4 utoa/(byte) 0 )
[148] (word) utoa::value#2 ← phi( utoa::@4/(word) utoa::value#6 utoa/(word) utoa::value#1 )
[148] (byte) utoa::digit#2 ← phi( utoa::@4/(byte) utoa::digit#1 utoa/(byte) 0 )
[149] if((byte) utoa::digit#2<(const byte) utoa::max_digits#1-(byte) 1) goto utoa::@2
to:utoa::@3
utoa::@3: scope:[utoa] from utoa::@1
[150] (byte~) utoa::$11 ← (byte)(word) utoa::value#2
[151] *((byte*) utoa::buffer#11) ← *((const byte*) DIGITS + (byte~) utoa::$11)
[152] (byte*) utoa::buffer#3 ← ++ (byte*) utoa::buffer#11
[153] *((byte*) utoa::buffer#3) ← (byte) 0
to:utoa::@return
utoa::@return: scope:[utoa] from utoa::@3
[154] return
to:@return
utoa::@2: scope:[utoa] from utoa::@1
[155] (byte~) utoa::$10 ← (byte) utoa::digit#2 << (byte) 1
[156] (word) utoa::digit_value#0 ← *((const word*) RADIX_DECIMAL_VALUES + (byte~) utoa::$10)
[157] if((byte) 0!=(byte) utoa::started#2) goto utoa::@5
to:utoa::@7
utoa::@7: scope:[utoa] from utoa::@2
[158] if((word) utoa::value#2>=(word) utoa::digit_value#0) goto utoa::@5
to:utoa::@4
utoa::@4: scope:[utoa] from utoa::@6 utoa::@7
[159] (byte*) utoa::buffer#14 ← phi( utoa::@7/(byte*) utoa::buffer#11 utoa::@6/(byte*) utoa::buffer#4 )
[159] (byte) utoa::started#4 ← phi( utoa::@7/(byte) utoa::started#2 utoa::@6/(byte) 1 )
[159] (word) utoa::value#6 ← phi( utoa::@7/(word) utoa::value#2 utoa::@6/(word) utoa::value#0 )
[160] (byte) utoa::digit#1 ← ++ (byte) utoa::digit#2
to:utoa::@1
utoa::@5: scope:[utoa] from utoa::@2 utoa::@7
[161] (byte*) utoa_append::buffer#0 ← (byte*) utoa::buffer#11
[162] (word) utoa_append::value#0 ← (word) utoa::value#2
[163] (word) utoa_append::sub#0 ← (word) utoa::digit_value#0
[164] call utoa_append
[165] (word) utoa_append::return#0 ← (word) utoa_append::value#2
to:utoa::@6
utoa::@6: scope:[utoa] from utoa::@5
[166] (word) utoa::value#0 ← (word) utoa_append::return#0
[167] (byte*) utoa::buffer#4 ← ++ (byte*) utoa::buffer#11
to:utoa::@4
(word()) utoa_append((byte*) utoa_append::buffer , (word) utoa_append::value , (word) utoa_append::sub)
utoa_append: scope:[utoa_append] from utoa::@5
[168] phi()
to:utoa_append::@1
utoa_append::@1: scope:[utoa_append] from utoa_append utoa_append::@2
[169] (byte) utoa_append::digit#2 ← phi( utoa_append/(byte) 0 utoa_append::@2/(byte) utoa_append::digit#1 )
[169] (word) utoa_append::value#2 ← phi( utoa_append/(word) utoa_append::value#0 utoa_append::@2/(word) utoa_append::value#1 )
[170] if((word) utoa_append::value#2>=(word) utoa_append::sub#0) goto utoa_append::@2
to:utoa_append::@3
utoa_append::@3: scope:[utoa_append] from utoa_append::@1
[171] *((byte*) utoa_append::buffer#0) ← *((const byte*) DIGITS + (byte) utoa_append::digit#2)
to:utoa_append::@return
utoa_append::@return: scope:[utoa_append] from utoa_append::@3
[172] return
to:@return
utoa_append::@2: scope:[utoa_append] from utoa_append::@1
[173] (byte) utoa_append::digit#1 ← ++ (byte) utoa_append::digit#2
[174] (word) utoa_append::value#1 ← (word) utoa_append::value#2 - (word) utoa_append::sub#0
to:utoa_append::@1
(void()) gotoxy((byte) gotoxy::x , (byte) gotoxy::y)
gotoxy: scope:[gotoxy] from main::@2
[175] phi()
to:gotoxy::@1
gotoxy::@1: scope:[gotoxy] from gotoxy
[176] (byte) conio_cursor_x ← (const byte) gotoxy::x#2
[177] (byte) conio_cursor_y ← (const byte) gotoxy::y#2
[178] (byte*) conio_cursor_text ← (const nomodify byte*) CONIO_SCREEN_TEXT
[179] (byte*) conio_cursor_color ← (const nomodify byte*) CONIO_SCREEN_COLORS
to:gotoxy::@return
gotoxy::@return: scope:[gotoxy] from gotoxy::@1
[180] return
to:@return

8125
src/test/ref/circlechars.log Normal file
View File

File diff suppressed because it is too large Load Diff

316
src/test/ref/circlechars.sym Normal file
View File

@ -0,0 +1,316 @@
(label) @1
(label) @2
(label) @begin
(label) @end
(const nomodify byte*) CONIO_SCREEN_COLORS = (byte*) 55296
(const nomodify byte*) CONIO_SCREEN_TEXT = (byte*) 1024
(const nomodify byte) CONIO_TEXTCOLOR_DEFAULT = (byte) $e
(const byte*) DIGITS[] = (byte*) "0123456789abcdef"z
(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS = (byte) 1
(const byte) RADIX::BINARY = (number) 2
(const byte) RADIX::DECIMAL = (number) $a
(const byte) RADIX::HEXADECIMAL = (number) $10
(const byte) RADIX::OCTAL = (number) 8
(const word*) RADIX_DECIMAL_VALUES[] = { (word) $2710, (word) $3e8, (word) $64, (word) $a }
(const nomodify byte*) SCREEN = (byte*) 1024
(const byte) SIZEOF_STRUCT_PRINTF_BUFFER_NUMBER = (byte) $c
(byte*) conio_cursor_color loadstore zp[2]:15 3484376.71875
(byte*) conio_cursor_text loadstore zp[2]:13 3430770.9230769235
(byte) conio_cursor_x loadstore zp[1]:11 489798.1428571429
(byte) conio_cursor_y loadstore zp[1]:12 4735295.735294118
(void()) cputc((byte) cputc::c)
(label) cputc::@1
(label) cputc::@2
(label) cputc::@3
(label) cputc::@return
(byte) cputc::c
(byte) cputc::c#0 reg byte a 200002.0
(byte) cputc::c#2 reg byte a 2002.0
(byte) cputc::c#3 reg byte a 1050502.0
(void()) cputln()
(byte*~) cputln::$1 zp[2]:13 2.0000002E7
(byte*~) cputln::$2 zp[2]:15 2.0000002E7
(label) cputln::@return
(word) cputln::ln_offset
(word) cputln::ln_offset#0 ln_offset zp[2]:22 1.0000001E7
(void()) cputs((to_nomodify byte*) cputs::s)
(label) cputs::@1
(label) cputs::@2
(label) cputs::@return
(byte) cputs::c
(byte) cputs::c#1 reg byte a 100001.0
(to_nomodify byte*) cputs::s
(to_nomodify byte*) cputs::s#0 s zp[2]:8 50000.5
(to_nomodify byte*) cputs::s#3 s zp[2]:8 155002.0
(to_nomodify byte*) cputs::s#4 s zp[2]:8 10001.0
(void()) cscroll()
(byte*~) cscroll::$7 zp[2]:13 2.00000002E8
(byte*~) cscroll::$8 zp[2]:15 2.00000002E8
(label) cscroll::@1
(label) cscroll::@2
(label) cscroll::@3
(label) cscroll::@4
(label) cscroll::@5
(label) cscroll::@return
(void()) gotoxy((byte) gotoxy::x , (byte) gotoxy::y)
(label) gotoxy::@1
(label) gotoxy::@return
(word) gotoxy::offset
(byte) gotoxy::x
(const byte) gotoxy::x#2 x = (byte) 0
(byte) gotoxy::y
(const byte) gotoxy::y#2 y = (byte) 0
(void()) main()
(signed word~) main::$10 zp[2]:6 2002.0
(signed byte~) main::$5 reg byte a 2002.0
(signed byte~) main::$7 reg byte a 2002.0
(signed word~) main::$9 zp[2]:18 400.4
(label) main::@1
(label) main::@10
(label) main::@11
(label) main::@2
(label) main::@3
(label) main::@4
(label) main::@5
(label) main::@6
(label) main::@7
(label) main::@8
(label) main::@9
(label) main::@return
(word) main::count
(word) main::count#1 count zp[2]:2 2002.0
(word) main::count#10 count zp[2]:2 178.05555555555557
(word) main::count#11 count zp[2]:2 53.25
(word) main::count#12 count zp[2]:2 1001.0
(signed word) main::dist_sq
(signed word) main::dist_sq#0 dist_sq zp[2]:18 2002.0
(const byte*) main::s[(byte) 7] = (byte*) " chars"
(byte*) main::sc
(byte*) main::sc#1 sc zp[2]:4 1001.0
(byte*) main::sc#10 sc zp[2]:4 160.25
(byte*) main::sc#8 sc zp[2]:4 101.0
(byte) main::x
(byte) main::x#1 x zp[1]:12 2002.0
(byte) main::x#2 x zp[1]:12 150.14999999999998
(signed byte) main::xd
(signed byte) main::xd#0 reg byte x 750.75
(byte) main::y
(byte) main::y#1 y zp[1]:11 202.0
(byte) main::y#2 y zp[1]:11 13.173913043478262
(signed byte) main::yd
(signed byte) main::yd#0 yd zp[1]:17 500.5
(void*()) memcpy((void*) memcpy::destination , (void*) memcpy::source , (word) memcpy::num)
(label) memcpy::@1
(label) memcpy::@2
(label) memcpy::@return
(void*) memcpy::destination
(void*) memcpy::destination#2 destination zp[2]:22
(byte*) memcpy::dst
(byte*) memcpy::dst#1 dst zp[2]:22 1.00000000001E11
(byte*) memcpy::dst#2 dst zp[2]:22 1.0033333333466667E11
(byte*) memcpy::dst#4 dst zp[2]:22 2.000000002E9
(word) memcpy::num
(void*) memcpy::return
(void*) memcpy::source
(void*) memcpy::source#2 source zp[2]:18
(byte*) memcpy::src
(byte*) memcpy::src#1 src zp[2]:18 2.00000000002E11
(byte*) memcpy::src#2 src zp[2]:18 1.0025000000125E11
(byte*) memcpy::src#4 src zp[2]:18 1.000000001E9
(byte*) memcpy::src_end
(byte*) memcpy::src_end#0 src_end zp[2]:20 1.262500000025E10
(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
(label) memset::@1
(label) memset::@2
(label) memset::@3
(label) memset::@return
(byte) memset::c
(byte) memset::c#5 reg byte x 1.250000000125E9
(byte*) memset::dst
(byte*) memset::dst#1 dst zp[2]:22 2.0000000002E10
(byte*) memset::dst#2 dst zp[2]:22 1.3666666668333332E10
(byte*) memset::dst#4 dst zp[2]:22 2.000000002E9
(byte*) memset::end
(byte*) memset::end#0 end zp[2]:18 1.8333333336666665E9
(word) memset::num
(word) memset::num#3 num zp[2]:18 1.000000001E9
(void*) memset::return
(void*) memset::str
(void*) memset::str#4 str zp[2]:22
(signed word()) mul8s((signed byte) mul8s::a , (signed byte) mul8s::b)
(byte~) mul8s::$11 reg byte a 20002.0
(byte~) mul8s::$12 reg byte a 20002.0
(byte~) mul8s::$6 reg byte a 20002.0
(byte~) mul8s::$9 reg byte a 20002.0
(label) mul8s::@1
(label) mul8s::@2
(label) mul8s::@3
(label) mul8s::@4
(label) mul8s::@5
(label) mul8s::@return
(signed byte) mul8s::a
(signed byte) mul8s::a#0 a zp[1]:10 1001.0
(signed byte) mul8s::a#1 a zp[1]:10 1001.0
(signed byte) mul8s::a#2 a zp[1]:10 923.3076923076923
(signed byte) mul8s::b
(signed byte) mul8s::b#0 reg byte y 2002.0
(signed byte) mul8s::b#1 reg byte y 2002.0
(signed byte) mul8s::b#2 reg byte y 1091.181818181818
(word) mul8s::m
(word) mul8s::m#0 m zp[2]:6 10001.0
(word) mul8s::m#1 m zp[2]:6 20002.0
(word) mul8s::m#2 m zp[2]:6 20002.0
(word) mul8s::m#4 m zp[2]:6 5000.5
(word) mul8s::m#5 m zp[2]:6 12501.25
(signed word) mul8s::return
(word()) mul8u((byte) mul8u::a , (byte) mul8u::b)
(byte~) mul8u::$1 reg byte a 2.00000002E8
(label) mul8u::@1
(label) mul8u::@2
(label) mul8u::@3
(label) mul8u::@4
(label) mul8u::@return
(byte) mul8u::a
(byte) mul8u::a#0 reg byte x 1.00000001E8
(byte) mul8u::a#1 reg byte x 36667.33333333333
(byte) mul8u::a#2 reg byte x 6.668333416666667E7
(byte) mul8u::b
(byte) mul8u::b#0 reg byte a 10001.0
(word) mul8u::mb
(word) mul8u::mb#0 mb zp[2]:8 200002.0
(word) mul8u::mb#1 mb zp[2]:8 2.00000002E8
(word) mul8u::mb#2 mb zp[2]:8 4.287142914285715E7
(word) mul8u::res
(word) mul8u::res#1 res zp[2]:6 2.00000002E8
(word) mul8u::res#2 res zp[2]:6 5.0001667333333336E7
(word) mul8u::res#6 res zp[2]:6 1.00000001E8
(word) mul8u::return
(word) mul8u::return#2 return zp[2]:6 20002.0
(struct printf_buffer_number) printf_buffer loadstore mem[12] = {}
(const byte*) printf_buffer_number::digits[(number) $b] = { fill( $b, 0) }
(byte) printf_buffer_number::sign
(byte) printf_format_number::justify_left
(byte) printf_format_number::min_length
(byte) printf_format_number::radix
(byte) printf_format_number::sign_always
(byte) printf_format_number::upper_case
(byte) printf_format_number::zero_padding
(byte) printf_format_string::justify_left
(byte) printf_format_string::min_length
(void()) printf_number_buffer((byte) printf_number_buffer::buffer_sign , (byte*) printf_number_buffer::buffer_digits , (byte) printf_number_buffer::format_min_length , (byte) printf_number_buffer::format_justify_left , (byte) printf_number_buffer::format_sign_always , (byte) printf_number_buffer::format_zero_padding , (byte) printf_number_buffer::format_upper_case , (byte) printf_number_buffer::format_radix)
(label) printf_number_buffer::@1
(label) printf_number_buffer::@2
(label) printf_number_buffer::@3
(label) printf_number_buffer::@return
(struct printf_buffer_number) printf_number_buffer::buffer
(byte*) printf_number_buffer::buffer_digits
(const byte*) printf_number_buffer::buffer_digits#0 buffer_digits = (byte*)&(struct printf_buffer_number) printf_buffer+(const byte) OFFSET_STRUCT_PRINTF_BUFFER_NUMBER_DIGITS
(byte) printf_number_buffer::buffer_sign
(byte) printf_number_buffer::buffer_sign#0 reg byte a 701.0
(struct printf_format_number) printf_number_buffer::format
(byte) printf_number_buffer::format_justify_left
(byte) printf_number_buffer::format_min_length
(byte) printf_number_buffer::format_radix
(byte) printf_number_buffer::format_sign_always
(byte) printf_number_buffer::format_upper_case
(byte) printf_number_buffer::format_zero_padding
(signed byte) printf_number_buffer::len
(signed byte) printf_number_buffer::padding
(void()) printf_uint((word) printf_uint::uvalue , (byte) printf_uint::format_min_length , (byte) printf_uint::format_justify_left , (byte) printf_uint::format_sign_always , (byte) printf_uint::format_zero_padding , (byte) printf_uint::format_upper_case , (byte) printf_uint::format_radix)
(label) printf_uint::@1
(label) printf_uint::@2
(label) printf_uint::@return
(struct printf_format_number) printf_uint::format
(byte) printf_uint::format_justify_left
(byte) printf_uint::format_min_length
(byte) printf_uint::format_radix
(byte) printf_uint::format_sign_always
(byte) printf_uint::format_upper_case
(byte) printf_uint::format_zero_padding
(word) printf_uint::uvalue
(word) printf_uint::uvalue#0 uvalue zp[2]:2 37.33333333333333
(void()) utoa((word) utoa::value , (byte*) utoa::buffer , (byte) utoa::radix)
(byte~) utoa::$10 reg byte a 20002.0
(byte~) utoa::$11 reg byte a 2002.0
(label) utoa::@1
(label) utoa::@2
(label) utoa::@3
(label) utoa::@4
(label) utoa::@5
(label) utoa::@6
(label) utoa::@7
(label) utoa::@return
(byte*) utoa::buffer
(byte*) utoa::buffer#11 buffer zp[2]:18 3000.4285714285716
(byte*) utoa::buffer#14 buffer zp[2]:18 15001.5
(byte*) utoa::buffer#3 buffer zp[2]:18 2002.0
(byte*) utoa::buffer#4 buffer zp[2]:18 20002.0
(byte) utoa::digit
(byte) utoa::digit#1 digit zp[1]:10 20002.0
(byte) utoa::digit#2 digit zp[1]:10 2857.4285714285716
(word) utoa::digit_value
(word) utoa::digit_value#0 digit_value zp[2]:22 6000.6
(word*) utoa::digit_values
(byte) utoa::max_digits
(const byte) utoa::max_digits#1 max_digits = (byte) 5
(byte) utoa::radix
(byte) utoa::started
(byte) utoa::started#2 reg byte x 5000.5
(byte) utoa::started#4 reg byte x 10001.0
(word) utoa::value
(word) utoa::value#0 value zp[2]:2 10001.0
(word) utoa::value#1 value zp[2]:2 551.0
(word) utoa::value#2 value zp[2]:2 5857.857142857143
(word) utoa::value#6 value zp[2]:2 15001.5
(word()) utoa_append((byte*) utoa_append::buffer , (word) utoa_append::value , (word) utoa_append::sub)
(label) utoa_append::@1
(label) utoa_append::@2
(label) utoa_append::@3
(label) utoa_append::@return
(byte*) utoa_append::buffer
(byte*) utoa_append::buffer#0 buffer zp[2]:18 13750.25
(byte) utoa_append::digit
(byte) utoa_append::digit#1 reg byte x 1.0000001E7
(byte) utoa_append::digit#2 reg byte x 1.00500015E7
(word) utoa_append::return
(word) utoa_append::return#0 return zp[2]:2 20002.0
(word) utoa_append::sub
(word) utoa_append::sub#0 sub zp[2]:22 3335000.5
(word) utoa_append::value
(word) utoa_append::value#0 value zp[2]:2 36667.33333333333
(word) utoa_append::value#1 value zp[2]:2 2.0000002E7
(word) utoa_append::value#2 value zp[2]:2 5018334.166666666
zp[2]:2 [ main::count#11 main::count#10 main::count#12 main::count#1 printf_uint::uvalue#0 utoa::value#2 utoa::value#6 utoa::value#1 utoa::value#0 utoa_append::value#2 utoa_append::value#0 utoa_append::value#1 utoa_append::return#0 ]
zp[2]:4 [ main::sc#8 main::sc#10 main::sc#1 ]
reg byte y [ mul8s::b#2 mul8s::b#1 mul8s::b#0 ]
zp[2]:6 [ mul8s::m#4 mul8s::m#5 mul8s::m#1 mul8s::m#0 mul8s::m#2 main::$10 mul8u::return#2 mul8u::res#2 mul8u::res#6 mul8u::res#1 ]
reg byte x [ mul8u::a#2 mul8u::a#1 mul8u::a#0 ]
zp[2]:8 [ cputs::s#3 cputs::s#4 cputs::s#0 mul8u::mb#2 mul8u::mb#0 mul8u::mb#1 ]
reg byte a [ cputc::c#3 cputc::c#0 cputc::c#2 ]
reg byte x [ memset::c#5 ]
zp[1]:10 [ utoa::digit#2 utoa::digit#1 mul8s::a#2 mul8s::a#1 mul8s::a#0 ]
reg byte x [ utoa::started#2 utoa::started#4 ]
reg byte x [ utoa_append::digit#2 utoa_append::digit#1 ]
zp[1]:11 [ conio_cursor_x main::y#2 main::y#1 ]
zp[1]:12 [ conio_cursor_y main::x#2 main::x#1 ]
zp[2]:13 [ conio_cursor_text cputln::$1 cscroll::$7 ]
zp[2]:15 [ conio_cursor_color cputln::$2 cscroll::$8 ]
reg byte a [ main::$5 ]
reg byte x [ main::xd#0 ]
reg byte a [ main::$7 ]
zp[1]:17 [ main::yd#0 ]
zp[2]:18 [ main::$9 main::dist_sq#0 utoa::buffer#11 utoa::buffer#14 utoa::buffer#4 utoa::buffer#3 utoa_append::buffer#0 memcpy::source#2 memcpy::src#2 memcpy::src#4 memcpy::src#1 memset::num#3 memset::end#0 ]
reg byte a [ mul8u::b#0 ]
reg byte a [ mul8s::$6 ]
reg byte a [ mul8s::$11 ]
reg byte a [ mul8s::$9 ]
reg byte a [ mul8s::$12 ]
reg byte a [ mul8u::$1 ]
reg byte a [ cputs::c#1 ]
zp[2]:20 [ memcpy::src_end#0 ]
reg byte a [ printf_number_buffer::buffer_sign#0 ]
reg byte a [ utoa::$11 ]
reg byte a [ utoa::$10 ]
zp[2]:22 [ utoa::digit_value#0 utoa_append::sub#0 cputln::ln_offset#0 memcpy::destination#2 memcpy::dst#2 memcpy::dst#4 memcpy::dst#1 memset::str#4 memset::dst#2 memset::dst#4 memset::dst#1 ]
mem[12] [ printf_buffer ]