You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3140 lines
73 KiB
3140 lines
73 KiB
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]
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
new_print_print:
|
|
; Prints string in si
|
|
; IN si: zero terminated string to print
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
mov ah, #0xE ; Specify 'int 0x10' 'teletype output' function
|
|
; [AL = Character, BH = Page Number, BL = Colour (in graphics mode)]
|
|
.new_print_printchar:
|
|
lodsb ; Load byte at address SI into AL, and increment SI
|
|
test al, al
|
|
jz .new_print_done ; If the character is zero (NUL), stop writing the string
|
|
int #0x10 ; Otherwise, print the character via 'int 0x10'
|
|
jmp .new_print_printchar ; Repeat for the next character
|
|
.new_print_done:
|
|
|
|
pop bp
|
|
! 28 endasm
|
|
!BCC_ENDASM
|
|
! 29 }
|
|
ret
|
|
! 30
|
|
! 31
|
|
! 32 void print_stack(argument)
|
|
! 33 {
|
|
export _print_stack
|
|
_print_stack:
|
|
! 34 #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]
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
print_stack_print:
|
|
; Prints string in si
|
|
; IN si: zero terminated string to print
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
mov ah, #0xE ; Specify 'int 0x10' 'teletype output' function
|
|
; [AL = Character, BH = Page Number, BL = Colour (in graphics mode)]
|
|
.print_stack_printchar:
|
|
lodsb ; Load byte at address SI into AL, and increment SI
|
|
test al, al
|
|
jz .print_stack_done ; If the character is zero (NUL), stop writing the string
|
|
int #0x10 ; Otherwise, print the character via 'int 0x10'
|
|
jmp .print_stack_printchar ; Repeat for the next character
|
|
.print_stack_done:
|
|
|
|
pop ax
|
|
pop ds
|
|
pop bp
|
|
! 61 endasm
|
|
!BCC_ENDASM
|
|
! 62 }
|
|
ret
|
|
! 63
|
|
! 64 void* dump_ax_return(input)
|
|
! 65 void* input;
|
|
export _dump_ax_return
|
|
_dump_ax_return:
|
|
!BCC_EOS
|
|
! 66 {
|
|
! 67 return
|
|
! 67 input;
|
|
push bp
|
|
mov bp,sp
|
|
push di
|
|
push si
|
|
mov ax,4[bp]
|
|
pop si
|
|
pop di
|
|
pop bp
|
|
ret
|
|
!BCC_EOS
|
|
! 68 }
|
|
! 69
|
|
! 70 void dump_ax(input)
|
|
! 71 void* input;
|
|
export _dump_ax
|
|
_dump_ax:
|
|
!BCC_EOS
|
|
! 72 {
|
|
! 73 dump_ax_return(input)
|
|
push bp
|
|
mov bp,sp
|
|
push di
|
|
push si
|
|
! 74 #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
|
|
|
|
pusha ; save registers
|
|
mov bx, ax
|
|
mov ah, #0xE ; Teletype output
|
|
|
|
mov cx, #4 ; 4 nipples in a 16 bit word
|
|
.dump_ax_loop:
|
|
rol bx, #4 ; rotate to next nipple
|
|
mov al, bl ; we copy to al because we need to mask only the low 4 bits
|
|
and al, #%1111 ; Do the masking
|
|
add al, #48 ; convert to ASCII
|
|
cmp al, #57 ; If we are greater than 9 ascii, we add 7 to make digit 10 be represented as 'A'
|
|
jbe .dump_ax_skip ; -|-
|
|
add al, #7 ; -|-
|
|
.dump_ax_skip: ; -|-
|
|
int #0x10 ; BIOS call 'output'
|
|
loop .dump_ax_loop
|
|
|
|
popa ; restore registers
|
|
|
|
pop bp
|
|
! 98 endasm
|
|
!BCC_ENDASM
|
|
!BCC_EOS
|
|
! 99 }
|
|
pop si
|
|
pop di
|
|
pop bp
|
|
ret
|
|
! 100
|
|
! 101 void print_newline()
|
|
! 102 {
|
|
export _print_newline
|
|
_print_newline:
|
|
! 103 #asm
|
|
!BCC_ASM
|
|
|
|
printCRLF:
|
|
mov ah, #0xE
|
|
mov al, #13
|
|
int #0x10
|
|
mov al, #10
|
|
int #0x10
|
|
ret
|
|
! 111 endasm
|
|
!BCC_ENDASM
|
|
! 112 }
|
|
ret
|
|
! 113 # 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
|
|
! 53 _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 # 19 "main.h"
|
|
! 19 }
|
|
! 20 # 2 "std_singos/string.h"
|
|
! 2 typedef 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 int strcmp(source_1, source_2)
|
|
! 169 char* source_1;
|
|
export _strcmp
|
|
_strcmp:
|
|
!BCC_EOS
|
|
! 170 char* source_2;
|
|
!BCC_EOS
|
|
! 171 {
|
|
! 172 int i;
|
|
!BCC_EOS
|
|
! 173 int count;
|
|
!BCC_EOS
|
|
! 174
|
|
! 175 count = strlen(source_1, 0x7e0);
|
|
push bp
|
|
mov bp,sp
|
|
push di
|
|
push si
|
|
add sp,*-4
|
|
! Debug: list int = const $7E0 (used reg = )
|
|
mov ax,#$7E0
|
|
push ax
|
|
! Debug: list * char source_1 = [S+$C+2] (used reg = )
|
|
push 4[bp]
|
|
! Debug: func () int = strlen+0 (used reg = )
|
|
call _strlen
|
|
add sp,*4
|
|
! Debug: eq int = ax+0 to int count = [S+$A-$A] (used reg = )
|
|
mov -8[bp],ax
|
|
!BCC_EOS
|
|
! 176 if (count != strlen(source_2, 0x7e0))
|
|
! Debug: list int = const $7E0 (used reg = )
|
|
mov ax,#$7E0
|
|
push ax
|
|
! Debug: list * char source_2 = [S+$C+4] (used reg = )
|
|
push 6[bp]
|
|
! Debug: func () int = strlen+0 (used reg = )
|
|
call _strlen
|
|
add sp,*4
|
|
! Debug: ne int = ax+0 to int count = [S+$A-$A] (used reg = )
|
|
! Debug: expression subtree swapping
|
|
cmp ax,-8[bp]
|
|
je .A
|
|
.B:
|
|
! 177 {
|
|
! 178 return -1;
|
|
mov ax,*-1
|
|
add sp,*4
|
|
pop si
|
|
pop di
|
|
pop bp
|
|
ret
|
|
!BCC_EOS
|
|
! 179 }
|
|
! 180
|
|
! 181
|
|
! 182 for (i = 0; i < count; i++)
|
|
.A:
|
|
! Debug: eq int = const 0 to int i = [S+$A-8] (used reg = )
|
|
xor ax,ax
|
|
mov -6[bp],ax
|
|
!BCC_EOS
|
|
!BCC_EOS
|
|
! 183 {
|
|
jmp .E
|
|
.F:
|
|
! 184 if(source_1[i] != source_2[i])
|
|
! Debug: ptradd int i = [S+$A-8] to * char source_2 = [S+$A+4] (used reg = )
|
|
mov ax,-6[bp]
|
|
add ax,6[bp]
|
|
mov bx,ax
|
|
! Debug: ptradd int i = [S+$A-8] to * char source_1 = [S+$A+2] (used reg = bx)
|
|
mov ax,-6[bp]
|
|
add ax,4[bp]
|
|
mov si,ax
|
|
! Debug: ne char = [bx+0] to char = [si+0] (used reg = )
|
|
mov al,[si]
|
|
cmp al,[bx]
|
|
je .10
|
|
.11:
|
|
! 185 {
|
|
! 186 return -1;
|
|
mov ax,*-1
|
|
add sp,*4
|
|
pop si
|
|
pop di
|
|
pop bp
|
|
ret
|
|
!BCC_EOS
|
|
! 187 }
|
|
! 188 }
|
|
.10:
|
|
! 189
|
|
! 190 return 0;
|
|
.D:
|
|
! Debug: postinc int i = [S+$A-8] (used reg = )
|
|
mov ax,-6[bp]
|
|
inc ax
|
|
mov -6[bp],ax
|
|
.E:
|
|
! Debug: lt int count = [S+$A-$A] to int i = [S+$A-8] (used reg = )
|
|
mov ax,-6[bp]
|
|
cmp ax,-8[bp]
|
|
jl .F
|
|
.12:
|
|
.C:
|
|
xor ax,ax
|
|
add sp,*4
|
|
pop si
|
|
pop di
|
|
pop bp
|
|
ret
|
|
!BCC_EOS
|
|
! 191 # 223
|
|
! 223
|
|
! 224 }
|
|
! 225
|
|
! 226 String_Array *string_split_c(string, delim, keep_delim)
|
|
! Register BX SI used in function strcmp
|
|
! 227 char *string;
|
|
export _string_split_c
|
|
_string_split_c:
|
|
!BCC_EOS
|
|
! 228 char delim;
|
|
!BCC_EOS
|
|
! 229 short keep_delim;
|
|
!BCC_EOS
|
|
! 230 {
|
|
! 231 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
|
|
! 232 }
|
|
! 233
|
|
! 234 Length_String *make_length_string_c(cstring)
|
|
! 235 char *cstring;
|
|
export _make_length_string_c
|
|
_make_length_string_c:
|
|
!BCC_EOS
|
|
! 236 {
|
|
! 237 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
|
|
! 238 }
|
|
! 239
|
|
! 240 Length_S
|
|
! 240 tring *make_length_string(length, chars)
|
|
! 241 unsigned int length;
|
|
export _make_length_string
|
|
_make_length_string:
|
|
!BCC_EOS
|
|
! 242 char *chars;
|
|
!BCC_EOS
|
|
! 243 {
|
|
! 244
|
|
! 245 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
|
|
! 246 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
|
|
! 247 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
|
|
! 248 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
|
|
! 249
|
|
! 250 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
|
|
! 251 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
|
|
! 252 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
|
|
! 253
|
|
! 254 return legth_string;
|
|
mov ax,-6[bp]
|
|
add sp,*4
|
|
pop si
|
|
pop di
|
|
pop bp
|
|
ret
|
|
!BCC_EOS
|
|
! 255 }
|
|
! 256
|
|
! 257 String_Array *length_string_split(string, delim, keep_delim)
|
|
! Register BX SI used in function make_length_string
|
|
! 258 Length_String *string;
|
|
export _length_string_split
|
|
_length_string_split:
|
|
!BCC_EOS
|
|
! 259 char delim;
|
|
!BCC_EOS
|
|
! 260 short keep_delim;
|
|
!BCC_EOS
|
|
! 261 {
|
|
! 262 unsigned int i;
|
|
!BCC_EOS
|
|
! 263 unsigned int last;
|
|
!BCC_EOS
|
|
! 264
|
|
! 265 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
|
|
! 266 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
|
|
! 267 String_Array *result;
|
|
!BCC_EOS
|
|
! 268 int k;
|
|
!BCC_EOS
|
|
! 269
|
|
! 270 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
|
|
! 271 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
|
|
! 272 while(i < string->length) {
|
|
jmp .14
|
|
.15:
|
|
! 273 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 .16
|
|
.17:
|
|
! 274 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 .18
|
|
.19:
|
|
! 275 ++count;
|
|
! Debug: preinc unsigned int count = [S+$12-$C] (used reg = )
|
|
mov ax,-$A[bp]
|
|
inc ax
|
|
mov -$A[bp],ax
|
|
!BCC_EOS
|
|
! 276 }
|
|
! 277 last = i;
|
|
.18:
|
|
! 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
|
|
! 278 }
|
|
! 279 ++i;
|
|
.16:
|
|
! Debug: preinc unsigned int i = [S+$12-8] (used reg = )
|
|
mov ax,-6[bp]
|
|
inc ax
|
|
mov -6[bp],ax
|
|
!BCC_EOS
|
|
! 280 }
|
|
! 281 if (i > last+1) {
|
|
.14:
|
|
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 .15
|
|
.1A:
|
|
.13:
|
|
! 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 .1B
|
|
.1C:
|
|
! 282 ++count;
|
|
! Debug: preinc unsigned int count = [S+$12-$C] (used reg = )
|
|
mov ax,-$A[bp]
|
|
inc ax
|
|
mov -$A[bp],ax
|
|
!BCC_EOS
|
|
! 283 }
|
|
! 284
|
|
! 285 result = create_length_string_array(count);
|
|
.1B:
|
|
! 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
|
|
! 286
|
|
! 287 if (keep_delim)
|
|
mov ax,8[bp]
|
|
test ax,ax
|
|
je .1D
|
|
.1E:
|
|
! 288 {
|
|
! 289 k = 0;
|
|
! Debug: eq int = const 0 to int k = [S+$12-$12] (used reg = )
|
|
xor ax,ax
|
|
mov -$10[bp],ax
|
|
!BCC_EOS
|
|
! 290 }
|
|
! 291 else
|
|
! 292 {
|
|
jmp .1F
|
|
.1D:
|
|
! 293 k = 1;
|
|
! Debug: eq int = const 1 to int k = [S+$12-$12] (used reg = )
|
|
mov ax,*1
|
|
mov -$10[bp],ax
|
|
!BCC_EOS
|
|
! 294 }
|
|
! 295
|
|
! 296 i = 0;
|
|
.1F:
|
|
! Debug: eq int = const 0 to unsigned int i = [S+$12-8] (used reg = )
|
|
xor ax,ax
|
|
mov -6[bp],ax
|
|
!BCC_EOS
|
|
! 297 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
|
|
! 298 while(i < string->length) {
|
|
jmp .21
|
|
.22:
|
|
! 299 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 .23
|
|
.24:
|
|
! 300 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 .25
|
|
.26:
|
|
! 301 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
|
|
! 302 }
|
|
! 303 last = i;
|
|
.25:
|
|
! 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
|
|
! 304 }
|
|
! 305 ++i;
|
|
.23:
|
|
! Debug: preinc unsigned int i = [S+$12-8] (used reg = )
|
|
mov ax,-6[bp]
|
|
inc ax
|
|
mov -6[bp],ax
|
|
!BCC_EOS
|
|
! 306 }
|
|
! 307 if (i > last+1) {
|
|
.21:
|
|
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 .22
|
|
.27:
|
|
.20:
|
|
! 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 .28
|
|
.29:
|
|
! 308 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
|
|
! 309 }
|
|
! 310
|
|
! 311 return result;
|
|
.28:
|
|
mov ax,-$E[bp]
|
|
add sp,*$C
|
|
pop si
|
|
pop di
|
|
pop bp
|
|
ret
|
|
!BCC_EOS
|
|
! 312
|
|
! 313 }
|
|
! 314
|
|
! 315 String_Array *create_length_string_array(array_size)
|
|
! Register BX SI used in function length_string_split
|
|
! 316 int array_size;
|
|
export _create_length_string_array
|
|
_create_length_string_array:
|
|
!BCC_EOS
|
|
! 317 {
|
|
! 318 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
|
|
! 319 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
|
|
! 320 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
|
|
! 321 return result;
|
|
mov ax,-6[bp]
|
|
inc sp
|
|
inc sp
|
|
pop si
|
|
pop di
|
|
pop bp
|
|
ret
|
|
!BCC_EOS
|
|
! 322 }
|
|
! 323
|
|
! 324
|
|
! 325 Length_String *create_length_string(length, chars)
|
|
! Register BX used in function create_length_string_array
|
|
! 326 unsigned int length;
|
|
export _create_length_string
|
|
_create_length_string:
|
|
!BCC_EOS
|
|
! 327 char *chars;
|
|
!BCC_EOS
|
|
! 328 {
|
|
! 329
|
|
! 330 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
|
|
! 331 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
|
|
! 332 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
|
|
! 333 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
|
|
! 334
|
|
! 335 legth_
|
|
! 335 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
|
|
! 336 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
|
|
! 337 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
|
|
! 338
|
|
! 339 return legth_string;
|
|
mov ax,-6[bp]
|
|
add sp,*4
|
|
pop si
|
|
pop di
|
|
pop bp
|
|
ret
|
|
!BCC_EOS
|
|
! 340 # 21 "main.h"
|
|
! 21 }
|
|
! 22 # 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 unsigned int data_buffer_segment;
|
|
!BCC_EOS
|
|
! 9 {
|
|
! 10
|
|
! 11 #asm
|
|
!BCC_ASM
|
|
_disk_service_read_data_from_disk.data_buffer set $A
|
|
_disk_service_read_data_from_disk.number_sectors set 6
|
|
_disk_service_read_data_from_disk.data_buffer_segment set $C
|
|
_disk_service_read_data_from_disk.index set 2
|
|
! 12 16
|
|
|
|
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, 14[bp];
|
|
mov WORD [DAPACK.db_addr_segment], cx
|
|
mov dx, 12[bp]; ;
|
|
mov WORD [DAPACK.db_addr_offset], dx
|
|
mov si, #DAPACK ; address of
|
|
mov ah, #0x42 ; READ
|
|
mov dl, [global_disk_identifier]
|
|
int #0x13
|
|
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
|
|
|
|
! 49 endasm
|
|
!BCC_ENDASM
|
|
! 50 }
|
|
ret
|
|
! 51 # 24 "main.h"
|
|
! 24 void dump_ax(input);
|
|
!BCC_EOS
|
|
! 25 void print_stack(argument);
|
|
!BCC_EOS
|
|
! 26 void print_newline();
|
|
!BCC_EOS
|
|
! 27
|
|
! 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
|
|
! 35 typedef enum Service_Action
|
|
! 36 {
|
|
! 37 SERIVCE_LOAD_DISK = 1,
|
|
! 38 SERVICE_FIND_ENTRY = 2,
|
|
! 39 SERIVCE_READ_DATA = 3,
|
|
! 40 SERIVCE_WRITE_DATA = 4,
|
|
! 41 SERIVCE_WRITE_FS_INFO = 10,
|
|
! 42
|
|
! 43 } Service_Action;
|
|
!BCC_EOS
|
|
! 44
|
|
! 45 struct File_System_Control_Information
|
|
! 46 {
|
|
! 47 char filesystem_information[256];
|
|
!BCC_EOS
|
|
! 48 long master_table_index[2];
|
|
!BCC_EOS
|
|
! 49 long this_partition_offset_on_disk[2];
|
|
!BCC_EOS
|
|
! 50 long next_free_sector[2];
|
|
!BCC_EOS
|
|
! 51
|
|
! 51 long next_uniqe_id[2];
|
|
!BCC_EOS
|
|
! 52 long next_sector_reuse_pointer[2];
|
|
!BCC_EOS
|
|
! 53 long last_sector_index_on_partition[2];
|
|
!BCC_EOS
|
|
! 54 long maximum_sectors_on_disk[2];
|
|
!BCC_EOS
|
|
! 55 long sector_size_on_disk[2];
|
|
!BCC_EOS
|
|
! 56 long not_used[48];
|
|
!BCC_EOS
|
|
! 57
|
|
! 58 };
|
|
!BCC_EOS
|
|
! 59
|
|
! 60
|
|
! 61 struct Parameter_Struct
|
|
! 62 {
|
|
! 63 char* path;
|
|
!BCC_EOS
|
|
! 64 char* new_path;
|
|
!BCC_EOS
|
|
! 65 unsigned int buffer_segment;
|
|
!BCC_EOS
|
|
! 66 unsigned int buffer_address;
|
|
!BCC_EOS
|
|
! 67 unsigned int buffer_size;
|
|
!BCC_EOS
|
|
! 68 unsigned int data_length;
|
|
!BCC_EOS
|
|
! 69 unsigned int byte_offset_into_file;
|
|
!BCC_EOS
|
|
! 70 short entry_kind;
|
|
!BCC_EOS
|
|
! 71 };
|
|
!BCC_EOS
|
|
! 72 # 6 "implementation/lsfs.h"
|
|
! 6 typedef struct lsfs_file lsfs_file;
|
|
!BCC_EOS
|
|
! 7 typedef struct Directory_Table Directory_Table;
|
|
!BCC_EOS
|
|
! 8 typedef struct Table_Entry Table_Entry;
|
|
!BCC_EOS
|
|
! 9
|
|
! 10 int lsfs_disk_getattr(find_file, path, fsci);
|
|
!BCC_EOS
|
|
! 11 int lsfs_disk_read_data_from_file(file, buffer_size, data, offset_to_next_entry);
|
|
!BCC_EOS
|
|
! 12 Directory_Table* lsfs_find_directory(path, drop_filename, fsci);
|
|
!BCC_EOS
|
|
! 13
|
|
! 14 typedef enum Table_Entry_Kind
|
|
! 15 {
|
|
! 16
|
|
! 17 ENTRY_EMPTY = 0,
|
|
! 18 ENTRY_FILE = 1,
|
|
! 19 ENTRY_DIRECTORY = 2,
|
|
! 20 } Table_Entry_Kind;
|
|
!BCC_EOS
|
|
! 21
|
|
! 22 struct Table_Entry
|
|
! 23 {
|
|
! 24 char filename[256];
|
|
!BCC_EOS
|
|
! 25 unsigned long file_id[2];
|
|
!BCC_EOS
|
|
! 26 unsigned long file_size[2];
|
|
!BCC_EOS
|
|
! 27 void* ext_file_data_low;
|
|
!BCC_EOS
|
|
! 28 void* ext_file_data_high;
|
|
!BCC_EOS
|
|
! 29 long number_sector_s;
|
|
!BCC_EOS
|
|
! 30 short entry_kind;
|
|
!BCC_EOS
|
|
! 31 short extra_control_bits1;
|
|
!BCC_EOS
|
|
! 32 short extra_control_bits2;
|
|
!BCC_EOS
|
|
! 33 short extra_control_bits3;
|
|
!BCC_EOS
|
|
! 34 long table_entry_sector_index[2];
|
|
!BCC_EOS
|
|
! 35 long data_pointer[27 * 2];
|
|
!BCC_EOS
|
|
! 36 };
|
|
!BCC_EOS
|
|
! 37
|
|
! 38 struct lsfs_file {
|
|
! 39 unsigned long file_id[2];
|
|
!BCC_EOS
|
|
! 40 long table_entry_pointer[2];
|
|
!BCC_EOS
|
|
! 41 Table_Entry_Kind entry_kind;
|
|
!BCC_EOS
|
|
! 42 char* filename;
|
|
!BCC_EOS
|
|
! 43 long owner_id;
|
|
!BCC_EOS
|
|
! 44 unsigned long size[2];
|
|
!BCC_EOS
|
|
! 45 long creation_date[2];
|
|
!BCC_EOS
|
|
! 46 long access_time[2];
|
|
!BCC_EOS
|
|
! 47 long modification_time[2];
|
|
!BCC_EOS
|
|
! 48 long number_sector;
|
|
!BCC_EOS
|
|
! 49 long table_entry_sector_index[2];
|
|
!BCC_EOS
|
|
! 50 long data_pointer[27 * 2];
|
|
!BCC_EOS
|
|
! 51 };
|
|
!BCC_EOS
|
|
! 52
|
|
! 53 struct Directory_Table
|
|
! 54 {
|
|
! 55 Table_Entry entries[8 ];
|
|
!BCC_EOS
|
|
! 56
|
|
! 57 };
|
|
!BCC_EOS
|
|
! 58 # 75
|
|
! 75 int lsfs_disk_getattr(find_file, path, fsci)
|
|
! 76 lsfs_file* find_file;
|
|
export _lsfs_disk_getattr
|
|
_lsfs_disk_getattr:
|
|
!BCC_EOS
|
|
! 77 char *path;
|
|
!BCC_EOS
|
|
! 78 FSCI *fsci;
|
|
!BCC_EOS
|
|
! 79 {
|
|
! 80 int i;
|
|
!BCC_EOS
|
|
! 81 String_Array *split_path = string_split_c(path, '/', 0 );
|
|
push bp
|
|
mov bp,sp
|
|
push di
|
|
push si
|
|
add sp,*-4
|
|
! 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 path = [S+$E+4] (used reg = )
|
|
push 6[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 split_path = [S+$A-$A] (used reg = )
|
|
mov -8[bp],ax
|
|
!BCC_EOS
|
|
! 82 Length_String *filename = split_path->strings[split_path->length-1];
|
|
dec sp
|
|
dec sp
|
|
mov bx,-8[bp]
|
|
! Debug: sub int = const 1 to unsigned int = [bx+0] (used reg = )
|
|
mov bx,[bx]
|
|
mov si,-8[bp]
|
|
! Debug: ptradd unsigned int = bx-1 to * * struct Length_String = [si+2] (used reg = )
|
|
mov ax,bx
|
|
dec ax
|
|
shl ax,*1
|
|
add ax,2[si]
|
|
mov bx,ax
|
|
! Debug: eq * struct Length_String = [bx+0] to * struct Length_String filename = [S+$C-$C] (used reg = )
|
|
mov bx,[bx]
|
|
mov -$A[bp],bx
|
|
!BCC_EOS
|
|
! 83
|
|
! 84
|
|
! 85 Directory
|
|
! 85 _Table *dir_table = lsfs_find_directory(path, 1 , fsci);
|
|
dec sp
|
|
dec sp
|
|
! Debug: list * struct File_System_Control_Information fsci = [S+$E+6] (used reg = )
|
|
push 8[bp]
|
|
! Debug: list int = const 1 (used reg = )
|
|
mov ax,*1
|
|
push ax
|
|
! Debug: list * char path = [S+$12+4] (used reg = )
|
|
push 6[bp]
|
|
! Debug: func () * struct Directory_Table = lsfs_find_directory+0 (used reg = )
|
|
call _lsfs_find_directory
|
|
add sp,*6
|
|
! Debug: eq * struct Directory_Table = ax+0 to * struct Directory_Table dir_table = [S+$E-$E] (used reg = )
|
|
mov -$C[bp],ax
|
|
!BCC_EOS
|
|
! 86
|
|
! 87 for (i = 0; i < 8 ; 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
|
|
! 88 {
|
|
br .2C
|
|
.2D:
|
|
! 89 int j;
|
|
!BCC_EOS
|
|
! 90 # 99
|
|
! 99
|
|
! 100 if(strcmp( filename->chars, dir_table->entries[i].filename ) == 0) {
|
|
dec sp
|
|
dec sp
|
|
! Debug: ptradd int i = [S+$10-8] to [8] struct Table_Entry dir_table = [S+$10-$E] (used reg = )
|
|
mov ax,-6[bp]
|
|
mov cx,#$200
|
|
imul cx
|
|
add ax,-$C[bp]
|
|
mov bx,ax
|
|
! Debug: cast * char = const 0 to [$100] char = bx+0 (used reg = )
|
|
! Debug: list * char = bx+0 (used reg = )
|
|
push bx
|
|
mov bx,-$A[bp]
|
|
! Debug: list * char = [bx+4] (used reg = )
|
|
push 4[bx]
|
|
! Debug: func () int = strcmp+0 (used reg = )
|
|
call _strcmp
|
|
add sp,*4
|
|
! Debug: logeq int = const 0 to int = ax+0 (used reg = )
|
|
test ax,ax
|
|
bne .2E
|
|
.2F:
|
|
! 101 find_file->file_id[0] = dir_table->entries[i].file_id[0];
|
|
! Debug: ptradd int i = [S+$10-8] to [8] struct Table_Entry dir_table = [S+$10-$E] (used reg = )
|
|
mov ax,-6[bp]
|
|
mov cx,#$200
|
|
imul cx
|
|
add ax,-$C[bp]
|
|
mov bx,ax
|
|
! Debug: ptradd int = const 0 to [2] unsigned long = bx+$100 (used reg = )
|
|
! Debug: ptradd int = const 0 to [2] unsigned long find_file = [S+$10+2] (used reg = bx)
|
|
mov si,4[bp]
|
|
! Debug: eq unsigned long = [bx+$100] to unsigned long = [si+0] (used reg = )
|
|
mov ax,$100[bx]
|
|
mov bx,$102[bx]
|
|
mov [si],ax
|
|
mov 2[si],bx
|
|
!BCC_EOS
|
|
! 102 find_file->entry_kind = dir_table->entries[i].entry_kind;
|
|
! Debug: ptradd int i = [S+$10-8] to [8] struct Table_Entry dir_table = [S+$10-$E] (used reg = )
|
|
mov ax,-6[bp]
|
|
mov cx,#$200
|
|
imul cx
|
|
add ax,-$C[bp]
|
|
mov bx,ax
|
|
mov si,4[bp]
|
|
! Debug: eq short = [bx+$118] to int = [si+$10] (used reg = )
|
|
mov bx,$118[bx]
|
|
mov $10[si],bx
|
|
!BCC_EOS
|
|
! 103 find_file->table_entry_pointer[0] = i;
|
|
mov bx,4[bp]
|
|
! Debug: ptradd int = const 0 to [2] long = bx+8 (used reg = )
|
|
! Debug: eq int i = [S+$10-8] to long = [bx+8] (used reg = )
|
|
mov ax,-6[bp]
|
|
cwd
|
|
mov si,dx
|
|
mov 8[bx],ax
|
|
mov $A[bx],si
|
|
!BCC_EOS
|
|
! 104 find_file->filename = dir_table->entries[i].filename;
|
|
! Debug: ptradd int i = [S+$10-8] to [8] struct Table_Entry dir_table = [S+$10-$E] (used reg = )
|
|
mov ax,-6[bp]
|
|
mov cx,#$200
|
|
imul cx
|
|
add ax,-$C[bp]
|
|
mov bx,ax
|
|
mov si,4[bp]
|
|
! Debug: eq [$100] char = bx+0 to * char = [si+$12] (used reg = )
|
|
mov $12[si],bx
|
|
!BCC_EOS
|
|
! 105 find_file->table_entry_sector_index[0] = dir_table->entries[i].table_entry_sector_index;
|
|
! Debug: ptradd int i = [S+$10-8] to [8] struct Table_Entry dir_table = [S+$10-$E] (used reg = )
|
|
mov ax,-6[bp]
|
|
mov cx,#$200
|
|
imul cx
|
|
add ax,-$C[bp]
|
|
mov bx,ax
|
|
mov si,4[bp]
|
|
! Debug: ptradd int = const 0 to [2] long = si+$3C (used reg = bx)
|
|
! Debug: eq [2] long = bx+$120 to long = [si+$3C] (used reg = )
|
|
mov ax,bx
|
|
add ax,#$120
|
|
xor bx,bx
|
|
mov $3C[si],ax
|
|
mov $3E[si],bx
|
|
!BCC_EOS
|
|
! 106 find_file->owner_id = 1;
|
|
mov bx,4[bp]
|
|
! Debug: eq int = const 1 to long = [bx+$14] (used reg = )
|
|
mov ax,*1
|
|
xor si,si
|
|
mov $14[bx],ax
|
|
mov $16[bx],si
|
|
!BCC_EOS
|
|
! 107 find_file->size[0] = dir_table->entries[i].file_size[0];
|
|
! Debug: ptradd int i = [S+$10-8] to [8] struct Table_Entry dir_table = [S+$10-$E] (used reg = )
|
|
mov ax,-6[bp]
|
|
mov cx,#$200
|
|
imul cx
|
|
add ax,-$C[bp]
|
|
mov bx,ax
|
|
! Debug: ptradd int = const 0 to [2] unsigned long = bx+$108 (used reg = )
|
|
mov si,4[bp]
|
|
! Debug: ptradd int = const 0 to [2] unsigned long = si+$18 (used reg = bx)
|
|
! Debug: eq unsigned long = [bx+$108] to unsigned long = [si+$18] (used reg = )
|
|
mov ax,$108[bx]
|
|
mov bx,$10A[bx]
|
|
mov $18[si],ax
|
|
mov $1A[si],bx
|
|
!BCC_EOS
|
|
! 108 find_file->creation_date[0] = 0;
|
|
mov bx,4[bp]
|
|
! Debug: ptradd int = const 0 to [2] long = bx+$20 (used reg = )
|
|
! Debug: eq int = const 0 to long = [bx+$20] (used reg = )
|
|
xor ax,ax
|
|
xor si,si
|
|
mov $20[bx],ax
|
|
mov $22[bx],si
|
|
!BCC_EOS
|
|
! 109 find_file->access_time[0] = 0;
|
|
mov bx,4[bp]
|
|
! Debug: ptradd int = const 0 to [2] long = bx+$28 (used reg = )
|
|
! Debug: eq int = const 0 to long = [bx+$28] (used reg = )
|
|
xor ax,ax
|
|
xor si,si
|
|
mov $28[bx],ax
|
|
mov $2A[bx],si
|
|
!BCC_EOS
|
|
! 110 find_file->modification_time[0] = 0;
|
|
mov bx,4[bp]
|
|
! Debug: ptradd int = const 0 to [2] long = bx+$30 (used reg = )
|
|
! Debug: eq int = const 0 to long = [bx+$30] (used reg = )
|
|
xor ax,ax
|
|
xor si,si
|
|
mov $30[bx],ax
|
|
mov $32[bx],si
|
|
!BCC_EOS
|
|
! 111
|
|
! 112 for (j = 0; j < 27 ; j = j + 2)
|
|
! Debug: eq int = const 0 to int j = [S+$10-$10] (used reg = )
|
|
xor ax,ax
|
|
mov -$E[bp],ax
|
|
!BCC_EOS
|
|
!BCC_EOS
|
|
! 113 {
|
|
jmp .33
|
|
.34:
|
|
! 114 find_file->data_pointer[j] = dir_table->entries[i].data_pointer[j];
|
|
! Debug: ptradd int i = [S+$10-8] to [8] struct Table_Entry dir_table = [S+$10-$E] (used reg = )
|
|
mov ax,-6[bp]
|
|
mov cx,#$200
|
|
imul cx
|
|
add ax,-$C[bp]
|
|
mov bx,ax
|
|
! Debug: ptradd int j = [S+$10-$10] to [$36] long = bx+$128 (used reg = )
|
|
mov ax,-$E[bp]
|
|
shl ax,*1
|
|
shl ax,*1
|
|
add bx,ax
|
|
mov si,4[bp]
|
|
! Debug: ptradd int j = [S+$10-$10] to [$36] long = si+$44 (used reg = bx)
|
|
mov ax,-$E[bp]
|
|
shl ax,*1
|
|
shl ax,*1
|
|
add si,ax
|
|
! Debug: eq long = [bx+$128] to long = [si+$44] (used reg = )
|
|
mov ax,$128[bx]
|
|
mov bx,$12A[bx]
|
|
mov $44[si],ax
|
|
mov $46[si],bx
|
|
!BCC_EOS
|
|
! 115 }
|
|
! 116
|
|
! 117
|
|
! 118 find_file->number_sector = 1;
|
|
.32:
|
|
! Debug: add int = const 2 to int j = [S+$10-$10] (used reg = )
|
|
mov ax,-$E[bp]
|
|
! Debug: eq int = ax+2 to int j = [S+$10-$10] (used reg = )
|
|
inc ax
|
|
inc ax
|
|
mov -$E[bp],ax
|
|
.33:
|
|
! Debug: lt int = const $1B to int j = [S+$10-$10] (used reg = )
|
|
mov ax,-$E[bp]
|
|
cmp ax,*$1B
|
|
jl .34
|
|
.35:
|
|
.31:
|
|
mov bx,4[bp]
|
|
! Debug: eq int = const 1 to long = [bx+$38] (used reg = )
|
|
mov ax,*1
|
|
xor si,si
|
|
mov $38[bx],ax
|
|
mov $3A[bx],si
|
|
!BCC_EOS
|
|
! 119 return 1;
|
|
mov ax,*1
|
|
add sp,*$A
|
|
pop si
|
|
pop di
|
|
pop bp
|
|
ret
|
|
!BCC_EOS
|
|
! 120 }
|
|
! 121 }
|
|
.2E:
|
|
inc sp
|
|
inc sp
|
|
! 122 return 0;
|
|
.2B:
|
|
! Debug: postinc int i = [S+$E-8] (used reg = )
|
|
mov ax,-6[bp]
|
|
inc ax
|
|
mov -6[bp],ax
|
|
.2C:
|
|
! Debug: lt int = const 8 to int i = [S+$E-8] (used reg = )
|
|
mov ax,-6[bp]
|
|
cmp ax,*8
|
|
blt .2D
|
|
.36:
|
|
.2A:
|
|
xor ax,ax
|
|
add sp,*8
|
|
pop si
|
|
pop di
|
|
pop bp
|
|
ret
|
|
!BCC_EOS
|
|
! 123 }
|
|
! 124
|
|
! 125 Directory_Table* lsfs_find_directory(path, drop_filename, fsci)
|
|
! Register BX SI used in function lsfs_disk_getattr
|
|
! 126 char *path;
|
|
export _lsfs_find_directory
|
|
_lsfs_find_directory:
|
|
!BCC_EOS
|
|
! 127 short drop_filename;
|
|
!BCC_EOS
|
|
! 128 FSCI *fsci;
|
|
!BCC_EOS
|
|
! 129 {
|
|
! 130 int number_of_traversal;
|
|
!BCC_EOS
|
|
! 131 int i, j;
|
|
!BCC_EOS
|
|
! 132 String_Array *split_path;
|
|
!BCC_EOS
|
|
! 133 Directory_Table *dir_table = calloc(1, sizeof(Directory_Table));
|
|
push bp
|
|
mov bp,sp
|
|
push di
|
|
push si
|
|
add sp,*-$A
|
|
! Debug: list int = const $1000 (used reg = )
|
|
mov ax,#$1000
|
|
push ax
|
|
! Debug: list int = const 1 (used reg = )
|
|
mov ax,*1
|
|
push ax
|
|
! Debug: func () * void = calloc+0 (used reg = )
|
|
call _calloc
|
|
add sp,*4
|
|
! Debug: eq * void = ax+0 to * struct Directory_Table dir_table = [S+$10-$10] (used reg = )
|
|
mov -$E[bp],ax
|
|
!BCC_EOS
|
|
! 134
|
|
! 135 disk_service_read_data_from_disk(fsci->master_table_index[0], (long) 8 , dir_table, 0x7e0);
|
|
! Debug: list int = const $7E0 (used reg = )
|
|
mov ax,#$7E0
|
|
push ax
|
|
! Debug: list * struct Directory_Table dir_table = [S+$12-$10] (used reg = )
|
|
push -$E[bp]
|
|
! Debug: list long = const 8 (used reg = )
|
|
mov ax,*8
|
|
xor bx,bx
|
|
push bx
|
|
push ax
|
|
mov bx,8[bp]
|
|
! Debug: ptradd int = const 0 to [2] long = bx+$100 (used reg = )
|
|
! Debug: list long = [bx+$100] (used reg = )
|
|
push $102[bx]
|
|
push $100[bx]
|
|
! Debug: func () int = disk_service_read_data_from_disk+0 (used reg = )
|
|
call _disk_service_read_data_from_disk
|
|
add sp,*$C
|
|
!BCC_EOS
|
|
! 136 split_path = string_split_c(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 path = [S+$14+2] (used reg = )
|
|
push 4[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 split_path = [S+$10-$E] (used reg = )
|
|
mov -$C[bp],ax
|
|
!BCC_EOS
|
|
! 137
|
|
! 138 number_of_traversal = split_path->length;
|
|
mov bx,-$C[bp]
|
|
! Debug: eq unsigned int = [bx+0] to int number_of_traversal = [S+$10-8] (used reg = )
|
|
mov bx,[bx]
|
|
mov -6[bp],bx
|
|
!BCC_EOS
|
|
! 139
|
|
! 140
|
|
! 141 if (drop_filename)
|
|
mov ax,6[bp]
|
|
test ax,ax
|
|
je .37
|
|
.38:
|
|
! 142 {
|
|
! 143 number_of_traversal -= 1;
|
|
! Debug: subab int = const 1 to int number_of_traversal = [S+$10-8] (used reg = )
|
|
mov ax,-6[bp]
|
|
dec ax
|
|
mov -6[bp],ax
|
|
!BCC_EOS
|
|
! 144 }
|
|
! 145
|
|
! 146
|
|
! 147 for (i = 0; i < number_of_traversal; ++i)
|
|
.37:
|
|
! Debug: eq int = const 0 to int i = [S+$10-$A] (used reg = )
|
|
xor ax,ax
|
|
mov -8[bp],ax
|
|
!BCC_EOS
|
|
!BCC_EOS
|
|
! 148 {
|
|
br .3B
|
|
.3C:
|
|
! 149 for (j = 0; j < 8 ; ++j)
|
|
! Debug: eq int = const 0 to int j = [S+$10-$C] (used reg = )
|
|
xor ax,ax
|
|
mov -$A[bp],ax
|
|
!BCC_EOS
|
|
!BCC_EOS
|
|
! 150 {
|
|
jmp .3F
|
|
.40:
|
|
! 151 # 158
|
|
! 158
|
|
! 159 if (strcmp(dir_table->entries[j].filename, split_path->strings[i]->chars) == 0)
|
|
mov bx,-$C[bp]
|
|
! Debug: ptradd int i = [S+$10-$A] to * * struct Length_String = [bx+2] (used reg = )
|
|
mov ax,-8[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: ptradd int j = [S+$12-$C] to [8] struct Table_Entry dir_table = [S+$12-$10] (used reg = )
|
|
mov ax,-$A[bp]
|
|
mov cx,#$200
|
|
imul cx
|
|
add ax,-$E[bp]
|
|
mov bx,ax
|
|
! Debug: cast * char = const 0 to [$100] char = bx+0 (used reg = )
|
|
! Debug: list * char = bx+0 (used reg = )
|
|
push bx
|
|
! Debug: func () int = strcmp+0 (used reg = )
|
|
call _strcmp
|
|
add sp,*4
|
|
! Debug: logeq int = const 0 to int = ax+0 (used reg = )
|
|
test ax,ax
|
|
jne .41
|
|
.42:
|
|
! 160 {
|
|
! 161 long index_sector = dir_table->entries[j].data_pointer[0];
|
|
add sp,*-4
|
|
! Debug: ptradd int j = [S+$14-$C] to [8] struct Table_Entry dir_table = [S+$14-$10] (used reg = )
|
|
mov ax,-$A[bp]
|
|
mov cx,#$200
|
|
imul cx
|
|
add ax,-$E[bp]
|
|
mov bx,ax
|
|
! Debug: ptradd int = const 0 to [$36] long = bx+$128 (used reg = )
|
|
! Debug: eq long = [bx+$128] to long index_sector = [S+$14-$14] (used reg = )
|
|
mov ax,$128[bx]
|
|
mov bx,$12A[bx]
|
|
mov -$12[bp],ax
|
|
mov -$10[bp],bx
|
|
!BCC_EOS
|
|
! 162
|
|
! 163
|
|
! 164 disk_service_read_data_from_disk(index_sector, (long) 8 , dir_table, 0x7e0);
|
|
! Debug: list int = const $7E0 (used reg = )
|
|
mov ax,#$7E0
|
|
push ax
|
|
! Debug: list * struct Directory_Table dir_table = [S+$16-$10] (used reg = )
|
|
push -$E[bp]
|
|
! Debug: list long = const 8 (used reg = )
|
|
mov ax,*8
|
|
xor bx,bx
|
|
push bx
|
|
push ax
|
|
! Debug: list long index_sector = [S+$1C-$14] (used reg = )
|
|
push -$10[bp]
|
|
push -$12[bp]
|
|
! Debug: func () int = disk_service_read_data_from_disk+0 (used reg = )
|
|
call _disk_service_read_data_from_disk
|
|
add sp,*$C
|
|
!BCC_EOS
|
|
! 165 break;
|
|
add sp,*4
|
|
jmp .3D
|
|
!BCC_EOS
|
|
! 166 }
|
|
add sp,*4
|
|
! 167
|
|
! 167 }
|
|
.41:
|
|
! 168 }
|
|
.3E:
|
|
! Debug: preinc int j = [S+$10-$C] (used reg = )
|
|
mov ax,-$A[bp]
|
|
inc ax
|
|
mov -$A[bp],ax
|
|
.3F:
|
|
! Debug: lt int = const 8 to int j = [S+$10-$C] (used reg = )
|
|
mov ax,-$A[bp]
|
|
cmp ax,*8
|
|
jl .40
|
|
.43:
|
|
.3D:
|
|
! 169 return dir_table;
|
|
.3A:
|
|
! Debug: preinc int i = [S+$10-$A] (used reg = )
|
|
mov ax,-8[bp]
|
|
inc ax
|
|
mov -8[bp],ax
|
|
.3B:
|
|
! Debug: lt int number_of_traversal = [S+$10-8] to int i = [S+$10-$A] (used reg = )
|
|
mov ax,-8[bp]
|
|
cmp ax,-6[bp]
|
|
blt .3C
|
|
.44:
|
|
.39:
|
|
mov ax,-$E[bp]
|
|
add sp,*$A
|
|
pop si
|
|
pop di
|
|
pop bp
|
|
ret
|
|
!BCC_EOS
|
|
! 170 }
|
|
! 171
|
|
! 172 int lsfs_disk_read_data_from_file(file, buffer_size, data, offset_to_next_entry, data_segment)
|
|
! Register BX used in function lsfs_find_directory
|
|
! 173 lsfs_file *file;
|
|
export _lsfs_disk_read_data_from_file
|
|
_lsfs_disk_read_data_from_file:
|
|
!BCC_EOS
|
|
! 174 unsigned int buffer_size;
|
|
!BCC_EOS
|
|
! 175 char *data;
|
|
!BCC_EOS
|
|
! 176 long offset_to_next_entry;
|
|
!BCC_EOS
|
|
! 177 unsigned int data_segment;
|
|
!BCC_EOS
|
|
! 178 {
|
|
! 179 unsigned int integer_file_size = file->size[0];
|
|
push bp
|
|
mov bp,sp
|
|
push di
|
|
push si
|
|
dec sp
|
|
dec sp
|
|
mov bx,4[bp]
|
|
! Debug: ptradd int = const 0 to [2] unsigned long = bx+$18 (used reg = )
|
|
! Debug: eq unsigned long = [bx+$18] to unsigned int integer_file_size = [S+8-8] (used reg = )
|
|
mov bx,$18[bx]
|
|
mov -6[bp],bx
|
|
!BCC_EOS
|
|
! 180 unsigned int integer_offset = offset_to_next_entry;
|
|
dec sp
|
|
dec sp
|
|
! Debug: eq long offset_to_next_entry = [S+$A+8] to unsigned int integer_offset = [S+$A-$A] (used reg = )
|
|
mov ax,$A[bp]
|
|
mov -8[bp],ax
|
|
!BCC_EOS
|
|
! 181 unsigned int integer_datapointer = 0;
|
|
dec sp
|
|
dec sp
|
|
! Debug: eq int = const 0 to unsigned int integer_datapointer = [S+$C-$C] (used reg = )
|
|
xor ax,ax
|
|
mov -$A[bp],ax
|
|
!BCC_EOS
|
|
! 182 unsigned int data_length = integer_file_size - integer_offset;
|
|
dec sp
|
|
dec sp
|
|
! Debug: sub unsigned int integer_offset = [S+$E-$A] to unsigned int integer_file_size = [S+$E-8] (used reg = )
|
|
mov ax,-6[bp]
|
|
sub ax,-8[bp]
|
|
! Debug: eq unsigned int = ax+0 to unsigned int data_length = [S+$E-$E] (used reg = )
|
|
mov -$C[bp],ax
|
|
!BCC_EOS
|
|
! 183 unsigned int amount_read = 0;
|
|
dec sp
|
|
dec sp
|
|
! Debug: eq int = const 0 to unsigned int amount_read = [S+$10-$10] (used reg = )
|
|
xor ax,ax
|
|
mov -$E[bp],ax
|
|
!BCC_EOS
|
|
! 184 unsigned int amount_to_read = 0;
|
|
dec sp
|
|
dec sp
|
|
! Debug: eq int = const 0 to unsigned int amount_to_read = [S+$12-$12] (used reg = )
|
|
xor ax,ax
|
|
mov -$10[bp],ax
|
|
!BCC_EOS
|
|
! 185 unsigned int remaining_offset = offset_to_next_entry;
|
|
dec sp
|
|
dec sp
|
|
! Debug: eq long offset_to_next_entry = [S+$14+8] to unsigned int remaining_offset = [S+$14-$14] (used reg = )
|
|
mov ax,$A[bp]
|
|
mov -$12[bp],ax
|
|
!BCC_EOS
|
|
! 186 void *next_data;
|
|
!BCC_EOS
|
|
! 187
|
|
! 188
|
|
! 189
|
|
! 190
|
|
! 191
|
|
! 192 int data_pointer_index = 0;
|
|
add sp,*-4
|
|
! Debug: eq int = const 0 to int data_pointer_index = [S+$18-$18] (used reg = )
|
|
xor ax,ax
|
|
mov -$16[bp],ax
|
|
!BCC_EOS
|
|
! 193
|
|
! 194
|
|
! 195
|
|
! 196 if (data_length > buffer_size)
|
|
! Debug: gt unsigned int buffer_size = [S+$18+4] to unsigned int data_length = [S+$18-$E] (used reg = )
|
|
mov ax,-$C[bp]
|
|
cmp ax,6[bp]
|
|
jbe .45
|
|
.46:
|
|
! 197 {
|
|
! 198 data_length = buffer_size;
|
|
! Debug: eq unsigned int buffer_size = [S+$18+4] to unsigned int data_length = [S+$18-$E] (used reg = )
|
|
mov ax,6[bp]
|
|
mov -$C[bp],ax
|
|
!BCC_EOS
|
|
! 199 }
|
|
! 200
|
|
! 201 while(data_length > 0)
|
|
.45:
|
|
! 202 {
|
|
br .48
|
|
.49:
|
|
! 203
|
|
! 204 if (remaining_offset == 0)
|
|
! Debug: logeq int = const 0 to unsigned int remaining_offset = [S+$18-$14] (used reg = )
|
|
mov ax,-$12[bp]
|
|
test ax,ax
|
|
bne .4A
|
|
.4B:
|
|
! 205 {
|
|
! 206 char *tmp_buffer = calloc(8 , 512 );
|
|
dec sp
|
|
dec sp
|
|
! Debug: list int = const $200 (used reg = )
|
|
mov ax,#$200
|
|
push ax
|
|
! Debug: list int = const 8 (used reg = )
|
|
mov ax,*8
|
|
push ax
|
|
! Debug: func () * void = calloc+0 (used reg = )
|
|
call _calloc
|
|
add sp,*4
|
|
! Debug: eq * void = ax+0 to * char tmp_buffer = [S+$1A-$1A] (used reg = )
|
|
mov -$18[bp],ax
|
|
!BCC_EOS
|
|
! 207
|
|
! 208
|
|
! 209 if (data_length < (8 * 512 ))
|
|
! Debug: lt int = const $1000 to unsigned int data_length = [S+$1A-$E] (used reg = )
|
|
mov ax,-$C[bp]
|
|
cmp ax,#$1000
|
|
jae .4C
|
|
.4D:
|
|
! 210 {
|
|
! 211 amount_to_read = data_length;
|
|
! Debug: eq unsigned int data_length = [S+$1A-$E] to unsigned int amount_to_read = [S+$1A-$12] (used reg = )
|
|
mov ax,-$C[bp]
|
|
mov -$10[bp],ax
|
|
!BCC_EOS
|
|
! 212 }
|
|
! 213 else
|
|
! 214 {
|
|
jmp .4E
|
|
.4C:
|
|
! 215 amount_to_read = (8 * 512 );
|
|
! Debug: eq int = const $1000 to unsigned int amount_to_read = [S+$1A-$12] (used reg = )
|
|
mov ax,#$1000
|
|
mov -$10[bp],ax
|
|
!BCC_EOS
|
|
! 216 }
|
|
! 217
|
|
! 218 integer_datapointer = file->data_pointer[data_pointer_index];
|
|
.4E:
|
|
mov bx,4[bp]
|
|
! Debug: ptradd int data_pointer_index = [S+$1A-$18] to [$36] long = bx+$44 (used reg = )
|
|
mov ax,-$16[bp]
|
|
shl ax,*1
|
|
shl ax,*1
|
|
add bx,ax
|
|
! Debug: eq long = [bx+$44] to unsigned int integer_datapointer = [S+$1A-$C] (used reg = )
|
|
mov bx,$44[bx]
|
|
mov -$A[bp],bx
|
|
!BCC_EOS
|
|
! 219 if (integer_datapointer == 0)
|
|
! Debug: logeq int = const 0 to unsigned int integer_datapointer = [S+$1A-$C] (used reg = )
|
|
mov ax,-$A[bp]
|
|
test ax,ax
|
|
jne .4F
|
|
.50:
|
|
! 220 {
|
|
! 221 break;
|
|
inc sp
|
|
inc sp
|
|
br .47
|
|
!BCC_EOS
|
|
! 222 }
|
|
! 223 next_data = data + amount_read;
|
|
.4F:
|
|
! Debug: ptradd unsigned int amount_read = [S+$1A-$10] to * char data = [S+$1A+6] (used reg = )
|
|
mov ax,-$E[bp]
|
|
add ax,8[bp]
|
|
! Debug: eq * char = ax+0 to * void next_data = [S+$1A-$16] (used reg = )
|
|
mov -$14[bp],ax
|
|
!BCC_EOS
|
|
! 224 disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], (long) 8 , next_data, data_segment);
|
|
! Debug: list unsigned int data_segment = [S+$1A+$C] (used reg = )
|
|
push $E[bp]
|
|
! Debug: list * void next_data = [S+$1C-$16] (used reg = )
|
|
push -$14[bp]
|
|
! Debug: list long = const 8 (used reg = )
|
|
mov ax,*8
|
|
xor bx,bx
|
|
push bx
|
|
push ax
|
|
mov bx,4[bp]
|
|
! Debug: ptradd int data_pointer_index = [S+$22-$18] to [$36] long = bx+$44 (used reg = )
|
|
mov ax,-$16[bp]
|
|
shl ax,*1
|
|
shl ax,*1
|
|
add bx,ax
|
|
! Debug: list long = [bx+$44] (used reg = )
|
|
push $46[bx]
|
|
push $44[bx]
|
|
! Debug: func () int = disk_service_read_data_from_disk+0 (used reg = )
|
|
call _disk_service_read_data_from_disk
|
|
add sp,*$C
|
|
!BCC_EOS
|
|
! 225
|
|
! 226
|
|
! 227
|
|
! 228 data_length -= amount_to_read;
|
|
! Debug: subab unsigned int amount_to_read = [S+$1A-$12] to unsigned int data_length = [S+$1A-$E] (used reg = )
|
|
mov ax,-$C[bp]
|
|
sub ax,-$10[bp]
|
|
mov -$C[bp],ax
|
|
!BCC_EOS
|
|
! 229 amount_read += amount_to_read;
|
|
! Debug: addab unsigned int amount_to_read = [S+$1A-$12] to unsigned int amount_read = [S+$1A-$10] (used reg = )
|
|
mov ax,-$E[bp]
|
|
add ax,-$10[bp]
|
|
mov -$E[bp],ax
|
|
!BCC_EOS
|
|
! 230 data_pointer_index = data_pointer_index + 2;
|
|
! Debug: add int = const 2 to int data_pointer_index = [S+$1A-$18] (used reg = )
|
|
mov ax,-$16[bp]
|
|
! Debug: eq int = ax+2 to int data_pointer_index = [S+$1A-$18] (used reg = )
|
|
inc ax
|
|
inc ax
|
|
mov -$16[bp],ax
|
|
!BCC_EOS
|
|
! 231
|
|
! 232 }
|
|
inc sp
|
|
inc sp
|
|
! 233 else if (remaining_offset < (8 * 512 ))
|
|
br .51
|
|
.4A:
|
|
! Debug: lt int = const $1000 to unsigned int remaining_offset = [S+$18-$14] (used reg = )
|
|
mov ax,-$12[bp]
|
|
cmp ax,#$1000
|
|
bhis .52
|
|
.53:
|
|
! 234 {
|
|
! 235 char *tmp_buffer = calloc(1, (8 * 512 ));
|
|
dec sp
|
|
dec sp
|
|
! Debug: list int = const $1000 (used reg = )
|
|
mov ax,#$1000
|
|
push ax
|
|
! Debug: list int = const 1 (used reg = )
|
|
mov ax,*1
|
|
push ax
|
|
! Debug: func () * void = calloc+0 (used reg = )
|
|
call _calloc
|
|
add sp,*4
|
|
! Debug: eq * void = ax+0 to * char tmp_buffer = [S+$1A-$1A] (used reg = )
|
|
mov -$18[bp],ax
|
|
!BCC_EOS
|
|
! 236
|
|
! 237
|
|
! 238 if (data_length < ((8 * 512 ) - remaining_offset) )
|
|
! Debug: sub unsigned int remaining_offset = [S+$1A-$14] to int = const $1000 (used reg = )
|
|
mov ax,#$1000
|
|
sub ax,-$12[bp]
|
|
! Debug: lt unsigned int = ax+0 to unsigned int data_length = [S+$1A-$E] (used reg = )
|
|
cmp ax,-$C[bp]
|
|
jbe .54
|
|
.55:
|
|
! 239 {
|
|
! 240 amount_to_read = data_length;
|
|
! Debug: eq unsigned int data_length = [S+$1A-$E] to unsigned int amount_to_read = [S+$1A-$12] (used reg = )
|
|
mov ax,-$C[bp]
|
|
mov -$10[bp],ax
|
|
!BCC_EOS
|
|
! 241 }
|
|
! 242 else
|
|
! 243 {
|
|
jmp .56
|
|
.54:
|
|
! 244 amount_to_read = ((8 * 512 ) - remaining_off
|
|
! 244 set);
|
|
! Debug: sub unsigned int remaining_offset = [S+$1A-$14] to int = const $1000 (used reg = )
|
|
mov ax,#$1000
|
|
sub ax,-$12[bp]
|
|
! Debug: eq unsigned int = ax+0 to unsigned int amount_to_read = [S+$1A-$12] (used reg = )
|
|
mov -$10[bp],ax
|
|
!BCC_EOS
|
|
! 245 }
|
|
! 246
|
|
! 247 disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], (long) 8 , tmp_buffer, 0x7e0);
|
|
.56:
|
|
! Debug: list int = const $7E0 (used reg = )
|
|
mov ax,#$7E0
|
|
push ax
|
|
! Debug: list * char tmp_buffer = [S+$1C-$1A] (used reg = )
|
|
push -$18[bp]
|
|
! Debug: list long = const 8 (used reg = )
|
|
mov ax,*8
|
|
xor bx,bx
|
|
push bx
|
|
push ax
|
|
mov bx,4[bp]
|
|
! Debug: ptradd int data_pointer_index = [S+$22-$18] to [$36] long = bx+$44 (used reg = )
|
|
mov ax,-$16[bp]
|
|
shl ax,*1
|
|
shl ax,*1
|
|
add bx,ax
|
|
! Debug: list long = [bx+$44] (used reg = )
|
|
push $46[bx]
|
|
push $44[bx]
|
|
! Debug: func () int = disk_service_read_data_from_disk+0 (used reg = )
|
|
call _disk_service_read_data_from_disk
|
|
add sp,*$C
|
|
!BCC_EOS
|
|
! 248
|
|
! 249 memcpy(data, data_segment, (tmp_buffer + remaining_offset), 0x7e0, amount_to_read);
|
|
! Debug: list unsigned int amount_to_read = [S+$1A-$12] (used reg = )
|
|
push -$10[bp]
|
|
! Debug: list int = const $7E0 (used reg = )
|
|
mov ax,#$7E0
|
|
push ax
|
|
! Debug: ptradd unsigned int remaining_offset = [S+$1E-$14] to * char tmp_buffer = [S+$1E-$1A] (used reg = )
|
|
mov ax,-$12[bp]
|
|
add ax,-$18[bp]
|
|
! Debug: list * char = ax+0 (used reg = )
|
|
push ax
|
|
! Debug: list unsigned int data_segment = [S+$20+$C] (used reg = )
|
|
push $E[bp]
|
|
! Debug: list * char data = [S+$22+6] (used reg = )
|
|
push 8[bp]
|
|
! Debug: func () void = memcpy+0 (used reg = )
|
|
call _memcpy
|
|
add sp,*$A
|
|
!BCC_EOS
|
|
! 250 data_length -= amount_to_read;
|
|
! Debug: subab unsigned int amount_to_read = [S+$1A-$12] to unsigned int data_length = [S+$1A-$E] (used reg = )
|
|
mov ax,-$C[bp]
|
|
sub ax,-$10[bp]
|
|
mov -$C[bp],ax
|
|
!BCC_EOS
|
|
! 251 amount_read += amount_to_read;
|
|
! Debug: addab unsigned int amount_to_read = [S+$1A-$12] to unsigned int amount_read = [S+$1A-$10] (used reg = )
|
|
mov ax,-$E[bp]
|
|
add ax,-$10[bp]
|
|
mov -$E[bp],ax
|
|
!BCC_EOS
|
|
! 252 remaining_offset -= amount_to_read;
|
|
! Debug: subab unsigned int amount_to_read = [S+$1A-$12] to unsigned int remaining_offset = [S+$1A-$14] (used reg = )
|
|
mov ax,-$12[bp]
|
|
sub ax,-$10[bp]
|
|
mov -$12[bp],ax
|
|
!BCC_EOS
|
|
! 253
|
|
! 254 data_pointer_index = data_pointer_index + 2;
|
|
! Debug: add int = const 2 to int data_pointer_index = [S+$1A-$18] (used reg = )
|
|
mov ax,-$16[bp]
|
|
! Debug: eq int = ax+2 to int data_pointer_index = [S+$1A-$18] (used reg = )
|
|
inc ax
|
|
inc ax
|
|
mov -$16[bp],ax
|
|
!BCC_EOS
|
|
! 255
|
|
! 256 }
|
|
inc sp
|
|
inc sp
|
|
! 257 else
|
|
! 258 {
|
|
jmp .57
|
|
.52:
|
|
! 259
|
|
! 260 remaining_offset -= (8 * 512 );
|
|
! Debug: subab int = const $1000 to unsigned int remaining_offset = [S+$18-$14] (used reg = )
|
|
mov ax,-$12[bp]
|
|
add ax,#-$1000
|
|
mov -$12[bp],ax
|
|
!BCC_EOS
|
|
! 261 data_pointer_index = data_pointer_index + 2;
|
|
! Debug: add int = const 2 to int data_pointer_index = [S+$18-$18] (used reg = )
|
|
mov ax,-$16[bp]
|
|
! Debug: eq int = ax+2 to int data_pointer_index = [S+$18-$18] (used reg = )
|
|
inc ax
|
|
inc ax
|
|
mov -$16[bp],ax
|
|
!BCC_EOS
|
|
! 262 }
|
|
! 263
|
|
! 264 }
|
|
.57:
|
|
.51:
|
|
! 265 # 269
|
|
! 269
|
|
! 270 return amount_read;
|
|
.48:
|
|
! Debug: gt int = const 0 to unsigned int data_length = [S+$18-$E] (used reg = )
|
|
mov ax,-$C[bp]
|
|
test ax,ax
|
|
bne .49
|
|
.58:
|
|
.47:
|
|
mov ax,-$E[bp]
|
|
add sp,*$12
|
|
pop si
|
|
pop di
|
|
pop bp
|
|
ret
|
|
!BCC_EOS
|
|
! 271
|
|
! 272 }
|
|
! 273 # 3 "main.c"
|
|
! 3 int main(selector, pointer_parameter_segment, pointer_parameter_struct)
|
|
! Register BX used in function lsfs_disk_read_data_from_file
|
|
! 4 int selector;
|
|
export _main
|
|
_main:
|
|
!BCC_EOS
|
|
! 5 void* pointer_parameter_segment;
|
|
!BCC_EOS
|
|
! 6 void* pointer_parameter_struct;
|
|
!BCC_EOS
|
|
! 7 {
|
|
! 8
|
|
! 9
|
|
! 10
|
|
! 11
|
|
! 12 Service_Action service_action;
|
|
!BCC_EOS
|
|
! 13 Directory_Table current_table;
|
|
!BCC_EOS
|
|
! 14 Parameter_Struct parameter_struct;
|
|
!BCC_EOS
|
|
! 15 int* local_segment;
|
|
!BCC_EOS
|
|
! 16 unsigned int heap_start = 0x2200;
|
|
push bp
|
|
mov bp,sp
|
|
push di
|
|
push si
|
|
add sp,#-$1016
|
|
! Debug: eq int = const $2200 to unsigned int heap_start = [S+$101C-$101C] (used reg = )
|
|
mov ax,#$2200
|
|
mov -$101A[bp],ax
|
|
!BCC_EOS
|
|
! 17 unsigned int heap_end = 0xffff;
|
|
dec sp
|
|
dec sp
|
|
! Debug: eq unsigned int = const $FFFF to unsigned int heap_end = [S+$101E-$101E] (used reg = )
|
|
mov ax,#$FFFF
|
|
mov -$101C[bp],ax
|
|
!BCC_EOS
|
|
! 18 int stack_segment = 0x8fc0;
|
|
dec sp
|
|
dec sp
|
|
! Debug: eq unsigned int = const $8FC0 to int stack_segment = [S+$1020-$1020] (used reg = )
|
|
mov ax,#$8FC0
|
|
mov -$101E[bp],ax
|
|
!BCC_EOS
|
|
! 19 int path_length;
|
|
!BCC_EOS
|
|
! 20 long index_as_long = 0;
|
|
add sp,*-6
|
|
! Debug: eq int = const 0 to long index_as_long = [S+$1026-$1026] (used reg = )
|
|
xor ax,ax
|
|
xor bx,bx
|
|
mov -$1024[bp],ax
|
|
mov -$1022[bp],bx
|
|
!BCC_EOS
|
|
! 21
|
|
! 22 char *local_path = 0;
|
|
dec sp
|
|
dec sp
|
|
! Debug: eq int = const 0 to * char local_path = [S+$1028-$1028] (used reg = )
|
|
xor ax,ax
|
|
mov -$1026[bp],ax
|
|
!BCC_EOS
|
|
! 23 FSCI *fsci = global_heap_start - 0x200;
|
|
dec sp
|
|
dec sp
|
|
! Debug: sub int = const $200 to unsigned int = [global_heap_start+0] (used reg = )
|
|
mov ax,[_global_heap_start]
|
|
! Debug: eq unsigned int = ax-$200 to * struct File_System_Control_Information fsci = [S+$102A-$102A] (used reg = )
|
|
add ax,#-$200
|
|
mov -$1028[bp],ax
|
|
!BCC_EOS
|
|
! 24 service_action = selector;
|
|
! Debug: eq int selector = [S+$102A+2] to int service_action = [S+$102A-8] (used reg = )
|
|
mov ax,4[bp]
|
|
mov -6[bp],ax
|
|
!BCC_EOS
|
|
! 25
|
|
! 26 switch (service_action)
|
|
mov ax,-6[bp]
|
|
! 27 {
|
|
br .5B
|
|
! 28 case SERIVCE_LOAD_DISK:
|
|
! 29 {
|
|
.5C:
|
|
! 30
|
|
! 31
|
|
! 32
|
|
! 33
|
|
! 34 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+$102C+4] (used reg = )
|
|
push 6[bp]
|
|
! Debug: list * void pointer_parameter_struct = [S+$102E+6] (used reg = )
|
|
push 8[bp]
|
|
! Debug: list int stack_segment = [S+$1030-$1020] (used reg = )
|
|
push -$101E[bp]
|
|
! Debug: list * struct Parameter_Struct parameter_struct = S+$1032-$1018 (used reg = )
|
|
lea bx,-$1016[bp]
|
|
push bx
|
|
! Debug: func () void = memcpy+0 (used reg = )
|
|
call _memcpy
|
|
add sp,*$A
|
|
!BCC_EOS
|
|
! 35
|
|
! 36 local_segment = parameter_struct.buffer_segment;
|
|
! Debug: eq unsigned int parameter_struct = [S+$102A-$1014] to * int local_segment = [S+$102A-$101A] (used reg = )
|
|
mov bx,-$1012[bp]
|
|
mov -$1018[bp],bx
|
|
!BCC_EOS
|
|
! 37 heap_start = parameter_struct.buffer_address + 0x200;
|
|
! Debug: add int = const $200 to unsigned int parameter_struct = [S+$102A-$1012] (used reg = )
|
|
mov ax,-$1010[bp]
|
|
! Debug: eq unsigned int = ax+$200 to unsigned int heap_start = [S+$102A-$101C] (used reg = )
|
|
add ax,#$200
|
|
mov -$101A[bp],ax
|
|
!BCC_EOS
|
|
! 38 heap_end = parameter_struct.buffer_size;
|
|
! Debug: eq unsigned int parameter_struct = [S+$102A-$1010] to unsigned int heap_end = [S+$102A-$101E] (used reg = )
|
|
mov ax,-$100E[bp]
|
|
mov -$101C[bp],ax
|
|
!BCC_EOS
|
|
! 39 index_as_long = parameter_struct.data_length;
|
|
! Debug: eq unsigned int parameter_struct = [S+$102A-$100E] to long index_as_long = [S+$102A-$1026] (used reg = )
|
|
mov ax,-$100C[bp]
|
|
xor bx,bx
|
|
mov -$1024[bp],ax
|
|
mov -$1022[bp],bx
|
|
!BCC_EOS
|
|
! 40 set_heap_settings(heap_start, heap_end);
|
|
! Debug: list unsigned int heap_end = [S+$102A-$101E] (used reg = )
|
|
push -$101C[bp]
|
|
! Debug: list unsigned int heap_start = [S+$102C-$101C] (used reg = )
|
|
push -$101A[bp]
|
|
! Debug: func () int = set_heap_settings+0 (used reg = )
|
|
call _set_heap_settings
|
|
add sp,*4
|
|
!BCC_EOS
|
|
! 41 fsci = global_heap_start - 0x200;
|
|
! Debug: sub int = const $200 to unsigned int = [global_heap_start+0] (used reg = )
|
|
mov ax,[_global_heap_start]
|
|
! Debug: eq unsigned int = ax-$200 to * struct File_System_Control_Information fsci = [S+$102A-$102A] (used reg = )
|
|
add ax,#-$200
|
|
mov -$1028[bp],ax
|
|
!BCC_EOS
|
|
! 42 disk_service_read_data_from_disk(index_as_long, (long) 1, fsci, local_segment);
|
|
! Debug: list * int local_segment = [S+$102A-$101A] (used reg = )
|
|
push -$1018[bp]
|
|
! Debug: list * struct File_System_Control_Information fsci = [S+$102C-$102A] (used reg = )
|
|
push -$1028[bp]
|
|
! Debug: list long = const 1 (used reg = )
|
|
mov ax,*1
|
|
xor bx,bx
|
|
push bx
|
|
push ax
|
|
! Debug: list long index_as_long = [S+$1032-$1026] (used reg = )
|
|
push -$1022[bp]
|
|
push -$1024[bp]
|
|
! Debug: func () int = disk_service_read_data_from_disk+0 (used reg = )
|
|
call _disk_service_read_data_from_disk
|
|
add sp,*$C
|
|
!BCC_EOS
|
|
! 43 print("File System has been loaded: ");
|
|
! Debug: list * char = .5D+0 (used reg = )
|
|
mov bx,#.5D
|
|
push bx
|
|
! Debug: func () void = print+0 (used reg = )
|
|
call _print
|
|
inc sp
|
|
inc sp
|
|
!BCC_EOS
|
|
! 44 print_newline();
|
|
! Debug: func () void = print_newline+0 (used reg = )
|
|
call _print_newline
|
|
!BCC_EOS
|
|
! 45 print(fsci->filesystem_information);
|
|
! Debug: cast * char = const 0 to [$100] char fsci = [S+$102A-$102A] (used reg = )
|
|
! Debug: list * char fsci = [S+$102A-$102A] (used reg = )
|
|
push -$1028[bp]
|
|
! Debug: func () void = print+0 (used reg = )
|
|
call _print
|
|
inc sp
|
|
inc sp
|
|
!BCC_EOS
|
|
! 46 p
|
|
! 46 rint("16-bit implementation v0.2.1");
|
|
! Debug: list * char = .5E+0 (used reg = )
|
|
mov bx,#.5E
|
|
push bx
|
|
! Debug: func () void = print+0 (used reg = )
|
|
call _print
|
|
inc sp
|
|
inc sp
|
|
!BCC_EOS
|
|
! 47 print_newline();
|
|
! Debug: func () void = print_newline+0 (used reg = )
|
|
call _print_newline
|
|
!BCC_EOS
|
|
! 48 } break;
|
|
br .59
|
|
!BCC_EOS
|
|
! 49 case SERVICE_FIND_ENTRY:
|
|
! 50 {
|
|
.5F:
|
|
! 51 String_Array *path_array;
|
|
!BCC_EOS
|
|
! 52 lsfs_file* find_file;
|
|
!BCC_EOS
|
|
! 53 int i;
|
|
!BCC_EOS
|
|
! 54 disk_service_read_data_from_disk(fsci->master_table_index[0], (long) 8 , ¤t_table, stack_segment);
|
|
! Debug: list int stack_segment = [S+$1030-$1020] (used reg = )
|
|
push -$101E[bp]
|
|
! Debug: list * struct Directory_Table current_table = S+$1032-$1008 (used reg = )
|
|
lea bx,-$1006[bp]
|
|
push bx
|
|
! Debug: list long = const 8 (used reg = )
|
|
mov ax,*8
|
|
xor bx,bx
|
|
push bx
|
|
push ax
|
|
mov bx,-$1028[bp]
|
|
! Debug: ptradd int = const 0 to [2] long = bx+$100 (used reg = )
|
|
! Debug: list long = [bx+$100] (used reg = )
|
|
push $102[bx]
|
|
push $100[bx]
|
|
! Debug: func () int = disk_service_read_data_from_disk+0 (used reg = )
|
|
call _disk_service_read_data_from_disk
|
|
add sp,*$C
|
|
!BCC_EOS
|
|
! 55 # 64
|
|
! 64
|
|
! 65
|
|
! 66 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+$1032+4] (used reg = )
|
|
push 6[bp]
|
|
! Debug: list * void pointer_parameter_struct = [S+$1034+6] (used reg = )
|
|
push 8[bp]
|
|
! Debug: list int stack_segment = [S+$1036-$1020] (used reg = )
|
|
push -$101E[bp]
|
|
! Debug: list * struct Parameter_Struct parameter_struct = S+$1038-$1018 (used reg = )
|
|
lea bx,-$1016[bp]
|
|
push bx
|
|
! Debug: func () void = memcpy+0 (used reg = )
|
|
call _memcpy
|
|
add sp,*$A
|
|
!BCC_EOS
|
|
! 67 path_length = strlen(parameter_struct.path, pointer_parameter_segment);
|
|
! Debug: list * void pointer_parameter_segment = [S+$1030+4] (used reg = )
|
|
push 6[bp]
|
|
! Debug: list * char parameter_struct = [S+$1032-$1018] (used reg = )
|
|
push -$1016[bp]
|
|
! Debug: func () int = strlen+0 (used reg = )
|
|
call _strlen
|
|
add sp,*4
|
|
! Debug: eq int = ax+0 to int path_length = [S+$1030-$1022] (used reg = )
|
|
mov -$1020[bp],ax
|
|
!BCC_EOS
|
|
! 68 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+$1030-$1028] (used reg = )
|
|
mov -$1026[bp],ax
|
|
!BCC_EOS
|
|
! 69 memcpy(local_path, local_segment, parameter_struct.path, pointer_parameter_segment, path_length);
|
|
! Debug: list int path_length = [S+$1030-$1022] (used reg = )
|
|
push -$1020[bp]
|
|
! Debug: list * void pointer_parameter_segment = [S+$1032+4] (used reg = )
|
|
push 6[bp]
|
|
! Debug: list * char parameter_struct = [S+$1034-$1018] (used reg = )
|
|
push -$1016[bp]
|
|
! Debug: list * int local_segment = [S+$1036-$101A] (used reg = )
|
|
push -$1018[bp]
|
|
! Debug: list * char local_path = [S+$1038-$1028] (used reg = )
|
|
push -$1026[bp]
|
|
! Debug: func () void = memcpy+0 (used reg = )
|
|
call _memcpy
|
|
add sp,*$A
|
|
!BCC_EOS
|
|
! 70 local_path[path_length] = 0;
|
|
! Debug: ptradd int path_length = [S+$1030-$1022] to * char local_path = [S+$1030-$1028] (used reg = )
|
|
mov ax,-$1020[bp]
|
|
add ax,-$1026[bp]
|
|
mov bx,ax
|
|
! Debug: eq int = const 0 to char = [bx+0] (used reg = )
|
|
xor al,al
|
|
mov [bx],al
|
|
!BCC_EOS
|
|
! 71 print("Read file: ");
|
|
! Debug: list * char = .60+0 (used reg = )
|
|
mov bx,#.60
|
|
push bx
|
|
! Debug: func () void = print+0 (used reg = )
|
|
call _print
|
|
inc sp
|
|
inc sp
|
|
!BCC_EOS
|
|
! 72 print(local_path);
|
|
! Debug: list * char local_path = [S+$1030-$1028] (used reg = )
|
|
push -$1026[bp]
|
|
! Debug: func () void = print+0 (used reg = )
|
|
call _print
|
|
inc sp
|
|
inc sp
|
|
!BCC_EOS
|
|
! 73 print_newline();
|
|
! Debug: func () void = print_newline+0 (used reg = )
|
|
call _print_newline
|
|
!BCC_EOS
|
|
! 74
|
|
! 75 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+$1034-$1028] (used reg = )
|
|
push -$1026[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+$1030-$102C] (used reg = )
|
|
mov -$102A[bp],ax
|
|
!BCC_EOS
|
|
! 76
|
|
! 77 find_file = calloc(sizeof(lsfs_file), 1);
|
|
! Debug: list int = const 1 (used reg = )
|
|
mov ax,*1
|
|
push ax
|
|
! Debug: list int = const $11C (used reg = )
|
|
mov ax,#$11C
|
|
push ax
|
|
! Debug: func () * void = calloc+0 (used reg = )
|
|
call _calloc
|
|
add sp,*4
|
|
! Debug: eq * void = ax+0 to * struct lsfs_file find_file = [S+$1030-$102E] (used reg = )
|
|
mov -$102C[bp],ax
|
|
!BCC_EOS
|
|
! 78 if ( !lsfs_disk_getattr(find_file, local_path, fsci) )
|
|
! Debug: list * struct File_System_Control_Information fsci = [S+$1030-$102A] (used reg = )
|
|
push -$1028[bp]
|
|
! Debug: list * char local_path = [S+$1032-$1028] (used reg = )
|
|
push -$1026[bp]
|
|
! Debug: list * struct lsfs_file find_file = [S+$1034-$102E] (used reg = )
|
|
push -$102C[bp]
|
|
! Debug: func () int = lsfs_disk_getattr+0 (used reg = )
|
|
call _lsfs_disk_getattr
|
|
add sp,*6
|
|
test ax,ax
|
|
jne .61
|
|
.62:
|
|
! 79 {
|
|
! 80 print("File not found");
|
|
! Debug: list * char = .63+0 (used reg = )
|
|
mov bx,#.63
|
|
push bx
|
|
! Debug: func () void = print+0 (used reg = )
|
|
call _print
|
|
inc sp
|
|
inc sp
|
|
!BCC_EOS
|
|
! 81 print_newline();
|
|
! Debug: func () void = print_newline+0 (used reg = )
|
|
call _print_newline
|
|
!BCC_EOS
|
|
! 82 }
|
|
! 83 else
|
|
! 84 {
|
|
jmp .64
|
|
.61:
|
|
! 85 print("File has been read");
|
|
! Debug: list * char = .65+0 (used reg = )
|
|
mov bx,#.65
|
|
push bx
|
|
! Debug: func () void = print+0 (used reg = )
|
|
call _print
|
|
inc sp
|
|
inc sp
|
|
!BCC_EOS
|
|
! 86 print_newline();
|
|
! Debug: func () void = print_newline+0 (used reg = )
|
|
call _print_newline
|
|
!BCC_EOS
|
|
! 87 }
|
|
! 88 # 95
|
|
! 95
|
|
! 96 lsfs_disk_read_data_from_file(find_file, parameter_struct.buffer_size, parameter_struct.buffer_address, (long) 0x0, parameter_struct.buffer_segment);
|
|
.64:
|
|
! Debug: list unsigned int parameter_struct = [S+$1030-$1014] (used reg = )
|
|
push -$1012[bp]
|
|
! Debug: list long = const 0 (used reg = )
|
|
xor ax,ax
|
|
xor bx,bx
|
|
push bx
|
|
push ax
|
|
! Debug: list unsigned int parameter_struct = [S+$1036-$1012] (used reg = )
|
|
push -$1010[bp]
|
|
! Debug: list unsigned int parameter_struct = [S+$1038-$1010] (used reg = )
|
|
push -$100E[bp]
|
|
! Debug: list * struct lsfs_file find_file = [S+$103A-$102E] (used reg = )
|
|
push -$102C[bp]
|
|
! Debug: func () int = lsfs_disk_read_data_from_file+0 (used reg = )
|
|
call _lsfs_disk_read_data_from_file
|
|
add sp,*$C
|
|
!BCC_EOS
|
|
! 97
|
|
! 98
|
|
! 99 } break;
|
|
jmp .59
|
|
!BCC_EOS
|
|
! 100 case SERIVCE_READ_DATA:
|
|
! 101 {
|
|
.66:
|
|
! 102 # 110
|
|
! 110
|
|
! 111 print("Hit READ case");
|
|
! Debug: list * char = .67+0 (used reg = )
|
|
mov bx,#.67
|
|
push bx
|
|
! Debug: func () void = print+0 (used reg = )
|
|
call _print
|
|
inc sp
|
|
inc sp
|
|
!BCC_EOS
|
|
! 112 } break;
|
|
jmp .59
|
|
!BCC_EOS
|
|
! 113 case SERIVCE_WRITE_DATA:
|
|
! 114 {
|
|
.68:
|
|
! 115 print("Hit WRITE case");
|
|
! Debug: list * char = .69+0 (used reg = )
|
|
mov bx,#.69
|
|
push bx
|
|
! Debug: func () void = print+0 (used reg = )
|
|
call _print
|
|
inc sp
|
|
inc sp
|
|
!BCC_EOS
|
|
! 116 } break;
|
|
jmp .59
|
|
!BCC_EOS
|
|
! 117 case SERIVCE_WRITE_FS_INFO:
|
|
! 118 {
|
|
.6A:
|
|
! 119
|
|
! 120 print(fsci->filesystem_information);
|
|
! Debug: cast * char = const 0 to [$100] char fsci = [S+$102A-$102A] (used reg = )
|
|
! Debug: list * char fsci = [S+$102A-$102A] (used reg = )
|
|
push -$1028[bp]
|
|
! Debug: func () void = print+0 (used reg = )
|
|
call _print
|
|
inc sp
|
|
inc sp
|
|
!BCC_EOS
|
|
! 121
|
|
! 122 } break;
|
|
jmp .59
|
|
!BCC_EOS
|
|
! 123
|
|
! 124 default:
|
|
! 125 {
|
|
.6B:
|
|
! 126 print("Default case: ");
|
|
! Debug: list * char = .6C+0 (used reg = )
|
|
mov bx,#.6C
|
|
push bx
|
|
! Debug: func () void = print+0 (used reg = )
|
|
call _print
|
|
inc sp
|
|
inc sp
|
|
!BCC_EOS
|
|
! 127 dump_ax(service_action);
|
|
! Debug: list int service_action = [S+$102A-8] (used reg = )
|
|
push -6[bp]
|
|
! Debug: func () void = dump_ax+0 (used reg = )
|
|
call _dump_ax
|
|
inc sp
|
|
inc sp
|
|
!BCC_EOS
|
|
! 128 }
|
|
! 129 }
|
|
! 130
|
|
! 131 return 0;
|
|
jmp .59
|
|
.5B:
|
|
add sp,*-6
|
|
sub ax,*1
|
|
beq .5C
|
|
sub ax,*1
|
|
beq .5F
|
|
sub ax,*1
|
|
je .66
|
|
sub ax,*1
|
|
je .68
|
|
sub ax,*6
|
|
je .6A
|
|
jmp .6B
|
|
.59:
|
|
..FFFF = -$1030
|
|
add sp,*6
|
|
xor ax,ax
|
|
lea sp,-4[bp]
|
|
pop si
|
|
pop di
|
|
pop bp
|
|
ret
|
|
!BCC_EOS
|
|
! 132
|
|
! 133 }
|
|
! 134
|
|
! Register BX used in function main
|
|
.6C:
|
|
.6D:
|
|
.ascii "Default case: "
|
|
.byte 0
|
|
.69:
|
|
.6E:
|
|
.ascii "Hit WRITE case"
|
|
.byte 0
|
|
.67:
|
|
.6F:
|
|
.ascii "Hit READ case"
|
|
.byte 0
|
|
.65:
|
|
.70:
|
|
.ascii "File has been read"
|
|
.byte 0
|
|
.63:
|
|
.71:
|
|
.ascii "File not found"
|
|
.byte 0
|
|
.60:
|
|
.72:
|
|
.ascii "Read file: "
|
|
.byte 0
|
|
.5E:
|
|
.73:
|
|
.ascii "16-bit implementation v0.2.1"
|
|
.byte 0
|
|
.5D:
|
|
.74:
|
|
.ascii "File System has been loaded: "
|
|
.byte 0
|
|
.bss
|
|
|
|
! 0 errors detected
|