Sol-1 has its own C compiler. The compiler at the moment only supports integer types, but has support for most features
of the C language such as pointers of any indirection level, enums, structs, and so on.
It will generate pure Sol-1 assembly. The assembly is then assembled with Sol-1's assembler, or with TASM.
Based on simple statistics and in general, this compiler generates around 10 lines of assembly for each line of C,
and about 8 bytes per line of C.
The C compiler's source code is available here.
Compilation example
Let's look at the following C program given below. Note I decreased the size of the initialized array so it would fit
nicely within the page's boundaries. The real array can be found in sol-1/ccompiler/programs/life.c in the git repository.
The program below is Conway's game of life in C. We will compile it with Sol-1's c compiler.
#include "lib/stdio.h
#define WIDTH 40
#define HEIGHT 30
char clear[] = {27, '[', '2', 'J', 27, '[', 'H', 0};
// Global arrays to hold the current and next states of the game grid
char nextState[HEIGHT][WIDTH];
char currState[HEIGHT][WIDTH] = {
',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','@',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','@',' ','@',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
',' ',' ',' ',' ',' ',' ','@','@',' ',' ',' ',' ',' ',' ','@','@',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','@','@',' ',
',' ',' ',' ',' ',' ','@',' ',' ',' ','@',' ',' ',' ',' ','@','@',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','@','@',' ',
','@','@',' ',' ','@',' ',' ',' ',' ',' ','@',' ',' ',' ','@','@',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
','@','@',' ',' ','@',' ',' ',' ','@',' ','@','@',' ',' ',' ',' ','@',' ','@',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
',' ',' ',' ',' ','@',' ',' ',' ',' ',' ','@',' ',' ',' ',' ',' ',' ',' ','@',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
',' ',' ',' ',' ',' ','@',' ',' ',' ','@',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
',' ',' ',' ',' ',' ',' ','@','@',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '
};
void show(void){
int i, j;
for(i = 0; i < HEIGHT; i++){
for(j = 0; j < WIDTH; j++){
currState[i][j] == '@' ? printf("@ ") : printf(". ");
}
putchar(10);
}
}
int alive(int i, int j){
if(currState[i][j] == '@') return 1;
else return 0;
}
int neighbours(int i, int j){
int count;
count = 0;
if(currState[i+-1][j] == '@') count++;
if(currState[i+-1][j+-1] == '@') count++;
if(currState[i+-1][j+1] == '@') count++;
if(currState[i][j+-1] == '@') count++;
if(currState[i][j+1] == '@') count++;
if(currState[i+1][j+-1] == '@') count++;
if(currState[i+1][j] == '@') count++;
if(currState[i+1][j+1] == '@') count++;
return count;
}
int main(void){
int i, j;
int n;
for(i = 0; i < HEIGHT; i++){
for(j = 0; j < WIDTH; j++){
nextState[i][j] = currState[i][j];
}
}
for(;;){
for(i = 1; i < HEIGHT+-1; i++){
for(j = 1; j < WIDTH+-1; j++){
n = neighbours(i, j);
if(n < 2 || n > 3) nextState[i][j] = ' ';
else if(n == 3) nextState[i][j] = '@';
}
}
for(i = 1; i < HEIGHT+-1; i++){
for(j = 1; j < WIDTH+-1; j++){
currState[i][j] = nextState[i][j];
}
}
printf(clear);
show();
}
}
CD into ccompiler/, then compile with:
$ ./build programs/life.c
The assembled output is given below. Note that this output also contains the entirety of the stdio.h library.
In Sol-1's C compiler, at present, when a library is included, then all of the C code in that library is
compiled. This behaviour will change in the near future. But this is the reason the output is large.
Anyhow, this should give you a good idea of the C compiler for Sol-1.
; --- FILENAME: programs/life
.include "lib/kernel.exp"
.include "lib/bios.exp"
.org text_org
; --- BEGIN TEXT BLOCK
main:
mov bp, $FFE0 ;
mov sp, $FFE0 ; Make space for argc(2 bytes) and for 10 pointers in argv (local variables)
; $i
; $j
; $n
sub sp, 6
;; for(i = 0; i < 30 ; i++){
_for1_init:
lea d, [bp + -1] ; $i
mov b, $0
mov [d], b
_for1_cond:
mov b, [bp + -1] ; $i
; START RELATIONAL
push a
mov a, b
mov b, $1e
cmp a, b
slt ; <
pop a
; END RELATIONAL
cmp b, 0
je _for1_exit
_for1_block:
;; for(j = 0; j < 40 ; j++){
_for2_init:
lea d, [bp + -3] ; $j
mov b, $0
mov [d], b
_for2_cond:
mov b, [bp + -3] ; $j
; START RELATIONAL
push a
mov a, b
mov b, $28
cmp a, b
slt ; <
pop a
; END RELATIONAL
cmp b, 0
je _for2_exit
_for2_block:
;; nextState[i][j] = currState[i][j];
mov d, _nextState_data ; $nextState
push a
mov b, [bp + -1] ; $i
mma 40 ; mov a, 40; mul a, b; add d, b
mov b, [bp + -3] ; $j
add d, b
pop a
push d
mov d, _currState_data ; $currState
push a
mov b, [bp + -1] ; $i
mma 40 ; mov a, 40; mul a, b; add d, b
mov b, [bp + -3] ; $j
add d, b
pop a
mov bl, [d]
mov bh, 0
pop d
mov [d], bl
_for2_update:
mov b, [bp + -3] ; $j
mov g, b
inc b
lea d, [bp + -3] ; $j
mov [d], b
mov b, g
jmp _for2_cond
_for2_exit:
_for1_update:
mov b, [bp + -1] ; $i
mov g, b
inc b
lea d, [bp + -1] ; $i
mov [d], b
mov b, g
jmp _for1_cond
_for1_exit:
;; for(;;){
_for3_init:
_for3_cond:
_for3_block:
;; for(i = 1; i < 30 +-1; i++){
_for4_init:
lea d, [bp + -1] ; $i
mov b, $1
mov [d], b
_for4_cond:
mov b, [bp + -1] ; $i
; START RELATIONAL
push a
mov a, b
mov b, $1e
; START TERMS
push a
mov a, b
mov b, $1
neg b
add a, b
mov b, a
pop a
; END TERMS
cmp a, b
slt ; <
pop a
; END RELATIONAL
cmp b, 0
je _for4_exit
_for4_block:
;; for(j = 1; j < 40 +-1; j++){
_for5_init:
lea d, [bp + -3] ; $j
mov b, $1
mov [d], b
_for5_cond:
mov b, [bp + -3] ; $j
; START RELATIONAL
push a
mov a, b
mov b, $28
; START TERMS
push a
mov a, b
mov b, $1
neg b
add a, b
mov b, a
pop a
; END TERMS
cmp a, b
slt ; <
pop a
; END RELATIONAL
cmp b, 0
je _for5_exit
_for5_block:
;; n = neighbours(i, j);
lea d, [bp + -5] ; $n
push d
mov b, [bp + -1] ; $i
swp b
push b
mov b, [bp + -3] ; $j
swp b
push b
call neighbours
add sp, 4
pop d
mov [d], b
;; if(n < 2 || n > 3) nextState[i][j] = ' ';
_if6_cond:
mov b, [bp + -5] ; $n
; START RELATIONAL
push a
mov a, b
mov b, $2
cmp a, b
slt ; <
pop a
; END RELATIONAL
push a
mov a, b
mov b, [bp + -5] ; $n
; START RELATIONAL
push a
mov a, b
mov b, $3
cmp a, b
sgt ; >
pop a
; END RELATIONAL
sor a, b ; ||
pop a
cmp b, 0
je _if6_else
_if6_true:
;; nextState[i][j] = ' ';
mov d, _nextState_data ; $nextState
push a
mov b, [bp + -1] ; $i
mma 40 ; mov a, 40; mul a, b; add d, b
mov b, [bp + -3] ; $j
add d, b
pop a
mov b, $20
mov [d], bl
jmp _if6_exit
_if6_else:
;; if(n == 3) nextState[i][j] = '@';
_if7_cond:
mov b, [bp + -5] ; $n
; START RELATIONAL
push a
mov a, b
mov b, $3
cmp a, b
seq ; ==
pop a
; END RELATIONAL
cmp b, 0
je _if7_exit
_if7_true:
;; nextState[i][j] = '@';
mov d, _nextState_data ; $nextState
push a
mov b, [bp + -1] ; $i
mma 40 ; mov a, 40; mul a, b; add d, b
mov b, [bp + -3] ; $j
add d, b
pop a
mov b, $40
mov [d], bl
jmp _if7_exit
_if7_exit:
_if6_exit:
_for5_update:
mov b, [bp + -3] ; $j
mov g, b
inc b
lea d, [bp + -3] ; $j
mov [d], b
mov b, g
jmp _for5_cond
_for5_exit:
_for4_update:
mov b, [bp + -1] ; $i
mov g, b
inc b
lea d, [bp + -1] ; $i
mov [d], b
mov b, g
jmp _for4_cond
_for4_exit:
;; for(i = 1; i < 30 +-1; i++){
_for8_init:
lea d, [bp + -1] ; $i
mov b, $1
mov [d], b
_for8_cond:
mov b, [bp + -1] ; $i
; START RELATIONAL
push a
mov a, b
mov b, $1e
; START TERMS
push a
mov a, b
mov b, $1
neg b
add a, b
mov b, a
pop a
; END TERMS
cmp a, b
slt ; <
pop a
; END RELATIONAL
cmp b, 0
je _for8_exit
_for8_block:
;; for(j = 1; j < 40 +-1; j++){
_for9_init:
lea d, [bp + -3] ; $j
mov b, $1
mov [d], b
_for9_cond:
mov b, [bp + -3] ; $j
; START RELATIONAL
push a
mov a, b
mov b, $28
; START TERMS
push a
mov a, b
mov b, $1
neg b
add a, b
mov b, a
pop a
; END TERMS
cmp a, b
slt ; <
pop a
; END RELATIONAL
cmp b, 0
je _for9_exit
_for9_block:
;; currState[i][j] = nextState[i][j];
mov d, _currState_data ; $currState
push a
mov b, [bp + -1] ; $i
mma 40 ; mov a, 40; mul a, b; add d, b
mov b, [bp + -3] ; $j
add d, b
pop a
push d
mov d, _nextState_data ; $nextState
push a
mov b, [bp + -1] ; $i
mma 40 ; mov a, 40; mul a, b; add d, b
mov b, [bp + -3] ; $j
add d, b
pop a
mov bl, [d]
mov bh, 0
pop d
mov [d], bl
_for9_update:
mov b, [bp + -3] ; $j
mov g, b
inc b
lea d, [bp + -3] ; $j
mov [d], b
mov b, g
jmp _for9_cond
_for9_exit:
_for8_update:
mov b, [bp + -1] ; $i
mov g, b
inc b
lea d, [bp + -1] ; $i
mov [d], b
mov b, g
jmp _for8_cond
_for8_exit:
;; printf(clear);
mov b, _clear_data ; $clear
swp b
push b
call printf
add sp, 2
;; show();
call show
_for3_update:
jmp _for3_cond
_for3_exit:
syscall sys_terminate_proc
strcpy:
enter 0 ; (push bp; mov bp, sp)
; $psrc
; $pdest
sub sp, 4
;; psrc = src;
lea d, [bp + -1] ; $psrc
mov b, [bp + 5] ; $src
mov [d], b
;; pdest = dest;
lea d, [bp + -3] ; $pdest
mov b, [bp + 7] ; $dest
mov [d], b
;; while(*psrc) *pdest++ = *psrc++;
_while10_cond:
mov b, [bp + -1] ; $psrc
mov d, b
mov bl, [d]
mov bh, 0
cmp b, 0
je _while10_exit
_while10_block:
;; *pdest++ = *psrc++;
mov b, [bp + -3] ; $pdest
mov g, b
inc b
lea d, [bp + -3] ; $pdest
mov [d], b
mov b, g
push b
mov b, [bp + -1] ; $psrc
mov g, b
inc b
lea d, [bp + -1] ; $psrc
mov [d], b
mov b, g
mov d, b
mov bl, [d]
mov bh, 0
pop d
mov [d], bl
jmp _while10_cond
_while10_exit:
;; *pdest = '\0';
mov b, [bp + -3] ; $pdest
push b
mov b, $0
pop d
mov [d], bl
leave
ret
strcmp:
enter 0 ; (push bp; mov bp, sp)
;; while (*s1 && (*s1 == *s2)) {
_while11_cond:
mov b, [bp + 7] ; $s1
mov d, b
mov bl, [d]
mov bh, 0
push a
mov a, b
mov b, [bp + 7] ; $s1
mov d, b
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, [bp + 5] ; $s2
mov d, b
mov bl, [d]
mov bh, 0
cmp a, b
seq ; ==
pop a
; END RELATIONAL
sand a, b ; &&
pop a
cmp b, 0
je _while11_exit
_while11_block:
;; s1++;
mov b, [bp + 7] ; $s1
mov g, b
inc b
lea d, [bp + 7] ; $s1
mov [d], b
mov b, g
;; s2++;
mov b, [bp + 5] ; $s2
mov g, b
inc b
lea d, [bp + 5] ; $s2
mov [d], b
mov b, g
jmp _while11_cond
_while11_exit:
;; return *s1 - *s2;
mov b, [bp + 7] ; $s1
mov d, b
mov bl, [d]
mov bh, 0
; START TERMS
push a
mov a, b
mov b, [bp + 5] ; $s2
mov d, b
mov bl, [d]
mov bh, 0
sub a, b
mov b, a
pop a
; END TERMS
leave
ret
strcat:
enter 0 ; (push bp; mov bp, sp)
; $dest_len
; $i
sub sp, 4
;; dest_len = strlen(dest);
lea d, [bp + -1] ; $dest_len
push d
mov b, [bp + 7] ; $dest
swp b
push b
call strlen
add sp, 2
pop d
mov [d], b
;; for (i = 0; src[i] != 0; i=i+1) {
_for12_init:
lea d, [bp + -3] ; $i
mov b, $0
mov [d], b
_for12_cond:
lea d, [bp + 5] ; $src
mov d, [d]
push a
mov b, [bp + -3] ; $i
mma 1 ; mov a, 1; mul a b; add d, b
pop a
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $0
cmp a, b
sneq ; !=
pop a
; END RELATIONAL
cmp b, 0
je _for12_exit
_for12_block:
;; dest[dest_len + i] = src[i];
lea d, [bp + 7] ; $dest
mov d, [d]
push a
mov b, [bp + -1] ; $dest_len
; START TERMS
push a
mov a, b
mov b, [bp + -3] ; $i
add a, b
mov b, a
pop a
; END TERMS
mma 1 ; mov a, 1; mul a b; add d, b
pop a
push d
lea d, [bp + 5] ; $src
mov d, [d]
push a
mov b, [bp + -3] ; $i
mma 1 ; mov a, 1; mul a b; add d, b
pop a
mov bl, [d]
mov bh, 0
pop d
mov [d], bl
_for12_update:
lea d, [bp + -3] ; $i
mov b, [bp + -3] ; $i
; START TERMS
push a
mov a, b
mov b, $1
add a, b
mov b, a
pop a
; END TERMS
mov [d], b
jmp _for12_cond
_for12_exit:
;; dest[dest_len + i] = 0;
lea d, [bp + 7] ; $dest
mov d, [d]
push a
mov b, [bp + -1] ; $dest_len
; START TERMS
push a
mov a, b
mov b, [bp + -3] ; $i
add a, b
mov b, a
pop a
; END TERMS
mma 1 ; mov a, 1; mul a b; add d, b
pop a
mov b, $0
mov [d], bl
;; return dest;
mov b, [bp + 7] ; $dest
leave
ret
strlen:
enter 0 ; (push bp; mov bp, sp)
; $length
sub sp, 2
;; length = 0;
lea d, [bp + -1] ; $length
mov b, $0
mov [d], b
;; while (str[length] != 0) {
_while13_cond:
lea d, [bp + 5] ; $str
mov d, [d]
push a
mov b, [bp + -1] ; $length
mma 1 ; mov a, 1; mul a b; add d, b
pop a
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $0
cmp a, b
sneq ; !=
pop a
; END RELATIONAL
cmp b, 0
je _while13_exit
_while13_block:
;; length++;
mov b, [bp + -1] ; $length
mov g, b
inc b
lea d, [bp + -1] ; $length
mov [d], b
mov b, g
jmp _while13_cond
_while13_exit:
;; return length;
mov b, [bp + -1] ; $length
leave
ret
va_arg:
enter 0 ; (push bp; mov bp, sp)
; $val
sub sp, 2
;; if(size == 1){
_if14_cond:
mov b, [bp + 5] ; $size
; START RELATIONAL
push a
mov a, b
mov b, $1
cmp a, b
seq ; ==
pop a
; END RELATIONAL
cmp b, 0
je _if14_else
_if14_true:
;; val = *(char*)arg->p;
lea d, [bp + -1] ; $val
push d
lea d, [bp + 7] ; $arg
mov d, [d]
add d, 0
clb
mov b, [d]
mov d, b
mov bl, [d]
mov bh, 0
pop d
mov [d], b
jmp _if14_exit
_if14_else:
;; if(size == 2){
_if15_cond:
mov b, [bp + 5] ; $size
; START RELATIONAL
push a
mov a, b
mov b, $2
cmp a, b
seq ; ==
pop a
; END RELATIONAL
cmp b, 0
je _if15_else
_if15_true:
;; val = *(int*)arg->p;
lea d, [bp + -1] ; $val
push d
lea d, [bp + 7] ; $arg
mov d, [d]
add d, 0
clb
mov b, [d]
mov d, b
mov b, [d]
pop d
mov [d], b
jmp _if15_exit
_if15_else:
;; print("Unknown type size in va_arg() call. Size needs to be either 1 or 2.");
mov b, __s0 ; "Unknown type size in va_arg() call. Size needs to be either 1 or 2."
swp b
push b
call print
add sp, 2
_if15_exit:
_if14_exit:
;; arg->p = arg->p + size;
lea d, [bp + 7] ; $arg
mov d, [d]
add d, 0
clb
push d
lea d, [bp + 7] ; $arg
mov d, [d]
add d, 0
clb
mov b, [d]
; START TERMS
push a
mov a, b
mov b, [bp + 5] ; $size
add a, b
mov b, a
pop a
; END TERMS
pop d
mov [d], b
;; return val;
mov b, [bp + -1] ; $val
leave
ret
printf:
enter 0 ; (push bp; mov bp, sp)
; $p
; $fp
; $i
sub sp, 6
;; fp = format;
lea d, [bp + -3] ; $fp
mov b, [bp + 5] ; $format
mov [d], b
;; p = &format;
lea d, [bp + -1] ; $p
push d
lea d, [bp + 5] ; $format
mov b, d
pop d
mov [d], b
;; for(;;){
_for16_init:
_for16_cond:
_for16_block:
;; if(!*fp) break;
_if17_cond:
mov b, [bp + -3] ; $fp
mov d, b
mov bl, [d]
mov bh, 0
cmp b, 0
seq ; !
cmp b, 0
je _if17_exit
_if17_true:
;; break;
jmp _for16_exit ; for break
jmp _if17_exit
_if17_exit:
;; if(*fp == '%'){
_if18_cond:
mov b, [bp + -3] ; $fp
mov d, b
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $25
cmp a, b
seq ; ==
pop a
; END RELATIONAL
cmp b, 0
je _if18_else
_if18_true:
;; fp++;
mov b, [bp + -3] ; $fp
mov g, b
inc b
lea d, [bp + -3] ; $fp
mov [d], b
mov b, g
;; switch(*fp){
_switch19_expr:
mov b, [bp + -3] ; $fp
mov d, b
mov bl, [d]
mov bh, 0
_switch19_comparisons:
cmp bl, $64
je _switch19_case0
cmp bl, $69
je _switch19_case1
cmp bl, $75
je _switch19_case2
cmp bl, $78
je _switch19_case3
cmp bl, $63
je _switch19_case4
cmp bl, $73
je _switch19_case5
jmp _switch19_default
jmp _switch19_exit
_switch19_case0:
_switch19_case1:
;; p = p - 2;
lea d, [bp + -1] ; $p
mov b, [bp + -1] ; $p
; START TERMS
push a
mov a, b
mov b, $2
sub a, b
mov b, a
pop a
; END TERMS
mov [d], b
;; prints(*(int*)p);
mov b, [bp + -1] ; $p
mov d, b
mov b, [d]
swp b
push b
call prints
add sp, 2
;; break;
jmp _switch19_exit ; case break
_switch19_case2:
;; p = p - 2;
lea d, [bp + -1] ; $p
mov b, [bp + -1] ; $p
; START TERMS
push a
mov a, b
mov b, $2
sub a, b
mov b, a
pop a
; END TERMS
mov [d], b
;; printu(*(unsigned int*)p);
mov b, [bp + -1] ; $p
mov d, b
mov b, [d]
swp b
push b
call printu
add sp, 2
;; break;
jmp _switch19_exit ; case break
_switch19_case3:
;; p = p - 2;
lea d, [bp + -1] ; $p
mov b, [bp + -1] ; $p
; START TERMS
push a
mov a, b
mov b, $2
sub a, b
mov b, a
pop a
; END TERMS
mov [d], b
;; printx16(*(unsigned int*)p);
mov b, [bp + -1] ; $p
mov d, b
mov b, [d]
swp b
push b
call printx16
add sp, 2
;; break;
jmp _switch19_exit ; case break
_switch19_case4:
;; p = p - 2;
lea d, [bp + -1] ; $p
mov b, [bp + -1] ; $p
; START TERMS
push a
mov a, b
mov b, $2
sub a, b
mov b, a
pop a
; END TERMS
mov [d], b
;; putchar(*(char*)p);
mov b, [bp + -1] ; $p
mov d, b
mov bl, [d]
mov bh, 0
push bl
call putchar
add sp, 1
;; break;
jmp _switch19_exit ; case break
_switch19_case5:
;; p = p - 2;
lea d, [bp + -1] ; $p
mov b, [bp + -1] ; $p
; START TERMS
push a
mov a, b
mov b, $2
sub a, b
mov b, a
pop a
; END TERMS
mov [d], b
;; print(*(char**)p);
mov b, [bp + -1] ; $p
mov d, b
mov b, [d]
swp b
push b
call print
add sp, 2
;; break;
jmp _switch19_exit ; case break
_switch19_default:
;; print("Error: Unknown argument type.\n");
mov b, __s1 ; "Error: Unknown argument type.\n"
swp b
push b
call print
add sp, 2
_switch19_exit:
;; fp++;
mov b, [bp + -3] ; $fp
mov g, b
inc b
lea d, [bp + -3] ; $fp
mov [d], b
mov b, g
jmp _if18_exit
_if18_else:
;; putchar(*fp);
mov b, [bp + -3] ; $fp
mov d, b
mov bl, [d]
mov bh, 0
push bl
call putchar
add sp, 1
;; fp++;
mov b, [bp + -3] ; $fp
mov g, b
inc b
lea d, [bp + -3] ; $fp
mov [d], b
mov b, g
_if18_exit:
_for16_update:
jmp _for16_cond
_for16_exit:
leave
ret
printx16:
enter 0 ; (push bp; mov bp, sp)
; --- BEGIN INLINE ASM BLOCK
mov b, [bp + 5] ; $hex
call print_u16x
; --- END INLINE ASM BLOCK
leave
ret
printx8:
enter 0 ; (push bp; mov bp, sp)
; --- BEGIN INLINE ASM BLOCK
lea d, [bp + 5] ; $hex
mov bl, [d]
call print_u8x
; --- END INLINE ASM BLOCK
leave
ret
hex_to_int:
enter 0 ; (push bp; mov bp, sp)
; $value
mov a, $0
mov [bp + -1], a
; $i
; $hex_char
; $len
sub sp, 7
;; len = strlen(hex_string);
lea d, [bp + -6] ; $len
push d
mov b, [bp + 5] ; $hex_string
swp b
push b
call strlen
add sp, 2
pop d
mov [d], b
;; for (i = 0; i < len; i++) {
_for20_init:
lea d, [bp + -3] ; $i
mov b, $0
mov [d], b
_for20_cond:
mov b, [bp + -3] ; $i
; START RELATIONAL
push a
mov a, b
mov b, [bp + -6] ; $len
cmp a, b
slt ; <
pop a
; END RELATIONAL
cmp b, 0
je _for20_exit
_for20_block:
;; hex_char = hex_string[i];
lea d, [bp + -4] ; $hex_char
push d
lea d, [bp + 5] ; $hex_string
mov d, [d]
push a
mov b, [bp + -3] ; $i
mma 1 ; mov a, 1; mul a b; add d, b
pop a
mov bl, [d]
mov bh, 0
pop d
mov [d], bl
;; if (hex_char >= 'a' && hex_char <= 'f')
_if21_cond:
mov bl, [bp + -4] ; $hex_char
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $61
cmp a, b
sge ; >=
pop a
; END RELATIONAL
push a
mov a, b
mov bl, [bp + -4] ; $hex_char
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $66
cmp a, b
sle ; <=
pop a
; END RELATIONAL
sand a, b ; &&
pop a
cmp b, 0
je _if21_else
_if21_true:
;; value = (value * 16) + (hex_char - 'a' + 10);
lea d, [bp + -1] ; $value
mov b, [bp + -1] ; $value
; START FACTORS
push a
mov a, b
mov b, $10
mul a, b ; *
mov a, b
mov b, a
pop a
; END FACTORS
; START TERMS
push a
mov a, b
mov bl, [bp + -4] ; $hex_char
mov bh, 0
; START TERMS
push a
mov a, b
mov b, $61
sub a, b
mov b, $a
add a, b
mov b, a
pop a
; END TERMS
add a, b
mov b, a
pop a
; END TERMS
mov [d], b
jmp _if21_exit
_if21_else:
;; if (hex_char >= 'A' && hex_char <= 'F')
_if22_cond:
mov bl, [bp + -4] ; $hex_char
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $41
cmp a, b
sge ; >=
pop a
; END RELATIONAL
push a
mov a, b
mov bl, [bp + -4] ; $hex_char
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $46
cmp a, b
sle ; <=
pop a
; END RELATIONAL
sand a, b ; &&
pop a
cmp b, 0
je _if22_else
_if22_true:
;; value = (value * 16) + (hex_char - 'A' + 10);
lea d, [bp + -1] ; $value
mov b, [bp + -1] ; $value
; START FACTORS
push a
mov a, b
mov b, $10
mul a, b ; *
mov a, b
mov b, a
pop a
; END FACTORS
; START TERMS
push a
mov a, b
mov bl, [bp + -4] ; $hex_char
mov bh, 0
; START TERMS
push a
mov a, b
mov b, $41
sub a, b
mov b, $a
add a, b
mov b, a
pop a
; END TERMS
add a, b
mov b, a
pop a
; END TERMS
mov [d], b
jmp _if22_exit
_if22_else:
;; value = (value * 16) + (hex_char - '0');
lea d, [bp + -1] ; $value
mov b, [bp + -1] ; $value
; START FACTORS
push a
mov a, b
mov b, $10
mul a, b ; *
mov a, b
mov b, a
pop a
; END FACTORS
; START TERMS
push a
mov a, b
mov bl, [bp + -4] ; $hex_char
mov bh, 0
; START TERMS
push a
mov a, b
mov b, $30
sub a, b
mov b, a
pop a
; END TERMS
add a, b
mov b, a
pop a
; END TERMS
mov [d], b
_if22_exit:
_if21_exit:
_for20_update:
mov b, [bp + -3] ; $i
mov g, b
inc b
lea d, [bp + -3] ; $i
mov [d], b
mov b, g
jmp _for20_cond
_for20_exit:
;; return value;
mov b, [bp + -1] ; $value
leave
ret
atoi:
enter 0 ; (push bp; mov bp, sp)
; $result
mov a, $0
mov [bp + -1], a
; $sign
mov a, $1
mov [bp + -3], a
sub sp, 4
;; while (*str == ' ') str++;
_while23_cond:
mov b, [bp + 5] ; $str
mov d, b
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $20
cmp a, b
seq ; ==
pop a
; END RELATIONAL
cmp b, 0
je _while23_exit
_while23_block:
;; str++;
mov b, [bp + 5] ; $str
mov g, b
inc b
lea d, [bp + 5] ; $str
mov [d], b
mov b, g
jmp _while23_cond
_while23_exit:
;; if (*str == '-' || *str == '+') {
_if24_cond:
mov b, [bp + 5] ; $str
mov d, b
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $2d
cmp a, b
seq ; ==
pop a
; END RELATIONAL
push a
mov a, b
mov b, [bp + 5] ; $str
mov d, b
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $2b
cmp a, b
seq ; ==
pop a
; END RELATIONAL
sor a, b ; ||
pop a
cmp b, 0
je _if24_exit
_if24_true:
;; if (*str == '-') sign = -1;
_if25_cond:
mov b, [bp + 5] ; $str
mov d, b
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $2d
cmp a, b
seq ; ==
pop a
; END RELATIONAL
cmp b, 0
je _if25_exit
_if25_true:
;; sign = -1;
lea d, [bp + -3] ; $sign
mov b, $1
neg b
mov [d], b
jmp _if25_exit
_if25_exit:
;; str++;
mov b, [bp + 5] ; $str
mov g, b
inc b
lea d, [bp + 5] ; $str
mov [d], b
mov b, g
jmp _if24_exit
_if24_exit:
;; while (*str >= '0' && *str <= '9') {
_while26_cond:
mov b, [bp + 5] ; $str
mov d, b
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $30
cmp a, b
sge ; >=
pop a
; END RELATIONAL
push a
mov a, b
mov b, [bp + 5] ; $str
mov d, b
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $39
cmp a, b
sle ; <=
pop a
; END RELATIONAL
sand a, b ; &&
pop a
cmp b, 0
je _while26_exit
_while26_block:
;; result = result * 10 + (*str - '0');
lea d, [bp + -1] ; $result
push d
mov b, [bp + -1] ; $result
; START FACTORS
push a
mov a, b
mov b, $a
mul a, b ; *
mov a, b
mov b, a
pop a
; END FACTORS
; START TERMS
push a
mov a, b
mov b, [bp + 5] ; $str
mov d, b
mov bl, [d]
mov bh, 0
; START TERMS
push a
mov a, b
mov b, $30
sub a, b
mov b, a
pop a
; END TERMS
add a, b
mov b, a
pop a
; END TERMS
pop d
mov [d], b
;; str++;
mov b, [bp + 5] ; $str
mov g, b
inc b
lea d, [bp + 5] ; $str
mov [d], b
mov b, g
jmp _while26_cond
_while26_exit:
;; return sign * result;
mov b, [bp + -3] ; $sign
; START FACTORS
push a
mov a, b
mov b, [bp + -1] ; $result
mul a, b ; *
mov a, b
mov b, a
pop a
; END FACTORS
leave
ret
gets:
enter 0 ; (push bp; mov bp, sp)
; --- BEGIN INLINE ASM BLOCK
mov a, [bp + 5] ; $s
mov d, a
call _gets
; --- END INLINE ASM BLOCK
;; return strlen(s);
mov b, [bp + 5] ; $s
swp b
push b
call strlen
add sp, 2
leave
ret
prints:
enter 0 ; (push bp; mov bp, sp)
; $digits
; $i
mov a, $0
mov [bp + -6], a
sub sp, 7
;; if (num < 0) {
_if27_cond:
mov b, [bp + 5] ; $num
; START RELATIONAL
push a
mov a, b
mov b, $0
cmp a, b
slt ; <
pop a
; END RELATIONAL
cmp b, 0
je _if27_else
_if27_true:
;; putchar('-');
mov b, $2d
push bl
call putchar
add sp, 1
;; num = -num;
lea d, [bp + 5] ; $num
mov b, [bp + 5] ; $num
neg b
mov [d], b
jmp _if27_exit
_if27_else:
;; if (num == 0) {
_if28_cond:
mov b, [bp + 5] ; $num
; START RELATIONAL
push a
mov a, b
mov b, $0
cmp a, b
seq ; ==
pop a
; END RELATIONAL
cmp b, 0
je _if28_exit
_if28_true:
;; putchar('0');
mov b, $30
push bl
call putchar
add sp, 1
;; return;
leave
ret
jmp _if28_exit
_if28_exit:
_if27_exit:
;; while (num > 0) {
_while29_cond:
mov b, [bp + 5] ; $num
; START RELATIONAL
push a
mov a, b
mov b, $0
cmp a, b
sgt ; >
pop a
; END RELATIONAL
cmp b, 0
je _while29_exit
_while29_block:
;; digits[i] = '0' + (num % 10);
lea d, [bp + -4] ; $digits
push a
mov b, [bp + -6] ; $i
add d, b
pop a
mov b, $30
; START TERMS
push a
mov a, b
mov b, [bp + 5] ; $num
; START FACTORS
push a
mov a, b
mov b, $a
div a, b ;
mov a, b
mov b, a
pop a
; END FACTORS
add a, b
mov b, a
pop a
; END TERMS
mov [d], bl
;; num = num / 10;
lea d, [bp + 5] ; $num
mov b, [bp + 5] ; $num
; START FACTORS
push a
mov a, b
mov b, $a
div a, b
mov b, a
pop a
; END FACTORS
mov [d], b
;; i++;
mov b, [bp + -6] ; $i
mov g, b
inc b
lea d, [bp + -6] ; $i
mov [d], b
mov b, g
jmp _while29_cond
_while29_exit:
;; while (i > 0) {
_while30_cond:
mov b, [bp + -6] ; $i
; START RELATIONAL
push a
mov a, b
mov b, $0
cmp a, b
sgt ; >
pop a
; END RELATIONAL
cmp b, 0
je _while30_exit
_while30_block:
;; i--;
mov b, [bp + -6] ; $i
mov g, b
dec b
lea d, [bp + -6] ; $i
mov [d], b
mov b, g
;; putchar(digits[i]);
lea d, [bp + -4] ; $digits
push a
mov b, [bp + -6] ; $i
add d, b
pop a
mov bl, [d]
mov bh, 0
push bl
call putchar
add sp, 1
jmp _while30_cond
_while30_exit:
leave
ret
printu:
enter 0 ; (push bp; mov bp, sp)
; $digits
; $i
sub sp, 7
;; i = 0;
lea d, [bp + -6] ; $i
mov b, $0
mov [d], b
;; if(num == 0){
_if31_cond:
mov b, [bp + 5] ; $num
; START RELATIONAL
push a
mov a, b
mov b, $0
cmp a, b
seq ; ==
pop a
; END RELATIONAL
cmp b, 0
je _if31_exit
_if31_true:
;; putchar('0');
mov b, $30
push bl
call putchar
add sp, 1
;; return;
leave
ret
jmp _if31_exit
_if31_exit:
;; while (num > 0) {
_while32_cond:
mov b, [bp + 5] ; $num
; START RELATIONAL
push a
mov a, b
mov b, $0
cmp a, b
sgu ; > (unsigned)
pop a
; END RELATIONAL
cmp b, 0
je _while32_exit
_while32_block:
;; digits[i] = '0' + (num % 10);
lea d, [bp + -4] ; $digits
push a
mov b, [bp + -6] ; $i
add d, b
pop a
mov b, $30
; START TERMS
push a
mov a, b
mov b, [bp + 5] ; $num
; START FACTORS
push a
mov a, b
mov b, $a
div a, b ;
mov a, b
mov b, a
pop a
; END FACTORS
add a, b
mov b, a
pop a
; END TERMS
mov [d], bl
;; num = num / 10;
lea d, [bp + 5] ; $num
mov b, [bp + 5] ; $num
; START FACTORS
push a
mov a, b
mov b, $a
div a, b
mov b, a
pop a
; END FACTORS
mov [d], b
;; i++;
mov b, [bp + -6] ; $i
mov g, b
inc b
lea d, [bp + -6] ; $i
mov [d], b
mov b, g
jmp _while32_cond
_while32_exit:
;; while (i > 0) {
_while33_cond:
mov b, [bp + -6] ; $i
; START RELATIONAL
push a
mov a, b
mov b, $0
cmp a, b
sgt ; >
pop a
; END RELATIONAL
cmp b, 0
je _while33_exit
_while33_block:
;; i--;
mov b, [bp + -6] ; $i
mov g, b
dec b
lea d, [bp + -6] ; $i
mov [d], b
mov b, g
;; putchar(digits[i]);
lea d, [bp + -4] ; $digits
push a
mov b, [bp + -6] ; $i
add d, b
pop a
mov bl, [d]
mov bh, 0
push bl
call putchar
add sp, 1
jmp _while33_cond
_while33_exit:
leave
ret
rand:
enter 0 ; (push bp; mov bp, sp)
; $sec
sub sp, 1
; --- BEGIN INLINE ASM BLOCK
mov al, 0
syscall sys_rtc
mov al, ah
mov al, [bp + 0] ; $sec
; --- END INLINE ASM BLOCK
;; return sec;
mov bl, [bp + 0] ; $sec
mov bh, 0
leave
ret
date:
enter 0 ; (push bp; mov bp, sp)
; --- BEGIN INLINE ASM BLOCK
mov al, 0
syscall sys_datetime
; --- END INLINE ASM BLOCK
leave
ret
putchar:
enter 0 ; (push bp; mov bp, sp)
; --- BEGIN INLINE ASM BLOCK
mov al, [bp + 5] ; $c
mov ah, al
call _putchar
; --- END INLINE ASM BLOCK
leave
ret
getchar:
enter 0 ; (push bp; mov bp, sp)
; $c
sub sp, 1
; --- BEGIN INLINE ASM BLOCK
call getch
mov al, ah
lea d, [bp + 0] ; $c
mov [d], al
; --- END INLINE ASM BLOCK
;; return c;
mov bl, [bp + 0] ; $c
mov bh, 0
leave
ret
scann:
enter 0 ; (push bp; mov bp, sp)
; $m
sub sp, 2
; --- BEGIN INLINE ASM BLOCK
call scan_u16d
lea d, [bp + -1] ; $m
mov [d], a
; --- END INLINE ASM BLOCK
;; return m;
mov b, [bp + -1] ; $m
leave
ret
puts:
enter 0 ; (push bp; mov bp, sp)
; --- BEGIN INLINE ASM BLOCK
mov a, [bp + 5] ; $s
mov d, a
call _puts
mov ah, $0A
mov al, 0
syscall sys_io
; --- END INLINE ASM BLOCK
leave
ret
print:
enter 0 ; (push bp; mov bp, sp)
; --- BEGIN INLINE ASM BLOCK
lea d, [bp + 5] ; $s
mov d, [d]
call _puts
; --- END INLINE ASM BLOCK
leave
ret
loadfile:
enter 0 ; (push bp; mov bp, sp)
; --- BEGIN INLINE ASM BLOCK
mov a, [bp + 5] ; $destination
mov di, a
lea d, [bp + 7] ; $filename
mov d, [d]
mov al, 20
syscall sys_filesystem
; --- END INLINE ASM BLOCK
leave
ret
create_file:
enter 0 ; (push bp; mov bp, sp)
leave
ret
delete_file:
enter 0 ; (push bp; mov bp, sp)
; --- BEGIN INLINE ASM BLOCK
lea d, [bp + 5] ; $filename
mov al, 10
syscall sys_filesystem
; --- END INLINE ASM BLOCK
leave
ret
fopen:
enter 0 ; (push bp; mov bp, sp)
leave
ret
fclose:
enter 0 ; (push bp; mov bp, sp)
leave
ret
alloc:
enter 0 ; (push bp; mov bp, sp)
;; heap_top = heap_top + bytes;
mov d, _heap_top ; $heap_top
mov b, [_heap_top] ; $heap_top
; START TERMS
push a
mov a, b
mov b, [bp + 5] ; $bytes
add a, b
mov b, a
pop a
; END TERMS
mov [d], b
;; return heap_top - bytes;
mov b, [_heap_top] ; $heap_top
; START TERMS
push a
mov a, b
mov b, [bp + 5] ; $bytes
sub a, b
mov b, a
pop a
; END TERMS
leave
ret
free:
enter 0 ; (push bp; mov bp, sp)
;; return heap_top = heap_top - bytes;
mov d, _heap_top ; $heap_top
mov b, [_heap_top] ; $heap_top
; START TERMS
push a
mov a, b
mov b, [bp + 5] ; $bytes
sub a, b
mov b, a
pop a
; END TERMS
mov [d], b
leave
ret
exit:
enter 0 ; (push bp; mov bp, sp)
; --- BEGIN INLINE ASM BLOCK
syscall sys_terminate_proc
; --- END INLINE ASM BLOCK
leave
ret
load_hex:
enter 0 ; (push bp; mov bp, sp)
; $temp
sub sp, 2
;; temp = alloc(32768);
lea d, [bp + -1] ; $temp
push d
mov b, $8000
swp b
push b
call alloc
add sp, 2
pop d
mov [d], b
; --- BEGIN INLINE ASM BLOCK
_load_hex:
push a
push b
push d
push si
push di
sub sp, $8000
mov c, 0
mov a, sp
inc a
mov d, a
call _gets
mov si, a
__load_hex_loop:
lodsb
cmp al, 0
jz __load_hex_ret
mov bh, al
lodsb
mov bl, al
call _atoi
stosb
inc c
jmp __load_hex_loop
__load_hex_ret:
add sp, $8000
pop di
pop si
pop d
pop b
pop a
; --- END INLINE ASM BLOCK
leave
ret
getparam:
enter 0 ; (push bp; mov bp, sp)
; $data
sub sp, 1
; --- BEGIN INLINE ASM BLOCK
mov al, 4
lea d, [bp + 5] ; $address
mov d, [d]
syscall sys_system
lea d, [bp + 0] ; $data
mov [d], bl
; --- END INLINE ASM BLOCK
;; return data;
mov bl, [bp + 0] ; $data
mov bh, 0
leave
ret
include_stdio_asm:
enter 0 ; (push bp; mov bp, sp)
; --- BEGIN INLINE ASM BLOCK
.include "lib/stdio.asm"
; --- END INLINE ASM BLOCK
leave
ret
show:
enter 0 ; (push bp; mov bp, sp)
; $i
; $j
sub sp, 4
;; for(i = 0; i < 30 ; i++){
_for34_init:
lea d, [bp + -1] ; $i
mov b, $0
mov [d], b
_for34_cond:
mov b, [bp + -1] ; $i
; START RELATIONAL
push a
mov a, b
mov b, $1e
cmp a, b
slt ; <
pop a
; END RELATIONAL
cmp b, 0
je _for34_exit
_for34_block:
;; for(j = 0; j < 40 ; j++){
_for35_init:
lea d, [bp + -3] ; $j
mov b, $0
mov [d], b
_for35_cond:
mov b, [bp + -3] ; $j
; START RELATIONAL
push a
mov a, b
mov b, $28
cmp a, b
slt ; <
pop a
; END RELATIONAL
cmp b, 0
je _for35_exit
_for35_block:
;; currState[i][j] == '@' ? printf("@ ") : printf(". ");
_ternary36_cond:
mov d, _currState_data ; $currState
push a
mov b, [bp + -1] ; $i
mma 40 ; mov a, 40; mul a, b; add d, b
mov b, [bp + -3] ; $j
add d, b
pop a
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $40
cmp a, b
seq ; ==
pop a
; END RELATIONAL
cmp b, 0
je _ternary36_false
_ternary36_true:
mov b, __s2 ; "@ "
swp b
push b
call printf
add sp, 2
jmp _ternary36_exit
_ternary36_false:
mov b, __s3 ; ". "
swp b
push b
call printf
add sp, 2
_ternary36_exit:
_for35_update:
mov b, [bp + -3] ; $j
mov g, b
inc b
lea d, [bp + -3] ; $j
mov [d], b
mov b, g
jmp _for35_cond
_for35_exit:
;; putchar(10);
mov b, $a
push bl
call putchar
add sp, 1
_for34_update:
mov b, [bp + -1] ; $i
mov g, b
inc b
lea d, [bp + -1] ; $i
mov [d], b
mov b, g
jmp _for34_cond
_for34_exit:
leave
ret
alive:
enter 0 ; (push bp; mov bp, sp)
;; if(currState[i][j] == '@') return 1;
_if37_cond:
mov d, _currState_data ; $currState
push a
mov b, [bp + 7] ; $i
mma 40 ; mov a, 40; mul a, b; add d, b
mov b, [bp + 5] ; $j
add d, b
pop a
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $40
cmp a, b
seq ; ==
pop a
; END RELATIONAL
cmp b, 0
je _if37_else
_if37_true:
;; return 1;
mov b, $1
leave
ret
jmp _if37_exit
_if37_else:
;; return 0;
mov b, $0
leave
ret
_if37_exit:
leave
ret
neighbours:
enter 0 ; (push bp; mov bp, sp)
; $count
sub sp, 2
;; count = 0;
lea d, [bp + -1] ; $count
mov b, $0
mov [d], b
;; if(currState[i+-1][j] == '@') count++;
_if38_cond:
mov d, _currState_data ; $currState
push a
mov b, [bp + 7] ; $i
; START TERMS
push a
mov a, b
mov b, $1
neg b
add a, b
mov b, a
pop a
; END TERMS
mma 40 ; mov a, 40; mul a, b; add d, b
mov b, [bp + 5] ; $j
add d, b
pop a
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $40
cmp a, b
seq ; ==
pop a
; END RELATIONAL
cmp b, 0
je _if38_exit
_if38_true:
;; count++;
mov b, [bp + -1] ; $count
mov g, b
inc b
lea d, [bp + -1] ; $count
mov [d], b
mov b, g
jmp _if38_exit
_if38_exit:
;; if(currState[i+-1][j+-1] == '@') count++;
_if39_cond:
mov d, _currState_data ; $currState
push a
mov b, [bp + 7] ; $i
; START TERMS
push a
mov a, b
mov b, $1
neg b
add a, b
mov b, a
pop a
; END TERMS
mma 40 ; mov a, 40; mul a, b; add d, b
mov b, [bp + 5] ; $j
; START TERMS
push a
mov a, b
mov b, $1
neg b
add a, b
mov b, a
pop a
; END TERMS
add d, b
pop a
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $40
cmp a, b
seq ; ==
pop a
; END RELATIONAL
cmp b, 0
je _if39_exit
_if39_true:
;; count++;
mov b, [bp + -1] ; $count
mov g, b
inc b
lea d, [bp + -1] ; $count
mov [d], b
mov b, g
jmp _if39_exit
_if39_exit:
;; if(currState[i+-1][j+1] == '@') count++;
_if40_cond:
mov d, _currState_data ; $currState
push a
mov b, [bp + 7] ; $i
; START TERMS
push a
mov a, b
mov b, $1
neg b
add a, b
mov b, a
pop a
; END TERMS
mma 40 ; mov a, 40; mul a, b; add d, b
mov b, [bp + 5] ; $j
; START TERMS
push a
mov a, b
mov b, $1
add a, b
mov b, a
pop a
; END TERMS
add d, b
pop a
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $40
cmp a, b
seq ; ==
pop a
; END RELATIONAL
cmp b, 0
je _if40_exit
_if40_true:
;; count++;
mov b, [bp + -1] ; $count
mov g, b
inc b
lea d, [bp + -1] ; $count
mov [d], b
mov b, g
jmp _if40_exit
_if40_exit:
;; if(currState[i][j+-1] == '@') count++;
_if41_cond:
mov d, _currState_data ; $currState
push a
mov b, [bp + 7] ; $i
mma 40 ; mov a, 40; mul a, b; add d, b
mov b, [bp + 5] ; $j
; START TERMS
push a
mov a, b
mov b, $1
neg b
add a, b
mov b, a
pop a
; END TERMS
add d, b
pop a
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $40
cmp a, b
seq ; ==
pop a
; END RELATIONAL
cmp b, 0
je _if41_exit
_if41_true:
;; count++;
mov b, [bp + -1] ; $count
mov g, b
inc b
lea d, [bp + -1] ; $count
mov [d], b
mov b, g
jmp _if41_exit
_if41_exit:
;; if(currState[i][j+1] == '@') count++;
_if42_cond:
mov d, _currState_data ; $currState
push a
mov b, [bp + 7] ; $i
mma 40 ; mov a, 40; mul a, b; add d, b
mov b, [bp + 5] ; $j
; START TERMS
push a
mov a, b
mov b, $1
add a, b
mov b, a
pop a
; END TERMS
add d, b
pop a
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $40
cmp a, b
seq ; ==
pop a
; END RELATIONAL
cmp b, 0
je _if42_exit
_if42_true:
;; count++;
mov b, [bp + -1] ; $count
mov g, b
inc b
lea d, [bp + -1] ; $count
mov [d], b
mov b, g
jmp _if42_exit
_if42_exit:
;; if(currState[i+1][j+-1] == '@') count++;
_if43_cond:
mov d, _currState_data ; $currState
push a
mov b, [bp + 7] ; $i
; START TERMS
push a
mov a, b
mov b, $1
add a, b
mov b, a
pop a
; END TERMS
mma 40 ; mov a, 40; mul a, b; add d, b
mov b, [bp + 5] ; $j
; START TERMS
push a
mov a, b
mov b, $1
neg b
add a, b
mov b, a
pop a
; END TERMS
add d, b
pop a
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $40
cmp a, b
seq ; ==
pop a
; END RELATIONAL
cmp b, 0
je _if43_exit
_if43_true:
;; count++;
mov b, [bp + -1] ; $count
mov g, b
inc b
lea d, [bp + -1] ; $count
mov [d], b
mov b, g
jmp _if43_exit
_if43_exit:
;; if(currState[i+1][j] == '@') count++;
_if44_cond:
mov d, _currState_data ; $currState
push a
mov b, [bp + 7] ; $i
; START TERMS
push a
mov a, b
mov b, $1
add a, b
mov b, a
pop a
; END TERMS
mma 40 ; mov a, 40; mul a, b; add d, b
mov b, [bp + 5] ; $j
add d, b
pop a
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $40
cmp a, b
seq ; ==
pop a
; END RELATIONAL
cmp b, 0
je _if44_exit
_if44_true:
;; count++;
mov b, [bp + -1] ; $count
mov g, b
inc b
lea d, [bp + -1] ; $count
mov [d], b
mov b, g
jmp _if44_exit
_if44_exit:
;; if(currState[i+1][j+1] == '@') count++;
_if45_cond:
mov d, _currState_data ; $currState
push a
mov b, [bp + 7] ; $i
; START TERMS
push a
mov a, b
mov b, $1
add a, b
mov b, a
pop a
; END TERMS
mma 40 ; mov a, 40; mul a, b; add d, b
mov b, [bp + 5] ; $j
; START TERMS
push a
mov a, b
mov b, $1
add a, b
mov b, a
pop a
; END TERMS
add d, b
pop a
mov bl, [d]
mov bh, 0
; START RELATIONAL
push a
mov a, b
mov b, $40
cmp a, b
seq ; ==
pop a
; END RELATIONAL
cmp b, 0
je _if45_exit
_if45_true:
;; count++;
mov b, [bp + -1] ; $count
mov g, b
inc b
lea d, [bp + -1] ; $count
mov [d], b
mov b, g
jmp _if45_exit
_if45_exit:
;; return count;
mov b, [bp + -1] ; $count
leave
ret
; --- END TEXT BLOCK
; --- BEGIN DATA BLOCK
_clear_data:
.db 27,$5b,$32,$4a,27,$5b,$48,0,
.fill 3, 0
_nextState_data: .fill 1200, 0
_currState_data:
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$40,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$40,$20,$40,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$40,$40,$20,$20,$20,$20,$20,$20,$40,$40,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$40,$40,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$40,$20,$20,$20,$40,$20,$20,$20,$20,$40,$40,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$40,$40,$20,$20,$20,$20,$40,$40,$20,$20,$20,$20,$20,$20,$20,$20,$40,$20,$20,$20,$20,$20,$40,
.db $20,$20,$20,$40,$40,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$40,$40,$20,$20,$20,$20,$20,
.db $20,$20,$20,$40,$20,$20,$20,$40,$20,$40,$40,$20,$20,$20,$20,$40,$20,$40,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$40,$20,$20,$20,$20,$20,$40,$20,$20,$20,$20,$20,$20,$20,$40,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$40,$20,$20,$20,$40,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$40,$40,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.db $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,
.fill 400, 0
__s0: .db "Unknown type size in va_arg() call. Size needs to be either 1 or 2.", 0
__s1: .db "Error: Unknown argument type.\n", 0
__s2: .db "@ ", 0
__s3: .db ". ", 0
_heap_top: .dw _heap
_heap: .db 0
; --- END DATA BLOCK
.end
|