|
|
push bp |
|
|
mov bp,sp |
|
|
push 10[bp] |
|
|
push 8[bp] |
|
|
push 6[bp] |
|
|
call _main |
|
|
add sp, #0x6 |
|
|
pop bp |
|
|
retf |
|
|
! 1 |
|
|
! 1 # 1 "main.c" |
|
|
! 1 # 1 "std_singos/stdio.h" |
|
|
! 1 void print(string); |
|
|
!BCC_EOS |
|
|
! 2 void* dump_ax_return(input); |
|
|
!BCC_EOS |
|
|
! 3 |
|
|
! 4 void print(string) |
|
|
! 5 char* string; |
|
|
export _print |
|
|
_print: |
|
|
!BCC_EOS |
|
|
! 6 { |
|
|
! 7 #asm |
|
|
!BCC_ASM |
|
|
_print.string set 2 |
|
|
|
|
|
push bp |
|
|
mov bp,sp |
|
|
mov si,4[bp] |
|
|
call 0x0000:0x7C47 |
|
|
pop bp |
|
|
! 13 endasm |
|
|
!BCC_ENDASM |
|
|
! 14 } |
|
|
ret |
|
|
! 15 |
|
|
! 16 void print_stack(argument) |
|
|
! 17 { |
|
|
export _print_stack |
|
|
_print_stack: |
|
|
! 18 #asm |
|
|
!BCC_ASM |
|
|
_print_stack.argument set 2 |
|
|
|
|
|
push bp |
|
|
mov bp,sp |
|
|
push ds |
|
|
push ax |
|
|
|
|
|
mov ax, ss |
|
|
mov ds, ax |
|
|
mov si,4[bp] |
|
|
call 0x0000:0x7C47 |
|
|
|
|
|
pop ax |
|
|
pop ds |
|
|
pop bp |
|
|
! 32 endasm |
|
|
!BCC_ENDASM |
|
|
! 33 } |
|
|
ret |
|
|
! 34 |
|
|
! 35 void* dump_ax_return(input) |
|
|
! 36 void* input; |
|
|
export _dump_ax_return |
|
|
_dump_ax_return: |
|
|
!BCC_EOS |
|
|
! 37 { |
|
|
! 38 return input; |
|
|
push bp |
|
|
mov bp,sp |
|
|
push di |
|
|
push si |
|
|
mov ax,4[bp] |
|
|
pop si |
|
|
pop di |
|
|
pop bp |
|
|
ret |
|
|
!BCC_EOS |
|
|
! 39 } |
|
|
! 40 |
|
|
! 41 void dump_ax(input) |
|
|
! 42 void* input; |
|
|
export _dump_ax |
|
|
_dump_ax: |
|
|
!BCC_EOS |
|
|
! 43 { |
|
|
! 44 dump_ax_return(input) |
|
|
push bp |
|
|
mov bp,sp |
|
|
push di |
|
|
push si |
|
|
! 45 #asm |
|
|
! Debug: list * void input = [S+6+2] (used reg = ) |
|
|
push 4[bp] |
|
|
! Debug: func () * void = dump_ax_return+0 (used reg = ) |
|
|
call _dump_ax_return |
|
|
inc sp |
|
|
inc sp |
|
|
!BCC_EOS |
|
|
!BCC_ASM |
|
|
_dump_ax.input set 8 |
|
|
.dump_ax.input set 4 |
|
|
push bp |
|
|
mov bp,sp |
|
|
call 0x000:0x7C2A |
|
|
pop bp |
|
|
! 50 endasm |
|
|
!BCC_ENDASM |
|
|
!BCC_EOS |
|
|
! 51 } |
|
|
pop si |
|
|
pop di |
|
|
pop bp |
|
|
ret |
|
|
! 52 |
|
|
! 53 void print_newline() |
|
|
! 54 { |
|
|
export _print_newline |
|
|
_print_newline: |
|
|
! 55 #asm |
|
|
!BCC_ASM |
|
|
|
|
|
printCRLF: |
|
|
mov ah, #0xE |
|
|
mov al, #13 |
|
|
int #0x10 |
|
|
mov al, #10 |
|
|
int #0x10 |
|
|
ret |
|
|
! 63 endasm |
|
|
!BCC_ENDASM |
|
|
! 64 } |
|
|
ret |
|
|
! 65 # 1 "std_singos/stdlib.h" |
|
|
! 1 unsigned int global_heap_start = 0; |
|
|
export _global_heap_start |
|
|
_global_heap_start: |
|
|
.word 0 |
|
|
!BCC_EOS |
|
|
! 2 unsigned int global_heap_end = 0; |
|
|
export _global_heap_end |
|
|
_global_heap_end: |
|
|
.word 0 |
|
|
!BCC_EOS |
|
|
! 3 unsigned int global_heap_next = 0; |
|
|
export _global_heap_next |
|
|
_global_heap_next: |
|
|
.word 0 |
|
|
!BCC_EOS |
|
|
! 4 |
|
|
! 5 void* malloc(num_bytes); |
|
|
!BCC_EOS |
|
|
! 6 void* calloc(number_elements, size); |
|
|
!BCC_EOS |
|
|
! 7 int set_heap_settings(param_start, param_end); |
|
|
!BCC_EOS |
|
|
! 8 unsigned int get_heap_next(); |
|
|
!BCC_EOS |
|
|
! 9 |
|
|
! 10 void* malloc(num_bytes) |
|
|
! 11 int num_bytes; |
|
|
.text |
|
|
export _malloc |
|
|
_malloc: |
|
|
!BCC_EOS |
|
|
! 12 { |
|
|
! 13 unsigned int allocated_pointer = global_heap_next; |
|
|
push bp |
|
|
mov bp,sp |
|
|
push di |
|
|
push si |
|
|
dec sp |
|
|
dec sp |
|
|
! Debug: eq unsigned int = [global_heap_next+0] to unsigned int allocated_pointer = [S+8-8] (used reg = ) |
|
|
mov ax,[_global_heap_next] |
|
|
mov -6[bp],ax |
|
|
!BCC_EOS |
|
|
! 14 global_heap_next = global_heap_next + num_bytes; |
|
|
! Debug: add int num_bytes = [S+8+2] to unsigned int = [global_heap_next+0] (used reg = ) |
|
|
mov ax,[_global_heap_next] |
|
|
add ax,4[bp] |
|
|
! Debug: eq unsigned int = ax+0 to unsigned int = [global_heap_next+0] (used reg = ) |
|
|
mov [_global_heap_next],ax |
|
|
!BCC_EOS |
|
|
! 15 if (global_heap_next > global_heap_end) |
|
|
! Debug: gt unsigned int = [global_heap_end+0] to unsigned int = [global_heap_next+0] (used reg = ) |
|
|
mov ax,[_global_heap_next] |
|
|
cmp ax,[_global_heap_end] |
|
|
jbe .1 |
|
|
.2: |
|
|
! 16 { |
|
|
! 17 return 0; |
|
|
xor ax,ax |
|
|
inc sp |
|
|
inc sp |
|
|
pop si |
|
|
pop di |
|
|
pop bp |
|
|
ret |
|
|
!BCC_EOS |
|
|
! 18 } |
|
|
! 19 |
|
|
! 20 return allocated_pointer; |
|
|
.1: |
|
|
mov ax,-6[bp] |
|
|
inc sp |
|
|
inc sp |
|
|
pop si |
|
|
pop di |
|
|
pop bp |
|
|
ret |
|
|
!BCC_EOS |
|
|
! 21 } |
|
|
! 22 |
|
|
! 23 void* calloc(number_elements, size) |
|
|
! 24 unsigned int number_elements; |
|
|
export _calloc |
|
|
_calloc: |
|
|
!BCC_EOS |
|
|
! 25 unsigned int size; |
|
|
!BCC_EOS |
|
|
! 26 { |
|
|
! 27 int i; |
|
|
!BCC_EOS |
|
|
! 28 char* temp_pointer; |
|
|
!BCC_EOS |
|
|
! 29 unsigned int num_bytes = number_elements * size; |
|
|
push bp |
|
|
mov bp,sp |
|
|
push di |
|
|
push si |
|
|
add sp,*-6 |
|
|
! Debug: mul unsigned int size = [S+$C+4] to unsigned int number_elements = [S+$C+2] (used reg = ) |
|
|
mov ax,4[bp] |
|
|
mov cx,6[bp] |
|
|
imul cx |
|
|
! Debug: eq unsigned int = ax+0 to unsigned int num_bytes = [S+$C-$C] (used reg = ) |
|
|
mov -$A[bp],ax |
|
|
!BCC_EOS |
|
|
! 30 void* allocated_pointer = global_heap_next; |
|
|
dec sp |
|
|
dec sp |
|
|
! Debug: eq unsigned int = [global_heap_next+0] to * void allocated_pointer = [S+$E-$E] (used reg = ) |
|
|
mov bx,[_global_heap_next] |
|
|
mov -$C[bp],bx |
|
|
!BCC_EOS |
|
|
! 31 global_heap_next = global_heap_next + num_bytes; |
|
|
! Debug: add unsigned int num_bytes = [S+$E-$C] to unsigned int = [global_heap_next+0] (used reg = ) |
|
|
mov ax,[_global_heap_next] |
|
|
add ax,-$A[bp] |
|
|
! Debug: eq unsigned int = ax+0 to unsigned int = [global_heap_next+0] (used reg = ) |
|
|
mov [_global_heap_next],ax |
|
|
!BCC_EOS |
|
|
! 32 if (global_heap_next > global_heap_end) |
|
|
! Debug: gt unsigned int = [global_heap_end+0] to unsigned int = [global_heap_next+0] (used reg = ) |
|
|
mov ax,[_global_heap_next] |
|
|
cmp ax,[_global_heap_end] |
|
|
jbe .3 |
|
|
.4: |
|
|
! 33 { |
|
|
! 34 return 0; |
|
|
xor ax,ax |
|
|
add sp,*8 |
|
|
pop si |
|
|
pop di |
|
|
pop bp |
|
|
ret |
|
|
!BCC_EOS |
|
|
! 35 } |
|
|
! 36 |
|
|
! 37 |
|
|
! 38 temp_pointer = allocated_pointer; |
|
|
.3: |
|
|
! Debug: eq * void allocated_pointer = [S+$E-$E] to * char temp_pointer = [S+$E-$A] (used reg = ) |
|
|
mov bx,-$C[bp] |
|
|
mov -8[bp],bx |
|
|
!BCC_EOS |
|
|
! 39 for (i = 0; i < num_bytes; ++i) |
|
|
! Debug: eq int = const 0 to int i = [S+$E-8] (used reg = ) |
|
|
xor ax,ax |
|
|
mov -6[bp],ax |
|
|
!BCC_EOS |
|
|
!BCC_EOS |
|
|
! 40 { |
|
|
jmp .7 |
|
|
.8: |
|
|
! 41 *temp_pointer = 0; |
|
|
mov bx,-8[bp] |
|
|
! Debug: eq int = const 0 to char = [bx+0] (used reg = ) |
|
|
xor al,al |
|
|
mov [bx],al |
|
|
!BCC_EOS |
|
|
! 42 temp_pointer++; |
|
|
! Debug: postinc * char temp_pointer = [S+$E-$A] (used reg = ) |
|
|
mov bx,-8[bp] |
|
|
inc bx |
|
|
mov -8[bp],bx |
|
|
!BCC_EOS |
|
|
! 43 } |
|
|
! 44 |
|
|
! 45 return allocated_pointer; |
|
|
.6: |
|
|
! Debug: preinc int i = [S+$E-8] (used reg = ) |
|
|
mov ax,-6[bp] |
|
|
inc ax |
|
|
mov -6[bp],ax |
|
|
.7: |
|
|
! Debug: lt unsigned int num_bytes = [S+$E-$C] to int i = [S+$E-8] (used reg = ) |
|
|
mov ax,-6[bp] |
|
|
cmp ax,-$A[bp] |
|
|
jb .8 |
|
|
.9: |
|
|
.5: |
|
|
mov ax,-$C[bp] |
|
|
add sp,*8 |
|
|
pop si |
|
|
pop di |
|
|
pop bp |
|
|
ret |
|
|
!BCC_EOS |
|
|
! 46 } |
|
|
! 47 |
|
|
! 48 int set_heap_settings(param_start, param_end) |
|
|
! Register BX used in function calloc |
|
|
! 49 unsigned int param_start; |
|
|
export _set_heap_settings |
|
|
_set_heap_settings: |
|
|
!BCC_EOS |
|
|
! 50 unsigned int param_end; |
|
|
!BCC_EOS |
|
|
! 51 { |
|
|
! 52 global_heap_start = param_start; |
|
|
push bp |
|
|
mov bp,sp |
|
|
push di |
|
|
push si |
|
|
! Debug: eq unsigned int param_start = [S+6+2] to unsigned int = [global_heap_start+0] (used reg = ) |
|
|
mov ax,4[bp] |
|
|
mov [_global_heap_start],ax |
|
|
!BCC_EOS |
|
|
! 53 global_heap_next = param_start; |
|
|
! Debug: eq unsigned int param_start = [S+6+2] to unsigned int = [global_heap_next+0] (used reg = ) |
|
|
mov ax,4[bp] |
|
|
mov [_global_heap_next],ax |
|
|
!BCC_EOS |
|
|
! 54 global_heap_end = param_end; |
|
|
! Debug: eq unsigned int param_end = [S+6+4] to unsigned int = [global_heap_end+0] (used reg = ) |
|
|
mov ax,6[bp] |
|
|
mov [_global_heap_end],ax |
|
|
!BCC_EOS |
|
|
! 55 return 0; |
|
|
xor ax,ax |
|
|
pop si |
|
|
pop di |
|
|
pop bp |
|
|
ret |
|
|
!BCC_EOS |
|
|
! 56 } |
|
|
! 57 |
|
|
! 58 unsigned int get_heap_next() |
|
|
! 59 { |
|
|
export _get_heap_next |
|
|
_get_heap_next: |
|
|
! 60 return global_heap_next; |
|
|
push bp |
|
|
mov bp,sp |
|
|
push di |
|
|
push si |
|
|
mov ax,[_global_heap_next] |
|
|
pop si |
|
|
pop di |
|
|
pop bp |
|
|
ret |
|
|
!BCC_EOS |
|
|
! 61 # 16 "main.h" |
|
|
! 16 } |
|
|
! 17 # 2 "std_singos/string.h" |
|
|
! 2 type |
|
|
! 2 def struct Length_String { |
|
|
! 3 short dynamic; |
|
|
!BCC_EOS |
|
|
! 4 unsigned int length; |
|
|
!BCC_EOS |
|
|
! 5 char *chars; |
|
|
!BCC_EOS |
|
|
! 6 } Length_String; |
|
|
!BCC_EOS |
|
|
! 7 |
|
|
! 8 typedef struct String_Array { |
|
|
! 9 unsigned int length; |
|
|
!BCC_EOS |
|
|
! 10 Length_String **strings; |
|
|
!BCC_EOS |
|
|
! 11 } String_Array; |
|
|
!BCC_EOS |
|
|
! 12 |
|
|
! 13 void strcpy (destination, destination_segment, source, source_segment ); |
|
|
!BCC_EOS |
|
|
! 14 int strlen (source, source_segment); |
|
|
!BCC_EOS |
|
|
! 15 void memcpy (destination, destination_segment, source, source_segment, num_bytes ); |
|
|
!BCC_EOS |
|
|
! 16 |
|
|
! 17 |
|
|
! 18 String_Array *string_split_c(string, delim, keep_delim); |
|
|
!BCC_EOS |
|
|
! 19 Length_String *make_length_string(length, chars); |
|
|
!BCC_EOS |
|
|
! 20 Length_String *make_length_string_c(cstring); |
|
|
!BCC_EOS |
|
|
! 21 String_Array *length_string_split(string, delim, keep_delim); |
|
|
!BCC_EOS |
|
|
! 22 String_Array *create_length_string_array(array_size); |
|
|
!BCC_EOS |
|
|
! 23 Length_String *create_length_string(length, chars); |
|
|
!BCC_EOS |
|
|
! 24 |
|
|
! 25 |
|
|
! 26 |
|
|
! 27 int strlen (source, source_segment) |
|
|
! 28 { |
|
|
export _strlen |
|
|
_strlen: |
|
|
! 29 #asm |
|
|
!BCC_ASM |
|
|
_strlen.source set 2 |
|
|
_strlen.source_segment set 4 |
|
|
|
|
|
|
|
|
push bp |
|
|
mov bp,sp |
|
|
push ds |
|
|
push bx |
|
|
|
|
|
mov ax, 6[bp]; |
|
|
mov ds, ax |
|
|
|
|
|
mov bx, 4[bp]; |
|
|
|
|
|
label_strlen: |
|
|
mov cx, #0x0 ; Set counte to zero |
|
|
.label_strlen_loop: |
|
|
mov BYTE al, [bx] |
|
|
cmp al, #0x0 |
|
|
je .label_strlen_done |
|
|
inc cx ; Count 1 |
|
|
inc bx ; Look at next char |
|
|
jmp .label_strlen_loop |
|
|
.label_strlen_done: |
|
|
mov ax, cx |
|
|
|
|
|
pop bx |
|
|
pop ds |
|
|
pop bp |
|
|
! 57 endasm |
|
|
!BCC_ENDASM |
|
|
! 58 } |
|
|
ret |
|
|
! 59 |
|
|
! 60 void strcpy (destination, destination_segment, source, source_segment ) |
|
|
! 61 char *destination; |
|
|
export _strcpy |
|
|
_strcpy: |
|
|
!BCC_EOS |
|
|
! 62 int destination_segment; |
|
|
!BCC_EOS |
|
|
! 63 char *source; |
|
|
!BCC_EOS |
|
|
! 64 int source_segment; |
|
|
!BCC_EOS |
|
|
! 65 { |
|
|
! 66 #asm |
|
|
!BCC_ASM |
|
|
_strcpy.source set 6 |
|
|
_strcpy.destination set 2 |
|
|
_strcpy.source_segment set 8 |
|
|
_strcpy.destination_segment set 4 |
|
|
; copy two strings |
|
|
; IN si: the first (zero terminated) string |
|
|
; IN di: the second (zero terminated) string |
|
|
; OUT SF and ZF (same semantics as cmp) |
|
|
|
|
|
! 72 76 |
|
|
|
|
|
push bp |
|
|
mov bp,sp |
|
|
label_strcpy: |
|
|
push ax |
|
|
push bx |
|
|
push di |
|
|
push es |
|
|
push si |
|
|
push ds |
|
|
mov ax, 4[bp]; ; |
|
|
mov di, ax |
|
|
mov ax, 6[bp]; ; |
|
|
mov es, ax |
|
|
mov ax, 8[bp]; ; |
|
|
mov si, ax |
|
|
mov ax, 10[bp]; ; |
|
|
mov ds, ax |
|
|
mov cx, 0x050 ;TODO(Jrn) Hardcded number of bytes to copy |
|
|
.label_strcpy_loop: |
|
|
movsb |
|
|
cmp cx, 0x0 |
|
|
je .label_strcpy_end |
|
|
dec cx |
|
|
jmp .label_strcpy_loop |
|
|
.label_strcpy_end: |
|
|
pop ds |
|
|
pop si |
|
|
pop es |
|
|
pop di |
|
|
pop bx |
|
|
pop ax |
|
|
pop bp |
|
|
|
|
|
! 110 endasm |
|
|
!BCC_ENDASM |
|
|
! 111 } |
|
|
ret |
|
|
! 112 |
|
|
! 113 void memcpy (destination, destination_segment, source, source_segment, num_bytes) |
|
|
! 114 void *destination; |
|
|
export _memcpy |
|
|
_memcpy: |
|
|
!BCC_EOS |
|
|
! 115 int destination_segment; |
|
|
!BCC_EOS |
|
|
! 116 void *source; |
|
|
!BCC_EOS |
|
|
! 117 int source_segment; |
|
|
!BCC_EOS |
|
|
! 118 int num_bytes; |
|
|
!BCC_EOS |
|
|
! 119 { |
|
|
! 120 #asm |
|
|
!BCC_ASM |
|
|
_memcpy.source set 6 |
|
|
_memcpy.destination set 2 |
|
|
_memcpy.num_bytes set $A |
|
|
_memcpy.source_segment set 8 |
|
|
_memcpy.destination_segment set 4 |
|
|
; copy two strings |
|
|
; IN si: the first (zero terminated) string |
|
|
; IN di: the second (zero terminated) string |
|
|
; OUT SF and ZF (same semantics as cmp) |
|
|
|
|
|
! 126 131 |
|
|
|
|
|
push bp |
|
|
mov bp,sp |
|
|
label_memcpy: |
|
|
push ax |
|
|
push bx |
|
|
push di |
|
|
push es |
|
|
push si |
|
|
push ds |
|
|
mov ax, 4[bp]; ; |
|
|
mov di, ax |
|
|
mov ax, 6[bp]; ; |
|
|
mov es, ax |
|
|
mov ax, 8[bp]; ; |
|
|
mov si, ax |
|
|
mov ax, 10[bp]; ; |
|
|
mov ds, ax |
|
|
mov cx, 12[bp]; |
|
|
.label_memcpy_loop: |
|
|
movsb |
|
|
cmp cx, 0x0 |
|
|
je .label_memcpy_end |
|
|
dec cx |
|
|
jmp .label_memcpy_loop |
|
|
.label_memcpy_end: |
|
|
pop ds |
|
|
pop si |
|
|
pop es |
|
|
pop di |
|
|
pop bx |
|
|
pop ax |
|
|
pop bp |
|
|
|
|
|
! 165 endasm |
|
|
!BCC_ENDASM |
|
|
! 166 } |
|
|
ret |
|
|
! 167 |
|
|
! 168 String_Array *string_split_c(string, delim, keep_delim) |
|
|
! 169 char *string; |
|
|
export _string_split_c |
|
|
_string_split_c: |
|
|
!BCC_EOS |
|
|
! 170 char delim; |
|
|
!BCC_EOS |
|
|
! 171 short keep_delim; |
|
|
!BCC_EOS |
|
|
! 172 { |
|
|
! 173 return length_string_split(make_length_string_c(string), delim, keep_delim); |
|
|
push bp |
|
|
mov bp,sp |
|
|
push di |
|
|
push si |
|
|
! Debug: list short keep_delim = [S+6+6] (used reg = ) |
|
|
push 8[bp] |
|
|
! Debug: list char delim = [S+8+4] (used reg = ) |
|
|
mov al,6[bp] |
|
|
xor ah,ah |
|
|
push ax |
|
|
! Debug: list * char string = [S+$A+2] (used reg = ) |
|
|
push 4[bp] |
|
|
! Debug: func () * struct Length_String = make_length_string_c+0 (used reg = ) |
|
|
call _make_length_string_c |
|
|
inc sp |
|
|
inc sp |
|
|
! Debug: list * struct Length_String = ax+0 (used reg = ) |
|
|
push ax |
|
|
! Debug: func () * struct String_Array = length_string_split+0 (used reg = ) |
|
|
call _length_string_split |
|
|
add sp,*6 |
|
|
! Debug: cast * struct String_Array = const 0 to * struct String_Array = ax+0 (used reg = ) |
|
|
pop si |
|
|
pop di |
|
|
pop bp |
|
|
ret |
|
|
!BCC_EOS |
|
|
! 174 } |
|
|
! 175 |
|
|
! 176 Length_String *make_length_string_c(cstring) |
|
|
! 177 char *cstring; |
|
|
export _make_length_string_c |
|
|
_make_length_string_c: |
|
|
!BCC_EOS |
|
|
! 178 { |
|
|
! 179 return make_length_string(strlen(cstring, 0x7e0), cstring); |
|
|
push bp |
|
|
mov bp,sp |
|
|
push di |
|
|
push si |
|
|
! Debug: list * char cstring = [S+6+2] (used reg = ) |
|
|
push 4[bp] |
|
|
! Debug: list int = const $7E0 (used reg = ) |
|
|
mov ax,#$7E0 |
|
|
push ax |
|
|
! Debug: list * char cstring = [S+$A+2] (used reg = ) |
|
|
push 4[bp] |
|
|
! Debug: func () int = strlen+0 (used reg = ) |
|
|
call _strlen |
|
|
add sp,*4 |
|
|
! Debug: list int = ax+0 (used reg = ) |
|
|
push ax |
|
|
! Debug: func () * struct Length_String = make_length_string+0 (used reg = ) |
|
|
call _make_length_string |
|
|
add sp,*4 |
|
|
! Debug: cast * struct Length_String = const 0 to * struct Length_String = ax+0 (used reg = ) |
|
|
pop si |
|
|
pop di |
|
|
pop bp |
|
|
ret |
|
|
!BCC_EOS |
|
|
! 180 } |
|
|
! 181 |
|
|
! 182 Length_String *make_length_string(length, chars) |
|
|
! 183 unsigned int length; |
|
|
export _make_length_string |
|
|
_make_length_string: |
|
|
!BCC_EOS |
|
|
! 184 char *chars; |
|
|
!BCC_EOS |
|
|
! 185 { |
|
|
! 186 |
|
|
! 187 Length_String *legth_string = malloc(sizeof(Length_String)); |
|
|
push bp |
|
|
mov bp,sp |
|
|
push di |
|
|
push si |
|
|
dec sp |
|
|
dec sp |
|
|
! Debug: list int = const 6 (used reg = ) |
|
|
mov ax,*6 |
|
|
push ax |
|
|
! Debug: func () * void = malloc+0 (used reg = ) |
|
|
call _malloc |
|
|
inc sp |
|
|
inc sp |
|
|
! Debug: eq * void = ax+0 to * struct Length_String legth_string = [S+8-8] (used reg = ) |
|
|
mov -6[bp],ax |
|
|
!BCC_EOS |
|
|
! 188 char *copy = malloc(length + 1); |
|
|
dec sp |
|
|
dec sp |
|
|
! Debug: add int = const 1 to unsigned int length = [S+$A+2] (used reg = ) |
|
|
mov ax,4[bp] |
|
|
! Debug: list unsigned int = ax+1 (used reg = ) |
|
|
inc ax |
|
|
push ax |
|
|
! Debug: func () * void = malloc+0 (used reg = ) |
|
|
call _malloc |
|
|
inc sp |
|
|
inc sp |
|
|
! Debug: eq * void = ax+0 to * char copy = [S+$A-$A] (used reg = ) |
|
|
mov -8[bp],ax |
|
|
!BCC_EOS |
|
|
! 189 memcpy(copy, 0x7e0, chars, 0x7e0, length); |
|
|
! Debug: list unsigned int length = [S+$A+2] (used reg = ) |
|
|
push 4[bp] |
|
|
! Debug: list int = const $7E0 (used reg = ) |
|
|
mov ax,#$7E0 |
|
|
push ax |
|
|
! Debug: list * char chars = [S+$E+4] (used reg = ) |
|
|
push 6[bp] |
|
|
! Debug: list int = const $7E0 (used reg = ) |
|
|
mov ax,#$7E0 |
|
|
push ax |
|
|
! Debug: list * char copy = [S+$12-$A] (used reg = ) |
|
|
push -8[bp] |
|
|
! Debug: func () void = memcpy+0 (used reg = ) |
|
|
call _memcpy |
|
|
add sp,*$A |
|
|
!BCC_EOS |
|
|
! 190 copy[length] = ' '; |
|
|
! Debug: ptradd unsigned int length = [S+$A+2] to * char copy = [S+$A-$A] (used reg = ) |
|
|
mov ax,4[bp] |
|
|
add ax,-8[bp] |
|
|
mov bx,ax |
|
|
! Debug: eq int = const 0 to char = [bx+0] (used reg = ) |
|
|
xor al,al |
|
|
mov [bx],al |
|
|
!BCC_EOS |
|
|
! 191 |
|
|
! 192 legth_string->dynamic = 0; |
|
|
mov bx,-6[bp] |
|
|
! Debug: eq int = const 0 to short = [bx+0] (used reg = ) |
|
|
xor ax,ax |
|
|
mov [bx],ax |
|
|
!BCC_EOS |
|
|
! 193 legth_string->length = length; |
|
|
mov bx,-6[bp] |
|
|
! Debug: eq unsigned int length = [S+$A+2] to unsigned int = [bx+2] (used reg = ) |
|
|
mov ax,4[bp] |
|
|
mov 2[bx],ax |
|
|
!BCC_EOS |
|
|
! 194 legth_string->chars = (char *)chars; |
|
|
mov bx,-6[bp] |
|
|
! Debug: eq * char chars = [S+$A+4] to * char = [bx+4] (used reg = ) |
|
|
mov si,6[bp] |
|
|
mov 4[bx],si |
|
|
!BCC_EOS |
|
|
! 195 |
|
|
! 196 return legth_string; |
|
|
mov ax,-6[bp] |
|
|
add sp,*4 |
|
|
pop si |
|
|
pop di |
|
|
pop bp |
|
|
ret |
|
|
!BCC_EOS |
|
|
! 197 } |
|
|
! 198 |
|
|
! 199 String_Array *length_string_split(string, delim, keep_delim) |
|
|
! Register BX SI used in function make_length_string |
|
|
! 200 Length_String *string; |
|
|
export _length_string_split |
|
|
_length_string_split: |
|
|
!BCC_EOS |
|
|
! 201 char delim; |
|
|
!BCC_EOS |
|
|
! 202 short keep_delim; |
|
|
!BCC_EOS |
|
|
! 203 { |
|
|
! 204 unsigned int i; |
|
|
!BCC_EOS |
|
|
! 205 unsi |
|
|
! 205 gned int last; |
|
|
!BCC_EOS |
|
|
! 206 |
|
|
! 207 unsigned int count = 0; |
|
|
push bp |
|
|
mov bp,sp |
|
|
push di |
|
|
push si |
|
|
add sp,*-6 |
|
|
! Debug: eq int = const 0 to unsigned int count = [S+$C-$C] (used reg = ) |
|
|
xor ax,ax |
|
|
mov -$A[bp],ax |
|
|
!BCC_EOS |
|
|
! 208 unsigned int insert_index = 0; |
|
|
dec sp |
|
|
dec sp |
|
|
! Debug: eq int = const 0 to unsigned int insert_index = [S+$E-$E] (used reg = ) |
|
|
xor ax,ax |
|
|
mov -$C[bp],ax |
|
|
!BCC_EOS |
|
|
! 209 String_Array *result; |
|
|
!BCC_EOS |
|
|
! 210 int k; |
|
|
!BCC_EOS |
|
|
! 211 |
|
|
! 212 i = 0; |
|
|
add sp,*-4 |
|
|
! Debug: eq int = const 0 to unsigned int i = [S+$12-8] (used reg = ) |
|
|
xor ax,ax |
|
|
mov -6[bp],ax |
|
|
!BCC_EOS |
|
|
! 213 last = 0; |
|
|
! Debug: eq int = const 0 to unsigned int last = [S+$12-$A] (used reg = ) |
|
|
xor ax,ax |
|
|
mov -8[bp],ax |
|
|
!BCC_EOS |
|
|
! 214 while(i < string->length) { |
|
|
jmp .B |
|
|
.C: |
|
|
! 215 if (string->chars[i] == delim) { |
|
|
mov bx,4[bp] |
|
|
! Debug: ptradd unsigned int i = [S+$12-8] to * char = [bx+4] (used reg = ) |
|
|
mov ax,-6[bp] |
|
|
add ax,4[bx] |
|
|
mov bx,ax |
|
|
! Debug: logeq char delim = [S+$12+4] to char = [bx+0] (used reg = ) |
|
|
mov al,[bx] |
|
|
cmp al,6[bp] |
|
|
jne .D |
|
|
.E: |
|
|
! 216 if (i > last+1) { |
|
|
! Debug: add int = const 1 to unsigned int last = [S+$12-$A] (used reg = ) |
|
|
mov ax,-8[bp] |
|
|
! Debug: gt unsigned int = ax+1 to unsigned int i = [S+$12-8] (used reg = ) |
|
|
inc ax |
|
|
cmp ax,-6[bp] |
|
|
jae .F |
|
|
.10: |
|
|
! 217 ++count; |
|
|
! Debug: preinc unsigned int count = [S+$12-$C] (used reg = ) |
|
|
mov ax,-$A[bp] |
|
|
inc ax |
|
|
mov -$A[bp],ax |
|
|
!BCC_EOS |
|
|
! 218 } |
|
|
! 219 last = i; |
|
|
.F: |
|
|
! Debug: eq unsigned int i = [S+$12-8] to unsigned int last = [S+$12-$A] (used reg = ) |
|
|
mov ax,-6[bp] |
|
|
mov -8[bp],ax |
|
|
!BCC_EOS |
|
|
! 220 } |
|
|
! 221 ++i; |
|
|
.D: |
|
|
! Debug: preinc unsigned int i = [S+$12-8] (used reg = ) |
|
|
mov ax,-6[bp] |
|
|
inc ax |
|
|
mov -6[bp],ax |
|
|
!BCC_EOS |
|
|
! 222 } |
|
|
! 223 if (i > last+1) { |
|
|
.B: |
|
|
mov bx,4[bp] |
|
|
! Debug: lt unsigned int = [bx+2] to unsigned int i = [S+$12-8] (used reg = ) |
|
|
mov ax,-6[bp] |
|
|
cmp ax,2[bx] |
|
|
jb .C |
|
|
.11: |
|
|
.A: |
|
|
! Debug: add int = const 1 to unsigned int last = [S+$12-$A] (used reg = ) |
|
|
mov ax,-8[bp] |
|
|
! Debug: gt unsigned int = ax+1 to unsigned int i = [S+$12-8] (used reg = ) |
|
|
inc ax |
|
|
cmp ax,-6[bp] |
|
|
jae .12 |
|
|
.13: |
|
|
! 224 ++count; |
|
|
! Debug: preinc unsigned int count = [S+$12-$C] (used reg = ) |
|
|
mov ax,-$A[bp] |
|
|
inc ax |
|
|
mov -$A[bp],ax |
|
|
!BCC_EOS |
|
|
! 225 } |
|
|
! 226 |
|
|
! 227 result = create_length_string_array(count); |
|
|
.12: |
|
|
! Debug: list unsigned int count = [S+$12-$C] (used reg = ) |
|
|
push -$A[bp] |
|
|
! Debug: func () * struct String_Array = create_length_string_array+0 (used reg = ) |
|
|
call _create_length_string_array |
|
|
inc sp |
|
|
inc sp |
|
|
! Debug: eq * struct String_Array = ax+0 to * struct String_Array result = [S+$12-$10] (used reg = ) |
|
|
mov -$E[bp],ax |
|
|
!BCC_EOS |
|
|
! 228 |
|
|
! 229 if (keep_delim) |
|
|
mov ax,8[bp] |
|
|
test ax,ax |
|
|
je .14 |
|
|
.15: |
|
|
! 230 { |
|
|
! 231 k = 0; |
|
|
! Debug: eq int = const 0 to int k = [S+$12-$12] (used reg = ) |
|
|
xor ax,ax |
|
|
mov -$10[bp],ax |
|
|
!BCC_EOS |
|
|
! 232 } |
|
|
! 233 else |
|
|
! 234 { |
|
|
jmp .16 |
|
|
.14: |
|
|
! 235 k = 1; |
|
|
! Debug: eq int = const 1 to int k = [S+$12-$12] (used reg = ) |
|
|
mov ax,*1 |
|
|
mov -$10[bp],ax |
|
|
!BCC_EOS |
|
|
! 236 } |
|
|
! 237 |
|
|
! 238 i = 0; |
|
|
.16: |
|
|
! Debug: eq int = const 0 to unsigned int i = [S+$12-8] (used reg = ) |
|
|
xor ax,ax |
|
|
mov -6[bp],ax |
|
|
!BCC_EOS |
|
|
! 239 last = 0; |
|
|
! Debug: eq int = const 0 to unsigned int last = [S+$12-$A] (used reg = ) |
|
|
xor ax,ax |
|
|
mov -8[bp],ax |
|
|
!BCC_EOS |
|
|
! 240 while(i < string->length) { |
|
|
jmp .18 |
|
|
.19: |
|
|
! 241 if (string->chars[i] == delim) { |
|
|
mov bx,4[bp] |
|
|
! Debug: ptradd unsigned int i = [S+$12-8] to * char = [bx+4] (used reg = ) |
|
|
mov ax,-6[bp] |
|
|
add ax,4[bx] |
|
|
mov bx,ax |
|
|
! Debug: logeq char delim = [S+$12+4] to char = [bx+0] (used reg = ) |
|
|
mov al,[bx] |
|
|
cmp al,6[bp] |
|
|
jne .1A |
|
|
.1B: |
|
|
! 242 if (i > last+1) { |
|
|
! Debug: add int = const 1 to unsigned int last = [S+$12-$A] (used reg = ) |
|
|
mov ax,-8[bp] |
|
|
! Debug: gt unsigned int = ax+1 to unsigned int i = [S+$12-8] (used reg = ) |
|
|
inc ax |
|
|
cmp ax,-6[bp] |
|
|
jae .1C |
|
|
.1D: |
|
|
! 243 result->strings[insert_index++] = create_length_string(i-(last+k), string->chars+(last+k)); |
|
|
! Debug: add int k = [S+$12-$12] to unsigned int last = [S+$12-$A] (used reg = ) |
|
|
mov ax,-8[bp] |
|
|
add ax,-$10[bp] |
|
|
mov bx,4[bp] |
|
|
! Debug: ptradd unsigned int = ax+0 to * char = [bx+4] (used reg = ) |
|
|
add ax,4[bx] |
|
|
! Debug: list * char = ax+0 (used reg = ) |
|
|
push ax |
|
|
! Debug: add int k = [S+$14-$12] to unsigned int last = [S+$14-$A] (used reg = ) |
|
|
mov ax,-8[bp] |
|
|
add ax,-$10[bp] |
|
|
! Debug: sub unsigned int = ax+0 to unsigned int i = [S+$14-8] (used reg = ) |
|
|
push ax |
|
|
mov ax,-6[bp] |
|
|
sub ax,-$14[bp] |
|
|
inc sp |
|
|
inc sp |
|
|
! Debug: list unsigned int = ax+0 (used reg = ) |
|
|
push ax |
|
|
! Debug: func () * struct Length_String = create_length_string+0 (used reg = ) |
|
|
call _create_length_string |
|
|
add sp,*4 |
|
|
push ax |
|
|
! Debug: postinc unsigned int insert_index = [S+$14-$E] (used reg = ) |
|
|
mov ax,-$C[bp] |
|
|
inc ax |
|
|
mov -$C[bp],ax |
|
|
mov bx,-$E[bp] |
|
|
! Debug: ptradd unsigned int = ax-1 to * * struct Length_String = [bx+2] (used reg = ) |
|
|
dec ax |
|
|
shl ax,*1 |
|
|
add ax,2[bx] |
|
|
mov bx,ax |
|
|
! Debug: eq * struct Length_String (temp) = [S+$14-$14] to * struct Length_String = [bx+0] (used reg = ) |
|
|
mov si,-$12[bp] |
|
|
mov [bx],si |
|
|
inc sp |
|
|
inc sp |
|
|
!BCC_EOS |
|
|
! 244 } |
|
|
! 245 last = i; |
|
|
.1C: |
|
|
! Debug: eq unsigned int i = [S+$12-8] to unsigned int last = [S+$12-$A] (used reg = ) |
|
|
mov ax,-6[bp] |
|
|
mov -8[bp],ax |
|
|
!BCC_EOS |
|
|
! 246 } |
|
|
! 247 ++i; |
|
|
.1A: |
|
|
! Debug: preinc unsigned int i = [S+$12-8] (used reg = ) |
|
|
mov ax,-6[bp] |
|
|
inc ax |
|
|
mov -6[bp],ax |
|
|
!BCC_EOS |
|
|
! 248 } |
|
|
! 249 if (i > last+1) { |
|
|
.18: |
|
|
mov bx,4[bp] |
|
|
! Debug: lt unsigned int = [bx+2] to unsigned int i = [S+$12-8] (used reg = ) |
|
|
mov ax,-6[bp] |
|
|
cmp ax,2[bx] |
|
|
jb .19 |
|
|
.1E: |
|
|
.17: |
|
|
! Debug: add int = const 1 to unsigned int last = [S+$12-$A] (used reg = ) |
|
|
mov ax,-8[bp] |
|
|
! Debug: gt unsigned int = ax+1 to unsigned int i = [S+$12-8] (used reg = ) |
|
|
inc ax |
|
|
cmp ax,-6[bp] |
|
|
jae .1F |
|
|
.20: |
|
|
! 250 result->strings[insert_index++] = create_length_string(i-(last+k), ((string->chars)+(last+k))); |
|
|
! Debug: add int k = [S+$12-$12] to unsigned int last = [S+$12-$A] (used reg = ) |
|
|
mov ax,-8[bp] |
|
|
add ax,-$10[bp] |
|
|
mov bx,4[bp] |
|
|
! Debug: ptradd unsigned int = ax+0 to * char = [bx+4] (used reg = ) |
|
|
add ax,4[bx] |
|
|
! Debug: list * char = ax+0 (used reg = ) |
|
|
push ax |
|
|
! Debug: add int k = [S+$14-$12] to unsigned int last = [S+$14-$A] (used reg = ) |
|
|
mov ax,-8[bp] |
|
|
add ax,-$10[bp] |
|
|
! Debug: sub unsigned int = ax+0 to unsigned int i = [S+$14-8] (used reg = ) |
|
|
push ax |
|
|
mov ax,-6[bp] |
|
|
sub ax,-$14[bp] |
|
|
inc sp |
|
|
inc sp |
|
|
! Debug: list unsigned int = ax+0 (used reg = ) |
|
|
push ax |
|
|
! Debug: func () * struct Length_String = create_length_string+0 (used reg = ) |
|
|
call _create_length_string |
|
|
add sp,*4 |
|
|
push ax |
|
|
! Debug: postinc unsigned int insert_index = [S+$14-$E] (used reg = ) |
|
|
mov ax,-$C[bp] |
|
|
inc ax |
|
|
mov -$C[bp],ax |
|
|
mov bx,-$E[bp] |
|
|
! Debug: ptradd unsigned int = ax-1 to * * struct Length_String = [bx+2] (used reg = ) |
|
|
dec ax |
|
|
shl ax,*1 |
|
|
add ax,2[bx] |
|
|
mov bx,ax |
|
|
! Debug: eq * struct Length_String (temp) = [S+$14-$14] to * struct Length_String = [bx+0] (used reg = ) |
|
|
mov si,-$12[bp] |
|
|
mov [bx],si |
|
|
inc sp |
|
|
inc sp |
|
|
!BCC_EOS |
|
|
! 251 } |
|
|
! 252 |
|
|
! 253 return result; |
|
|
.1F: |
|
|
mov ax,-$E[bp] |
|
|
add sp,*$C |
|
|
pop si |
|
|
pop di |
|
|
pop bp |
|
|
ret |
|
|
!BCC_EOS |
|
|
! 254 |
|
|
! 255 } |
|
|
! 256 |
|
|
! 257 String_Array *create_length_string_array(array_size) |
|
|
! Register BX SI used in function length_string_split |
|
|
! 258 int array_size; |
|
|
export _create_length_string_array |
|
|
_create_length_string_array: |
|
|
!BCC_EOS |
|
|
! 259 { |
|
|
! 260 String_Array *result = malloc(sizeof(String_Array)); |
|
|
push bp |
|
|
mov bp,sp |
|
|
push di |
|
|
push si |
|
|
dec sp |
|
|
dec sp |
|
|
! Debug: list int = const 4 (used reg = ) |
|
|
mov ax,*4 |
|
|
push ax |
|
|
! Debug: func () * void = malloc+0 (used reg = ) |
|
|
call _malloc |
|
|
inc sp |
|
|
inc sp |
|
|
! Debug: eq * void = ax+0 to * struct String_Array result = [S+8-8] (used reg = ) |
|
|
mov -6[bp],ax |
|
|
!BCC_EOS |
|
|
! 261 result->length = array_size; |
|
|
mov bx,-6[bp] |
|
|
! Debug: eq int array_size = [S+8+2] to unsigned int = [bx+0] (used reg = ) |
|
|
mov ax,4[bp] |
|
|
mov [bx],ax |
|
|
!BCC_EOS |
|
|
! 262 result->strings = malloc(array_size * sizeof(Length_String)); |
|
|
! Debug: mul int = const 6 to int array_size = [S+8+2] (used reg = ) |
|
|
mov ax,4[bp] |
|
|
mov dx,ax |
|
|
shl ax,*1 |
|
|
add ax,dx |
|
|
shl ax,*1 |
|
|
! Debug: list int = ax+0 (used reg = ) |
|
|
push ax |
|
|
! Debug: func () * void = malloc+0 (used reg = ) |
|
|
call _malloc |
|
|
inc sp |
|
|
inc sp |
|
|
mov bx,-6[bp] |
|
|
! Debug: eq * void = ax+0 to * * struct Length_String = [bx+2] (used reg = ) |
|
|
mov 2[bx],ax |
|
|
!BCC_EOS |
|
|
! 263 return result; |
|
|
mov ax,-6[bp] |
|
|
inc sp |
|
|
inc sp |
|
|
pop si |
|
|
pop di |
|
|
pop bp |
|
|
ret |
|
|
!BCC_EOS |
|
|
! 264 } |
|
|
! 265 |
|
|
! 266 |
|
|
! 267 Length_String *create_length_string(length, chars) |
|
|
! Register BX used in function create_length_string_array |
|
|
! 268 unsigned int length; |
|
|
export _create_length_string |
|
|
_create_length_string: |
|
|
!BCC_EOS |
|
|
! 269 char *chars; |
|
|
!BCC_EOS |
|
|
! 270 { |
|
|
! 271 |
|
|
! 272 Length_String *legth_string = malloc(sizeof(Length_String)); |
|
|
push bp |
|
|
mov bp,sp |
|
|
push di |
|
|
push si |
|
|
dec sp |
|
|
dec sp |
|
|
! Debug: list int = const 6 (used reg = ) |
|
|
mov ax,*6 |
|
|
push ax |
|
|
! Debug: func () * void = malloc+0 (used reg = ) |
|
|
call _malloc |
|
|
inc sp |
|
|
inc sp |
|
|
! Debug: eq * void = ax+0 to * struct Length_String legth_string = [S+8-8] (used reg = ) |
|
|
mov -6[bp],ax |
|
|
!BCC_EOS |
|
|
! 273 char *copy = malloc(length + 1); |
|
|
dec sp |
|
|
dec sp |
|
|
! Debug: add int = const 1 to unsigned int length = [S+$A+2] (used reg = ) |
|
|
mov ax,4[bp] |
|
|
! Debug: list unsigned int = ax+1 (used reg = ) |
|
|
inc ax |
|
|
push ax |
|
|
! Debug: func () * void = malloc+0 (used reg = ) |
|
|
call _malloc |
|
|
inc sp |
|
|
inc sp |
|
|
! Debug: eq * void = ax+0 to * char copy = [S+$A-$A] (used reg = ) |
|
|
mov -8[bp],ax |
|
|
!BCC_EOS |
|
|
! 274 memcpy(copy, 0x7e0, chars, 0x7e0, length); |
|
|
! Debug: list unsigned int length = [S+$A+2] (used reg = ) |
|
|
push 4[bp] |
|
|
! Debug: list int = const $7E0 (used reg = ) |
|
|
mov ax,#$7E0 |
|
|
push ax |
|
|
! Debug: list * char chars = [S+$E+4] (used reg = ) |
|
|
push 6[bp] |
|
|
! Debug: list int = const $7E0 (used reg = ) |
|
|
mov ax,#$7E0 |
|
|
push ax |
|
|
! Debug: list * char copy = [S+$12-$A] (used reg = ) |
|
|
push -8[bp] |
|
|
! Debug: func () void = memcpy+0 (used reg = ) |
|
|
call _memcpy |
|
|
add sp,*$A |
|
|
!BCC_EOS |
|
|
! 275 copy[length] = ' '; |
|
|
! Debug: ptradd unsigned int length = [S+$A+2] to * char copy = [S+$A-$A] (used reg = ) |
|
|
mov ax,4[bp] |
|
|
add ax,-8[bp] |
|
|
mov bx,ax |
|
|
! Debug: eq int = const 0 to char = [bx+0] (used reg = ) |
|
|
xor al,al |
|
|
mov [bx],al |
|
|
!BCC_EOS |
|
|
! 276 |
|
|
! 277 legth_string->dynamic = 1; |
|
|
mov bx,-6[bp] |
|
|
! Debug: eq int = const 1 to short = [bx+0] (used reg = ) |
|
|
mov ax,*1 |
|
|
mov [bx],ax |
|
|
!BCC_EOS |
|
|
! 278 legth_string->length = length; |
|
|
mov bx,-6[bp] |
|
|
! Debug: eq unsigned int length = [S+$A+2] to unsigned int = [bx+2] (used reg = ) |
|
|
mov ax,4[bp] |
|
|
mov 2[bx],ax |
|
|
!BCC_EOS |
|
|
! 279 legth_string->chars = copy; |
|
|
mov bx,-6[bp] |
|
|
! Debug: eq * char copy = [S+$A-$A] to * char = [bx+4] (used reg = ) |
|
|
mov si,-8[bp] |
|
|
mov 4[bx],si |
|
|
!BCC_EOS |
|
|
! 280 |
|
|
! 281 return legth_string; |
|
|
mov ax,-6[bp] |
|
|
add sp,*4 |
|
|
pop si |
|
|
pop di |
|
|
pop bp |
|
|
ret |
|
|
!BCC_EOS |
|
|
! 282 # 18 "main.h" |
|
|
! 18 } |
|
|
! 19 # 1 "driver/disk.h" |
|
|
! 1 int data_from_disk(index, number_sectors, data_buffer, data_buffer_segment); |
|
|
! Register BX SI used in function create_length_string |
|
|
!BCC_EOS |
|
|
! 2 int disk_service_read_data_from_disk(index, number_sectors, data_buffer, data_buffer_segment); |
|
|
!BCC_EOS |
|
|
! 3 |
|
|
! 4 int disk_service_read_data_from_disk(index, number_sectors, data_buffer, data_buffer_segment) |
|
|
! 5 long* index; |
|
|
export _disk_service_read_data_from_disk |
|
|
_disk_service_read_data_from_disk: |
|
|
!BCC_EOS |
|
|
! 6 long number_sectors; |
|
|
!BCC_EOS |
|
|
! 7 void* data_buffer; |
|
|
!BCC_EOS |
|
|
! 8 int data_buffer_segment; |
|
|
!BCC_EOS |
|
|
! 9 { |
|
|
! 10 |
|
|
! 11 #asm |
|
|
!BCC_ASM |
|
|
_disk_service_read_data_from_disk.data_buffer set 8 |
|
|
_disk_service_read_data_from_disk.number_sectors set 4 |
|
|
_disk_service_read_data_from_disk.data_buffer_segment set $A |
|
|
_disk_service_read_data_from_disk.index set 2 |
|
|
|
|
|
! 13 define number_sectors 8[bp]; |
|
|
|
|
|
|
|
|
|
|
|
push bp |
|
|
mov bp,sp |
|
|
pusha |
|
|
|
|
|
lsfs_load_data: |
|
|
mov ax, 4[bp]; |
|
|
mov WORD [DAPACK.lba_addr_dw_low], ax |
|
|
mov bx, 8[bp]; |
|
|
mov WORD [DAPACK.blkcnt], bx |
|
|
mov cx, 12[bp]; |
|
|
mov WORD [DAPACK.db_addr_segment], cx |
|
|
mov dx, 10[bp]; ; |
|
|
mov WORD [DAPACK.db_addr_offset], dx |
|
|
mov si, #DAPACK ; address of |
|
|
mov ah, #0x42 ; READ |
|
|
mov dl, [global_disk_identifier] |
|
|
int #0x13 |
|
|
;call 0x0000:0x7C2A |
|
|
popa |
|
|
pop bp |
|
|
ret |
|
|
|
|
|
|
|
|
DAPACK: |
|
|
DAPACK.dap_Size: db 0x10 |
|
|
DAPACK.rev_byte: db 0x0 |
|
|
DAPACK.blkcnt: dw 0x0 |
|
|
DAPACK.db_addr_offset: dw 0x0 |
|
|
DAPACK.db_addr_segment: dw 0x0 |
|
|
DAPACK.lba_addr_dw_low: dd 0x0 |
|
|
DAPACK.lba_addr_dw_high: dd 0x0 |
|
|
|
|
|
global_disk_identifier: db 0x80 |
|
|
|
|
|
! 51 endasm |
|
|
!BCC_ENDASM |
|
|
! 52 } |
|
|
ret |
|
|
! 53 # 4 "implementation/lsfs.h" |
|
|
! 4 typedef struct lsfs_file lsfs_file; |
|
|
!BCC_EOS |
|
|
! 5 # 22 "main.h" |
|
|
! 22 void dump_ax(input); |
|
|
!BCC_EOS |
|
|
! 23 void print_stack(argument); |
|
|
!BCC_EOS |
|
|
! 24 void print_newline(); |
|
|
!BCC_EOS |
|
|
! 25 |
|
|
! 26 typedef struct Directory_Table Directory_Table; |
|
|
!BCC_EOS |
|
|
! 27 typedef struct Struct_Table_Entry Table_Entry; |
|
|
!BCC_EOS |
|
|
! 28 typedef struct struct_partition_control partition_control; |
|
|
!BCC_EOS |
|
|
! 29 typedef struct File_System_Control_Information FSCI; |
|
|
!BCC_EOS |
|
|
! 30 typedef struct meta_information_format mif; |
|
|
!BCC_EOS |
|
|
! 31 typedef struct tag_record tag_record; |
|
|
!BCC_EOS |
|
|
! 32 typedef struct Parameter_Struct Parameter_Struct; |
|
|
!BCC_EOS |
|
|
! 33 |
|
|
! 34 typedef enum Table_Entry_Kind |
|
|
! 35 { |
|
|
! 36 |
|
|
! 37 ENTRY_EMPTY = 0, |
|
|
! 38 ENTRY_FILE = 1, |
|
|
! 39 ENTRY_DIRECTORY = 2, |
|
|
! 40 } Table_Entry_Kind; |
|
|
!BCC_EOS |
|
|
! 41 |
|
|
! 42 typedef enum Service_Action |
|
|
! 43 { |
|
|
! 44 SERIVCE_LOAD_DISK = 1, |
|
|
! 45 SERVICE_FIND_ENTRY = 2, |
|
|
! 46 SERIVCE_READ_DATA = 3, |
|
|
! 47 SERIVCE_WRITE_DATA = 4, |
|
|
! 48 |
|
|
! 49 } Service_Action; |
|
|
!BCC_EOS |
|
|
! 50 |
|
|
! 51 struct Struct_Table_Entry |
|
|
! 52 { |
|
|
! 53 char filename[256]; |
|
|
!BCC_EOS |
|
|
! 54 long file_id[2]; |
|
|
!BCC_EOS |
|
|
! 55 long file_size[2]; |
|
|
!BCC_EOS |
|
|
! 56 void* ext_file_data_low; |
|
|
!BCC_EOS |
|
|
! 57 void* ext_file_data_high; |
|
|
!BCC_EOS |
|
|
! 58 long number_sector_s; |
|
|
!BCC_EOS |
|
|
! 59 short entry_kind; |
|
|
!BCC_EOS |
|
|
! 60 short extra_control_bits1; |
|
|
!BCC_EOS |
|
|
! 61 short extra_control_bits2; |
|
|
!BCC_EOS |
|
|
! 62 short extra_control_bits3; |
|
|
!BCC_EOS |
|
|
! 63 long table_entry_sector_index[2]; |
|
|
!BCC_EOS |
|
|
! 64 long data_pointer[27 * 2]; |
|
|
!BCC_EOS |
|
|
! 65 }; |
|
|
!BCC_EOS |
|
|
! 66 |
|
|
! 67 struct File_Syst |
|
|
! 67 em_Control_Information |
|
|
! 68 { |
|
|
! 69 char filesystem_information[256]; |
|
|
!BCC_EOS |
|
|
! 70 long master_table_index[2]; |
|
|
!BCC_EOS |
|
|
! 71 long this_partition_offset_on_disk[2]; |
|
|
!BCC_EOS |
|
|
! 72 long next_free_sector[2]; |
|
|
!BCC_EOS |
|
|
! 73 long next_uniqe_id[2]; |
|
|
!BCC_EOS |
|
|
! 74 long next_sector_reuse_pointer[2]; |
|
|
!BCC_EOS |
|
|
! 75 long last_sector_index_on_partition[2]; |
|
|
!BCC_EOS |
|
|
! 76 long maximum_sectors_on_disk[2]; |
|
|
!BCC_EOS |
|
|
! 77 long sector_size_on_disk[2]; |
|
|
!BCC_EOS |
|
|
! 78 long not_used[48]; |
|
|
!BCC_EOS |
|
|
! 79 |
|
|
! 80 }; |
|
|
!BCC_EOS |
|
|
! 81 |
|
|
! 82 typedef struct Directory_Table |
|
|
! 83 { |
|
|
! 84 Table_Entry entries[16 ]; |
|
|
!BCC_EOS |
|
|
! 85 |
|
|
! 86 }; |
|
|
!BCC_EOS |
|
|
! 87 |
|
|
! 88 struct Parameter_Struct |
|
|
! 89 { |
|
|
! 90 char* path; |
|
|
!BCC_EOS |
|
|
! 91 char* new_path; |
|
|
!BCC_EOS |
|
|
! 92 int buffer_segment; |
|
|
!BCC_EOS |
|
|
! 93 int buffer_address; |
|
|
!BCC_EOS |
|
|
! 94 int buffer_size; |
|
|
!BCC_EOS |
|
|
! 95 int data_length; |
|
|
!BCC_EOS |
|
|
! 96 int byte_offset_into_file; |
|
|
!BCC_EOS |
|
|
! 97 Table_Entry_Kind entry_kind; |
|
|
!BCC_EOS |
|
|
! 98 }; |
|
|
!BCC_EOS |
|
|
! 99 # 7 "main.c" |
|
|
! 7 int main(selector, pointer_parameter_segment, pointer_parameter_struct) |
|
|
! 8 int selector; |
|
|
export _main |
|
|
_main: |
|
|
!BCC_EOS |
|
|
! 9 void* pointer_parameter_segment; |
|
|
!BCC_EOS |
|
|
! 10 void* pointer_parameter_struct; |
|
|
!BCC_EOS |
|
|
! 11 { |
|
|
! 12 |
|
|
! 13 |
|
|
! 14 |
|
|
! 15 FSCI fsci; |
|
|
!BCC_EOS |
|
|
! 16 |
|
|
! 17 Service_Action service_action; |
|
|
!BCC_EOS |
|
|
! 18 Directory_Table current_table; |
|
|
!BCC_EOS |
|
|
! 19 Parameter_Struct parameter_struct; |
|
|
!BCC_EOS |
|
|
! 20 int local_segment = 0x7e0; |
|
|
push bp |
|
|
mov bp,sp |
|
|
push di |
|
|
push si |
|
|
add sp,#-$2214 |
|
|
! Debug: eq int = const $7E0 to int local_segment = [S+$221A-$221A] (used reg = ) |
|
|
mov ax,#$7E0 |
|
|
mov -$2218[bp],ax |
|
|
!BCC_EOS |
|
|
! 21 unsigned int heap_start = 0x2000; |
|
|
dec sp |
|
|
dec sp |
|
|
! Debug: eq int = const $2000 to unsigned int heap_start = [S+$221C-$221C] (used reg = ) |
|
|
mov ax,#$2000 |
|
|
mov -$221A[bp],ax |
|
|
!BCC_EOS |
|
|
! 22 unsigned int heap_end = 0xffff; |
|
|
dec sp |
|
|
dec sp |
|
|
! Debug: eq unsigned int = const $FFFF to unsigned int heap_end = [S+$221E-$221E] (used reg = ) |
|
|
mov ax,#$FFFF |
|
|
mov -$221C[bp],ax |
|
|
!BCC_EOS |
|
|
! 23 int stack_segment = 0x8fc0; |
|
|
dec sp |
|
|
dec sp |
|
|
! Debug: eq unsigned int = const $8FC0 to int stack_segment = [S+$2220-$2220] (used reg = ) |
|
|
mov ax,#$8FC0 |
|
|
mov -$221E[bp],ax |
|
|
!BCC_EOS |
|
|
! 24 int path_length; |
|
|
!BCC_EOS |
|
|
! 25 long index_as_long; |
|
|
!BCC_EOS |
|
|
! 26 |
|
|
! 27 char *local_path = 0; |
|
|
add sp,*-8 |
|
|
! Debug: eq int = const 0 to * char local_path = [S+$2228-$2228] (used reg = ) |
|
|
xor ax,ax |
|
|
mov -$2226[bp],ax |
|
|
!BCC_EOS |
|
|
! 28 service_action = selector; |
|
|
! Debug: eq int selector = [S+$2228+2] to int service_action = [S+$2228-$208] (used reg = ) |
|
|
mov ax,4[bp] |
|
|
mov -$206[bp],ax |
|
|
!BCC_EOS |
|
|
! 29 |
|
|
! 30 switch (service_action) |
|
|
mov ax,-$206[bp] |
|
|
! 31 { |
|
|
br .23 |
|
|
! 32 case SERIVCE_LOAD_DISK: |
|
|
! 33 { |
|
|
.24: |
|
|
! 34 |
|
|
! 35 |
|
|
! 36 |
|
|
! 37 |
|
|
! 38 index_as_long = pointer_parameter_struct; |
|
|
! Debug: eq * void pointer_parameter_struct = [S+$2228+6] to long index_as_long = [S+$2228-$2226] (used reg = ) |
|
|
mov ax,8[bp] |
|
|
xor bx,bx |
|
|
mov -$2224[bp],ax |
|
|
mov -$2222[bp],bx |
|
|
!BCC_EOS |
|
|
! 39 disk_service_read_data_from_disk(index_as_long, 1, &fsci, stack_segment); |
|
|
! Debug: list int stack_segment = [S+$2228-$2220] (used reg = ) |
|
|
push -$221E[bp] |
|
|
! Debug: list * struct File_System_Control_Information fsci = S+$222A-$206 (used reg = ) |
|
|
lea bx,-$204[bp] |
|
|
push bx |
|
|
! Debug: list int = const 1 (used reg = ) |
|
|
mov ax,*1 |
|
|
push ax |
|
|
! Debug: list long index_as_long = [S+$222E-$2226] (used reg = ) |
|
|
push -$2222[bp] |
|
|
push -$2224[bp] |
|
|
! Debug: func () int = disk_service_read_data_from_disk+0 (used reg = ) |
|
|
call _disk_service_read_data_from_disk |
|
|
add sp,*$A |
|
|
!BCC_EOS |
|
|
! 40 print("File System has been loaded: "); |
|
|
! Debug: list * char = .25+0 (used reg = ) |
|
|
mov bx,#.25 |
|
|
push bx |
|
|
! Debug: func () void = print+0 (used reg = ) |
|
|
call _print |
|
|
inc sp |
|
|
inc sp |
|
|
!BCC_EOS |
|
|
! 41 print_newline(); |
|
|
! Debug: func () void = print_newline+0 (used reg = ) |
|
|
call _print_newline |
|
|
!BCC_EOS |
|
|
! 42 set_heap_settings(heap_start, heap_end); |
|
|
! Debug: list unsigned int heap_end = [S+$2228-$221E] (used reg = ) |
|
|
push -$221C[bp] |
|
|
! Debug: list unsigned int heap_start = [S+$222A-$221C] (used reg = ) |
|
|
push -$221A[bp] |
|
|
! Debug: func () int = set_heap_settings+0 (used reg = ) |
|
|
call _set_heap_settings |
|
|
add sp,*4 |
|
|
!BCC_EOS |
|
|
! 43 print_stack(fsci.filesystem_information); |
|
|
! Debug: list * char fsci = S+$2228-$206 (used reg = ) |
|
|
lea bx,-$204[bp] |
|
|
push bx |
|
|
! Debug: func () void = print_stack+0 (used reg = ) |
|
|
call _print_stack |
|
|
inc sp |
|
|
inc sp |
|
|
!BCC_EOS |
|
|
! 44 print_newline(); |
|
|
! Debug: func () void = print_newline+0 (used reg = ) |
|
|
call _print_newline |
|
|
!BCC_EOS |
|
|
! 45 } break; |
|
|
br .21 |
|
|
!BCC_EOS |
|
|
! 46 case SERVICE_FIND_ENTRY: |
|
|
! 47 { |
|
|
.26: |
|
|
! 48 String_Array *path_array; |
|
|
!BCC_EOS |
|
|
! 49 int i; |
|
|
!BCC_EOS |
|
|
! 50 memcpy(¶meter_struct, stack_segment, pointer_parameter_struct, pointer_parameter_segment, sizeof(Parameter_Struct)); |
|
|
! Debug: list int = const $10 (used reg = ) |
|
|
mov ax,*$10 |
|
|
push ax |
|
|
! Debug: list * void pointer_parameter_segment = [S+$222E+4] (used reg = ) |
|
|
push 6[bp] |
|
|
! Debug: list * void pointer_parameter_struct = [S+$2230+6] (used reg = ) |
|
|
push 8[bp] |
|
|
! Debug: list int stack_segment = [S+$2232-$2220] (used reg = ) |
|
|
push -$221E[bp] |
|
|
! Debug: list * struct Parameter_Struct parameter_struct = S+$2234-$2218 (used reg = ) |
|
|
lea bx,-$2216[bp] |
|
|
push bx |
|
|
! Debug: func () void = memcpy+0 (used reg = ) |
|
|
call _memcpy |
|
|
add sp,*$A |
|
|
!BCC_EOS |
|
|
! 51 path_length = strlen(parameter_struct.path, pointer_parameter_segment); |
|
|
! Debug: list * void pointer_parameter_segment = [S+$222C+4] (used reg = ) |
|
|
push 6[bp] |
|
|
! Debug: list * char parameter_struct = [S+$222E-$2218] (used reg = ) |
|
|
push -$2216[bp] |
|
|
! Debug: func () int = strlen+0 (used reg = ) |
|
|
call _strlen |
|
|
add sp,*4 |
|
|
! Debug: eq int = ax+0 to int path_length = [S+$222C-$2222] (used reg = ) |
|
|
mov -$2220[bp],ax |
|
|
!BCC_EOS |
|
|
! 52 local_path = malloc(256); |
|
|
! Debug: list int = const $100 (used reg = ) |
|
|
mov ax,#$100 |
|
|
push ax |
|
|
! Debug: func () * void = malloc+0 (used reg = ) |
|
|
call _malloc |
|
|
inc sp |
|
|
inc sp |
|
|
! Debug: eq * void = ax+0 to * char local_path = [S+$222C-$2228] (used reg = ) |
|
|
mov -$2226[bp],ax |
|
|
!BCC_EOS |
|
|
! 53 |
|
|
! 53 memcpy(local_path, local_segment, parameter_struct.path, pointer_parameter_segment, path_length); |
|
|
! Debug: list int path_length = [S+$222C-$2222] (used reg = ) |
|
|
push -$2220[bp] |
|
|
! Debug: list * void pointer_parameter_segment = [S+$222E+4] (used reg = ) |
|
|
push 6[bp] |
|
|
! Debug: list * char parameter_struct = [S+$2230-$2218] (used reg = ) |
|
|
push -$2216[bp] |
|
|
! Debug: list int local_segment = [S+$2232-$221A] (used reg = ) |
|
|
push -$2218[bp] |
|
|
! Debug: list * char local_path = [S+$2234-$2228] (used reg = ) |
|
|
push -$2226[bp] |
|
|
! Debug: func () void = memcpy+0 (used reg = ) |
|
|
call _memcpy |
|
|
add sp,*$A |
|
|
!BCC_EOS |
|
|
! 54 local_path[path_length] = 0; |
|
|
! Debug: ptradd int path_length = [S+$222C-$2222] to * char local_path = [S+$222C-$2228] (used reg = ) |
|
|
mov ax,-$2220[bp] |
|
|
add ax,-$2226[bp] |
|
|
mov bx,ax |
|
|
! Debug: eq int = const 0 to char = [bx+0] (used reg = ) |
|
|
xor al,al |
|
|
mov [bx],al |
|
|
!BCC_EOS |
|
|
! 55 print(local_path); |
|
|
! Debug: list * char local_path = [S+$222C-$2228] (used reg = ) |
|
|
push -$2226[bp] |
|
|
! Debug: func () void = print+0 (used reg = ) |
|
|
call _print |
|
|
inc sp |
|
|
inc sp |
|
|
!BCC_EOS |
|
|
! 56 |
|
|
! 57 path_array = string_split_c(local_path, '/', 0); |
|
|
! Debug: list int = const 0 (used reg = ) |
|
|
xor ax,ax |
|
|
push ax |
|
|
! Debug: list int = const $2F (used reg = ) |
|
|
mov ax,*$2F |
|
|
push ax |
|
|
! Debug: list * char local_path = [S+$2230-$2228] (used reg = ) |
|
|
push -$2226[bp] |
|
|
! Debug: func () * struct String_Array = string_split_c+0 (used reg = ) |
|
|
call _string_split_c |
|
|
add sp,*6 |
|
|
! Debug: eq * struct String_Array = ax+0 to * struct String_Array path_array = [S+$222C-$222A] (used reg = ) |
|
|
mov -$2228[bp],ax |
|
|
!BCC_EOS |
|
|
! 58 |
|
|
! 59 print_newline(); |
|
|
! Debug: func () void = print_newline+0 (used reg = ) |
|
|
call _print_newline |
|
|
!BCC_EOS |
|
|
! 60 print_newline(); |
|
|
! Debug: func () void = print_newline+0 (used reg = ) |
|
|
call _print_newline |
|
|
!BCC_EOS |
|
|
! 61 for (i = 0; i < path_array->length; ++i) |
|
|
! Debug: eq int = const 0 to int i = [S+$222C-$222C] (used reg = ) |
|
|
xor ax,ax |
|
|
mov -$222A[bp],ax |
|
|
!BCC_EOS |
|
|
!BCC_EOS |
|
|
! 62 { |
|
|
jmp .29 |
|
|
.2A: |
|
|
! 63 print(path_array->strings[i]->chars); |
|
|
mov bx,-$2228[bp] |
|
|
! Debug: ptradd int i = [S+$222C-$222C] to * * struct Length_String = [bx+2] (used reg = ) |
|
|
mov ax,-$222A[bp] |
|
|
shl ax,*1 |
|
|
add ax,2[bx] |
|
|
mov bx,ax |
|
|
mov bx,[bx] |
|
|
! Debug: list * char = [bx+4] (used reg = ) |
|
|
push 4[bx] |
|
|
! Debug: func () void = print+0 (used reg = ) |
|
|
call _print |
|
|
inc sp |
|
|
inc sp |
|
|
!BCC_EOS |
|
|
! 64 print_newline(); |
|
|
! Debug: func () void = print_newline+0 (used reg = ) |
|
|
call _print_newline |
|
|
!BCC_EOS |
|
|
! 65 } |
|
|
! 66 print_newline(); |
|
|
.28: |
|
|
! Debug: preinc int i = [S+$222C-$222C] (used reg = ) |
|
|
mov ax,-$222A[bp] |
|
|
inc ax |
|
|
mov -$222A[bp],ax |
|
|
.29: |
|
|
mov bx,-$2228[bp] |
|
|
! Debug: lt unsigned int = [bx+0] to int i = [S+$222C-$222C] (used reg = ) |
|
|
mov ax,-$222A[bp] |
|
|
cmp ax,[bx] |
|
|
jb .2A |
|
|
.2B: |
|
|
.27: |
|
|
! Debug: func () void = print_newline+0 (used reg = ) |
|
|
call _print_newline |
|
|
!BCC_EOS |
|
|
! 67 print_newline(); |
|
|
! Debug: func () void = print_newline+0 (used reg = ) |
|
|
call _print_newline |
|
|
!BCC_EOS |
|
|
! 68 |
|
|
! 69 print_newline(); |
|
|
! Debug: func () void = print_newline+0 (used reg = ) |
|
|
call _print_newline |
|
|
!BCC_EOS |
|
|
! 70 disk_service_read_data_from_disk(fsci.master_table_index[0], 16 , ¤t_table, stack_segment); |
|
|
! Debug: list int stack_segment = [S+$222C-$2220] (used reg = ) |
|
|
push -$221E[bp] |
|
|
! Debug: list * struct Directory_Table current_table = S+$222E-$2208 (used reg = ) |
|
|
lea bx,-$2206[bp] |
|
|
push bx |
|
|
! Debug: list int = const $10 (used reg = ) |
|
|
mov ax,*$10 |
|
|
push ax |
|
|
! Debug: list long fsci = [S+$2232-$106] (used reg = ) |
|
|
push -$102[bp] |
|
|
push -$104[bp] |
|
|
! Debug: func () int = disk_service_read_data_from_disk+0 (used reg = ) |
|
|
call _disk_service_read_data_from_disk |
|
|
add sp,*$A |
|
|
!BCC_EOS |
|
|
! 71 print("Current table: "); |
|
|
! Debug: list * char = .2C+0 (used reg = ) |
|
|
mov bx,#.2C |
|
|
push bx |
|
|
! Debug: func () void = print+0 (used reg = ) |
|
|
call _print |
|
|
inc sp |
|
|
inc sp |
|
|
!BCC_EOS |
|
|
! 72 print_newline(); |
|
|
! Debug: func () void = print_newline+0 (used reg = ) |
|
|
call _print_newline |
|
|
!BCC_EOS |
|
|
! 73 print_stack(current_table.entries[0].filename); |
|
|
! Debug: list * char current_table = S+$222C-$2208 (used reg = ) |
|
|
lea bx,-$2206[bp] |
|
|
push bx |
|
|
! Debug: func () void = print_stack+0 (used reg = ) |
|
|
call _print_stack |
|
|
inc sp |
|
|
inc sp |
|
|
!BCC_EOS |
|
|
! 74 print_newline(); |
|
|
! Debug: func () void = print_newline+0 (used reg = ) |
|
|
call _print_newline |
|
|
!BCC_EOS |
|
|
! 75 print_stack(current_table.entries[1].filename); |
|
|
! Debug: list * char current_table = S+$222C-$2008 (used reg = ) |
|
|
lea bx,-$2006[bp] |
|
|
push bx |
|
|
! Debug: func () void = print_stack+0 (used reg = ) |
|
|
call _print_stack |
|
|
inc sp |
|
|
inc sp |
|
|
!BCC_EOS |
|
|
! 76 print_newline(); |
|
|
! Debug: func () void = print_newline+0 (used reg = ) |
|
|
call _print_newline |
|
|
!BCC_EOS |
|
|
! 77 print_stack(current_table.entries[2].filename); |
|
|
! Debug: list * char current_table = S+$222C-$1E08 (used reg = ) |
|
|
lea bx,-$1E06[bp] |
|
|
push bx |
|
|
! Debug: func () void = print_stack+0 (used reg = ) |
|
|
call _print_stack |
|
|
inc sp |
|
|
inc sp |
|
|
!BCC_EOS |
|
|
! 78 print_newline(); |
|
|
! Debug: func () void = print_newline+0 (used reg = ) |
|
|
call _print_newline |
|
|
!BCC_EOS |
|
|
! 79 |
|
|
! 80 } break; |
|
|
jmp .21 |
|
|
!BCC_EOS |
|
|
! 81 case SERIVCE_READ_DATA: |
|
|
! 82 { |
|
|
.2D: |
|
|
! 83 # 91 |
|
|
! 91 |
|
|
! 92 print("Hit READ case"); |
|
|
! Debug: list * char = .2E+0 (used reg = ) |
|
|
mov bx,#.2E |
|
|
push bx |
|
|
! Debug: func () void = print+0 (used reg = ) |
|
|
call _print |
|
|
inc sp |
|
|
inc sp |
|
|
!BCC_EOS |
|
|
! 93 } break; |
|
|
jmp .21 |
|
|
!BCC_EOS |
|
|
! 94 case SERIVCE_WRITE_DATA: |
|
|
! 95 { |
|
|
.2F: |
|
|
! 96 print("Hit WRITE case"); |
|
|
! Debug: list * char = .30+0 (used reg = ) |
|
|
mov bx,#.30 |
|
|
push bx |
|
|
! Debug: func () void = print+0 (used reg = ) |
|
|
call _print |
|
|
inc sp |
|
|
inc sp |
|
|
!BCC_EOS |
|
|
! 97 } break; |
|
|
jmp .21 |
|
|
!BCC_EOS |
|
|
! 98 default: |
|
|
! 99 { |
|
|
.31: |
|
|
! 100 print("Default case"); |
|
|
! Debug: list * char = .32+0 (used reg = ) |
|
|
mov bx,#.32 |
|
|
push bx |
|
|
! Debug: func () void = print+0 (used reg = ) |
|
|
call _print |
|
|
inc sp |
|
|
inc sp |
|
|
!BCC_EOS |
|
|
! 101 } |
|
|
! 102 } |
|
|
! 103 |
|
|
! 104 return 0; |
|
|
jmp .21 |
|
|
.23: |
|
|
add sp,*-4 |
|
|
sub ax,*1 |
|
|
beq .24 |
|
|
sub ax,*1 |
|
|
beq .26 |
|
|
sub ax,*1 |
|
|
je .2D |
|
|
sub ax,*1 |
|
|
je .2F |
|
|
jmp .31 |
|
|
.21: |
|
|
..FFFF = -$222C |
|
|
add sp,*4 |
|
|
xor ax,ax |
|
|
lea sp,-4[bp] |
|
|
pop si |
|
|
pop di |
|
|
pop bp |
|
|
ret |
|
|
!BCC_EOS |
|
|
! 105 |
|
|
! 106 } |
|
|
! 107 |
|
|
! Register BX used in function main |
|
|
.32: |
|
|
.33: |
|
|
.ascii "Default case" |
|
|
.byte 0 |
|
|
.30: |
|
|
.34: |
|
|
.ascii "Hit WRITE case" |
|
|
.byte 0 |
|
|
.2E: |
|
|
.35: |
|
|
.ascii "Hit READ case" |
|
|
.byte 0 |
|
|
.2C: |
|
|
.36: |
|
|
.ascii "Current table: " |
|
|
.byte 0 |
|
|
.25: |
|
|
.37: |
|
|
.ascii "File System has been loaded: " |
|
|
.byte 0 |
|
|
.bss |
|
|
|
|
|
! 0 errors detected
|
|
|
|
