! 1
|
|
! 1 # 1 "implementation/lsfs.c"
|
|
! 1 # 4 "implementation/lsfs.h"
|
|
! 4 typedef struct lsfs_file lsfs_file;
|
|
!BCC_EOS
|
|
! 5 # 1 "implementation/../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 "implementation/../std_singos/stdlib.h"
|
|
! 1 unsigned int global_heap_start = 0;
|
|
.data
|
|
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 re
|
|
! 55 turn 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 "implementation/../main.h"
|
|
! 16 }
|
|
! 17 # 2 "implementation/../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 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] = '\0';
|
|
! 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
|
|
! 196 ;
|
|
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 unsigned 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] = '\0';
|
|
! 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 "implementation/../main.h"
|
|
! 18 }
|
|
! 19 # 1 "implementation/../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_
|
|
! 4 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 # 22 "implementation/../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_contro
|
|
! 61 l_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_System_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 # 4 "implementation/lsfs.c"
|
|
! 4 struct lsfs_file {
|
|
! 5 long file_id[2];
|
|
!BCC_EOS
|
|
! 6 long table_entry_pointer[2];
|
|
!BCC_EOS
|
|
! 7 Table_Entry_Kind entry_kind;
|
|
!BCC_EOS
|
|
! 8 char* filename;
|
|
!BCC_EOS
|
|
! 9 long owner_id;
|
|
!BCC_EOS
|
|
! 10 long size[2];
|
|
!BCC_EOS
|
|
! 11 long creation_date[2];
|
|
!BCC_EOS
|
|
! 12 long access_time[2];
|
|
!BCC_EOS
|
|
! 13 long modification_time[2];
|
|
!BCC_EOS
|
|
! 14 long number_sector;
|
|
!BCC_EOS
|
|
! 15 long table_entry_sector_index[2];
|
|
!BCC_EOS
|
|
! 16 long data_pointer[27 * 2];
|
|
!BCC_EOS
|
|
! 17 };
|
|
!BCC_EOS
|
|
! 18
|
|
! 19 int lsfs_disk_read_data_from_file(file, buffer_size, data, offset_to_next_entry)
|
|
! 20 lsfs_file *file;
|
|
export _lsfs_disk_read_data_from_file
|
|
_lsfs_disk_read_data_from_file:
|
|
!BCC_EOS
|
|
! 21 int buffer_size;
|
|
!BCC_EOS
|
|
! 22 char *data;
|
|
!BCC_EOS
|
|
! 23 long offset_to_next_entry;
|
|
!BCC_EOS
|
|
! 24 {
|
|
! 25 int integer_file_size = file->size;
|
|
push bp
|
|
mov bp,sp
|
|
push di
|
|
push si
|
|
dec sp
|
|
dec sp
|
|
mov bx,4[bp]
|
|
! Debug: eq [2] long = bx+$18 to int integer_file_size = [S+8-8] (used reg = )
|
|
add bx,*$18
|
|
mov -6[bp],bx
|
|
!BCC_EOS
|
|
! 26 int integer_offset = offset_to_next_entry;
|
|
dec sp
|
|
dec sp
|
|
! Debug: eq long offset_to_next_entry = [S+$A+8] to int integer_offset = [S+$A-$A] (used reg = )
|
|
mov ax,$A[bp]
|
|
mov -8[bp],ax
|
|
!BCC_EOS
|
|
! 27 int integer_datapointer = 0;
|
|
dec sp
|
|
dec sp
|
|
! Debug: eq int = const 0 to int integer_datapointer = [S+$C-$C] (used reg = )
|
|
xor ax,ax
|
|
mov -$A[bp],ax
|
|
!BCC_EOS
|
|
! 28 int data_length = integer_file_size - integer_offset;
|
|
dec sp
|
|
dec sp
|
|
! Debug: sub int integer_offset = [S+$E-$A] to int integer_file_size = [S+$E-8] (used reg = )
|
|
mov ax,-6[bp]
|
|
sub ax,-8[bp]
|
|
! Debug: eq int = ax+0 to int data_length = [S+$E-$E] (used reg = )
|
|
mov -$C[bp],ax
|
|
!BCC_EOS
|
|
! 29 int amount_read = 0;
|
|
dec sp
|
|
dec sp
|
|
! Debug: eq int = const 0 to int amount_read = [S+$10-$10] (used reg = )
|
|
xor ax,ax
|
|
mov -$E[bp],ax
|
|
!BCC_EOS
|
|
! 30 int amount_to_read = 0;
|
|
dec sp
|
|
dec sp
|
|
! Debug: eq int = const 0 to int amount_to_read = [S+$12-$12] (used reg = )
|
|
xor ax,ax
|
|
mov -$10[bp],ax
|
|
!BCC_EOS
|
|
! 31 int remaining_offset = offset_to_next_entry;
|
|
dec sp
|
|
dec sp
|
|
! Debug: eq long offset_to_next_entry = [S+$14+8] to int remaining_offset = [S+$14-$14] (used reg = )
|
|
mov ax,$A[bp]
|
|
mov -$12[bp],ax
|
|
!BCC_EOS
|
|
! 32
|
|
! 33
|
|
! 34
|
|
! 35
|
|
! 36
|
|
! 37 int data_pointer_index = 0;
|
|
dec sp
|
|
dec sp
|
|
! Debug: eq int = const 0 to int data_pointer_index = [S+$16-$16] (used reg = )
|
|
xor ax,ax
|
|
mov -$14[bp],ax
|
|
!BCC_EOS
|
|
! 38
|
|
! 39 if (data_length > buffer_size)
|
|
! Debug: gt int buffer_size = [S+$16+4] to int data_length = [S+$16-$E] (used reg = )
|
|
mov ax,-$C[bp]
|
|
cmp ax,6[bp]
|
|
jle .21
|
|
.22:
|
|
! 40 {
|
|
! 41 data_length = buffer_size;
|
|
! Debug: eq int buffer_size = [S+$16+4] to int data_length = [S+$16-$E] (used reg = )
|
|
mov ax,6[bp]
|
|
mov -$C[bp],ax
|
|
!BCC_EOS
|
|
! 42 }
|
|
! 43
|
|
! 44 while(data_length > 0)
|
|
.21:
|
|
! 45 {
|
|
br .24
|
|
.25:
|
|
! 46
|
|
! 47 if (remaining_offset == 0)
|
|
! Debug: logeq int = const 0 to int remaining_offset = [S+$16-$14] (used reg = )
|
|
mov ax,-$12[bp]
|
|
test ax,ax
|
|
bne .26
|
|
.27:
|
|
! 48 {
|
|
! 49 char *tmp_buffer = calloc(4 , 512 );
|
|
dec sp
|
|
dec sp
|
|
! Debug: list int = const $200 (used reg = )
|
|
mov ax,#$200
|
|
push ax
|
|
! Debug: list int = const 4 (used reg = )
|
|
mov ax,*4
|
|
push ax
|
|
! Debug: func () * void = calloc+0 (used reg = )
|
|
call _calloc
|
|
add sp,*4
|
|
! Debug: eq * void = ax+0 to * char tmp_buffer = [S+$18-$18] (used reg = )
|
|
mov -$16[bp],ax
|
|
!BCC_EOS
|
|
! 50
|
|
! 51
|
|
! 52 if (data_length < (4 * 512 ))
|
|
! Debug: lt int = const $800 to int data_length = [S+$18-$E] (used reg = )
|
|
mov ax,-$C[bp]
|
|
cmp ax,#$800
|
|
jge .28
|
|
.29:
|
|
! 53 {
|
|
! 54 amount_to_read = data_length;
|
|
! Debug: eq int data_length = [S+$18-$E] to int amount_to_read = [S+$18-$12] (used reg = )
|
|
mov ax,-$C[bp]
|
|
mov -$10[bp],ax
|
|
!BCC_EOS
|
|
! 55 }
|
|
! 56 e
|
|
! 56 lse
|
|
! 57 {
|
|
jmp .2A
|
|
.28:
|
|
! 58 amount_to_read = (4 * 512 );
|
|
! Debug: eq int = const $800 to int amount_to_read = [S+$18-$12] (used reg = )
|
|
mov ax,#$800
|
|
mov -$10[bp],ax
|
|
!BCC_EOS
|
|
! 59 }
|
|
! 60
|
|
! 61 integer_datapointer = file->data_pointer[data_pointer_index];
|
|
.2A:
|
|
mov bx,4[bp]
|
|
! Debug: ptradd int data_pointer_index = [S+$18-$16] to [$36] long = bx+$44 (used reg = )
|
|
mov ax,-$14[bp]
|
|
shl ax,*1
|
|
shl ax,*1
|
|
add bx,ax
|
|
! Debug: eq long = [bx+$44] to int integer_datapointer = [S+$18-$C] (used reg = )
|
|
mov bx,$44[bx]
|
|
mov -$A[bp],bx
|
|
!BCC_EOS
|
|
! 62 if (integer_datapointer == 0)
|
|
! Debug: logeq int = const 0 to int integer_datapointer = [S+$18-$C] (used reg = )
|
|
mov ax,-$A[bp]
|
|
test ax,ax
|
|
jne .2B
|
|
.2C:
|
|
! 63 {
|
|
! 64 break;
|
|
inc sp
|
|
inc sp
|
|
br .23
|
|
!BCC_EOS
|
|
! 65 }
|
|
! 66 disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], 4 , tmp_buffer);
|
|
.2B:
|
|
! Debug: list * char tmp_buffer = [S+$18-$18] (used reg = )
|
|
push -$16[bp]
|
|
! Debug: list int = const 4 (used reg = )
|
|
mov ax,*4
|
|
push ax
|
|
mov bx,4[bp]
|
|
! Debug: ptradd int data_pointer_index = [S+$1C-$16] to [$36] long = bx+$44 (used reg = )
|
|
mov ax,-$14[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,*8
|
|
!BCC_EOS
|
|
! 67 memcpy((data + amount_read), tmp_buffer, amount_to_read);
|
|
! Debug: list int amount_to_read = [S+$18-$12] (used reg = )
|
|
push -$10[bp]
|
|
! Debug: list * char tmp_buffer = [S+$1A-$18] (used reg = )
|
|
push -$16[bp]
|
|
! Debug: ptradd int amount_read = [S+$1C-$10] to * char data = [S+$1C+6] (used reg = )
|
|
mov ax,-$E[bp]
|
|
add ax,8[bp]
|
|
! Debug: list * char = ax+0 (used reg = )
|
|
push ax
|
|
! Debug: func () void = memcpy+0 (used reg = )
|
|
call _memcpy
|
|
add sp,*6
|
|
!BCC_EOS
|
|
! 68 data_length -= amount_to_read;
|
|
! Debug: subab int amount_to_read = [S+$18-$12] to int data_length = [S+$18-$E] (used reg = )
|
|
mov ax,-$C[bp]
|
|
sub ax,-$10[bp]
|
|
mov -$C[bp],ax
|
|
!BCC_EOS
|
|
! 69 amount_read += amount_to_read;
|
|
! Debug: addab int amount_to_read = [S+$18-$12] to int amount_read = [S+$18-$10] (used reg = )
|
|
mov ax,-$E[bp]
|
|
add ax,-$10[bp]
|
|
mov -$E[bp],ax
|
|
!BCC_EOS
|
|
! 70 data_pointer_index++;
|
|
! Debug: postinc int data_pointer_index = [S+$18-$16] (used reg = )
|
|
mov ax,-$14[bp]
|
|
inc ax
|
|
mov -$14[bp],ax
|
|
!BCC_EOS
|
|
! 71
|
|
! 72 }
|
|
inc sp
|
|
inc sp
|
|
! 73 else if (remaining_offset < (4 * 512 ))
|
|
br .2D
|
|
.26:
|
|
! Debug: lt int = const $800 to int remaining_offset = [S+$16-$14] (used reg = )
|
|
mov ax,-$12[bp]
|
|
cmp ax,#$800
|
|
bge .2E
|
|
.2F:
|
|
! 74 {
|
|
! 75 char *tmp_buffer = calloc(1, (4 * 512 ));
|
|
dec sp
|
|
dec sp
|
|
! Debug: list int = const $800 (used reg = )
|
|
mov ax,#$800
|
|
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+$18-$18] (used reg = )
|
|
mov -$16[bp],ax
|
|
!BCC_EOS
|
|
! 76
|
|
! 77
|
|
! 78 if (data_length < ((4 * 512 ) - remaining_offset) )
|
|
! Debug: sub int remaining_offset = [S+$18-$14] to int = const $800 (used reg = )
|
|
mov ax,#$800
|
|
sub ax,-$12[bp]
|
|
! Debug: lt int = ax+0 to int data_length = [S+$18-$E] (used reg = )
|
|
cmp ax,-$C[bp]
|
|
jle .30
|
|
.31:
|
|
! 79 {
|
|
! 80 amount_to_read = data_length;
|
|
! Debug: eq int data_length = [S+$18-$E] to int amount_to_read = [S+$18-$12] (used reg = )
|
|
mov ax,-$C[bp]
|
|
mov -$10[bp],ax
|
|
!BCC_EOS
|
|
! 81 }
|
|
! 82 else
|
|
! 83 {
|
|
jmp .32
|
|
.30:
|
|
! 84 amount_to_read = ((4 * 512 ) - remaining_offset);
|
|
! Debug: sub int remaining_offset = [S+$18-$14] to int = const $800 (used reg = )
|
|
mov ax,#$800
|
|
sub ax,-$12[bp]
|
|
! Debug: eq int = ax+0 to int amount_to_read = [S+$18-$12] (used reg = )
|
|
mov -$10[bp],ax
|
|
!BCC_EOS
|
|
! 85 }
|
|
! 86
|
|
! 87 disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], 4 , tmp_buffer);
|
|
.32:
|
|
! Debug: list * char tmp_buffer = [S+$18-$18] (used reg = )
|
|
push -$16[bp]
|
|
! Debug: list int = const 4 (used reg = )
|
|
mov ax,*4
|
|
push ax
|
|
mov bx,4[bp]
|
|
! Debug: ptradd int data_pointer_index = [S+$1C-$16] to [$36] long = bx+$44 (used reg = )
|
|
mov ax,-$14[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,*8
|
|
!BCC_EOS
|
|
! 88
|
|
! 89 memcpy(data, (tmp_buffer + remaining_offset), amount_to_read);
|
|
! Debug: list int amount_to_read = [S+$18-$12] (used reg = )
|
|
push -$10[bp]
|
|
! Debug: ptradd int remaining_offset = [S+$1A-$14] to * char tmp_buffer = [S+$1A-$18] (used reg = )
|
|
mov ax,-$12[bp]
|
|
add ax,-$16[bp]
|
|
! Debug: list * char = ax+0 (used reg = )
|
|
push ax
|
|
! Debug: list * char data = [S+$1C+6] (used reg = )
|
|
push 8[bp]
|
|
! Debug: func () void = memcpy+0 (used reg = )
|
|
call _memcpy
|
|
add sp,*6
|
|
!BCC_EOS
|
|
! 90 data_length -= amount_to_read;
|
|
! Debug: subab int amount_to_read = [S+$18-$12] to int data_length = [S+$18-$E] (used reg = )
|
|
mov ax,-$C[bp]
|
|
sub ax,-$10[bp]
|
|
mov -$C[bp],ax
|
|
!BCC_EOS
|
|
! 91 amount_read += amount_to_read;
|
|
! Debug: addab int amount_to_read = [S+$18-$12] to int amount_read = [S+$18-$10] (used reg = )
|
|
mov ax,-$E[bp]
|
|
add ax,-$10[bp]
|
|
mov -$E[bp],ax
|
|
!BCC_EOS
|
|
! 92 remaining_offset -= amount_to_read;
|
|
! Debug: subab int amount_to_read = [S+$18-$12] to int remaining_offset = [S+$18-$14] (used reg = )
|
|
mov ax,-$12[bp]
|
|
sub ax,-$10[bp]
|
|
mov -$12[bp],ax
|
|
!BCC_EOS
|
|
! 93
|
|
! 94 data_pointer_index++;
|
|
! Debug: postinc int data_pointer_index = [S+$18-$16] (used reg = )
|
|
mov ax,-$14[bp]
|
|
inc ax
|
|
mov -$14[bp],ax
|
|
!BCC_EOS
|
|
! 95
|
|
! 96 }
|
|
inc sp
|
|
inc sp
|
|
! 97 else
|
|
! 98 {
|
|
jmp .33
|
|
.2E:
|
|
! 99
|
|
! 100 remaining_offset -= (4 * 512 );
|
|
! Debug: subab int = const $800 to int remaining_offset = [S+$16-$14] (used reg = )
|
|
mov ax,-$12[bp]
|
|
add ax,#-$800
|
|
mov -$12[bp],ax
|
|
!BCC_EOS
|
|
! 101 data_pointer_index++;
|
|
! Debug: postinc int data_pointer_index = [S+$16-$16] (used reg = )
|
|
mov ax,-$14[bp]
|
|
inc ax
|
|
mov -$14[bp],ax
|
|
!BCC_EOS
|
|
! 102 }
|
|
! 103
|
|
! 104 }
|
|
.33:
|
|
.2D:
|
|
! 105 # 109
|
|
! 109
|
|
! 110 return amount_read;
|
|
.24:
|
|
! Debug: gt int = const 0 to int data_length = [S+$16-$E] (used reg = )
|
|
mov ax,-$C[bp]
|
|
test ax,ax
|
|
bgt .25
|
|
.34:
|
|
.23:
|
|
mov ax,-$E[bp]
|
|
add sp,*$10
|
|
pop si
|
|
pop di
|
|
pop bp
|
|
ret
|
|
!BCC_EOS
|
|
! 111
|
|
! 112 }
|
|
! 113
|
|
! Register BX used in function lsfs_disk_read_data_from_file
|
|
.data
|
|
.bss
|
|
|
|
! 0 errors detected
|