SingOS
/
lsfs_16-bit


								! 1

								! 1 # 1 "implementation/lsfs.c"

								! 1 # 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 	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_n

								push	bp

								mov	bp,sp

								push	di

								push	si

								! 60 ext;

								mov	ax,[_global_heap_next]

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 61 # 19 "implementation/../main.h"

								! 19 }

								! 20 # 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 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);

								push	bp

								mov	bp,sp

								push	di

								push	si

								add	sp,*-4

								! Debug: list * char source_1 = [S+$A+2] (used reg = )

								push	4[bp]

								! Debug: func () int = strlen+0 (used reg = )

								call	_strlen

								inc	sp

								inc	sp

								! 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))

								! Debug: list * char source_2 = [S+$A+4] (used reg = )

								push	6[bp]

								! Debug: func () int = strlen+0 (used reg = )

								call	_strlen

								inc	sp

								inc	sp

								! 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

								! 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: preinc 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_String *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

								! 245 (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] = '\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

								! 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] = '\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

								! 334

								! 335     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

								! 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

								! 20 "implementation/../main.h"

								! 21 }

								! 22 # 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_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 # 25 "implementation/../main.h"

								! 25 void dump_ax(input);

								!BCC_EOS

								! 26 void print_stack(argument);

								!BCC_EOS

								! 27 void print_newline();

								!BCC_EOS

								! 28

								! 29 typedef struct struct_partition_control partition_control;

								!BCC_EOS

								! 30 typedef struct File_System_Control_Information FSCI;

								!BCC_EOS

								! 31 typedef struct meta_information_format mif;

								!BCC_EOS

								! 32 typedef struct tag_record tag_record;

								!BCC_EOS

								! 33 typedef struct Parameter_Struct Parameter_Struct;

								!BCC_EOS

								! 34

								! 35

								! 36 typedef enum Service_Action

								! 37 {

								! 38     SERIVCE_LOAD_DISK  = 1,

								! 39     SERVICE_FIND_ENTRY = 2,

								! 40     SERIVCE_READ_DATA  = 3,

								! 41     SERIVCE_WRITE_DATA = 4,

								! 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     long next_uniqe_id[2];

								!BCC_EOS

								! 52     long next_secto

								! 52 r_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     int buffer_segment;

								!BCC_EOS

								! 66     int buffer_address;

								!BCC_EOS

								! 67     int buffer_size;

								!BCC_EOS

								! 68     int data_length;

								!BCC_EOS

								! 69     int byte_offset_into_file;

								!BCC_EOS

								! 70     short entry_kind;

								!BCC_EOS

								! 71 };

								!BCC_EOS

								! 72 # 5 "implementation/lsfs.h"

								! 5 typedef struct lsfs_file lsfs_file;

								!BCC_EOS

								! 6 typedef struct Directory_Table Directory_Table;

								!BCC_EOS

								! 7 typedef struct Table_Entry Table_Entry;

								!BCC_EOS

								! 8

								! 9 int lsfs_disk_getattr(find_file, path);

								!BCC_EOS

								! 10 int lsfs_disk_read_data_from_file(file, buffer_size, data,  offset_to_next_entry);

								!BCC_EOS

								! 11 Directory_Table* lsfs_find_directory(path, drop_filename);

								!BCC_EOS

								! 12

								! 13 typedef enum Table_Entry_Kind

								! 14 {

								! 15

								! 16     ENTRY_EMPTY = 0,

								! 17     ENTRY_FILE = 1,

								! 18     ENTRY_DIRECTORY = 2,

								! 19 } Table_Entry_Kind;

								!BCC_EOS

								! 20

								! 21 struct Table_Entry

								! 22 {

								! 23     char    filename[256];

								!BCC_EOS

								! 24     long    file_id[2];

								!BCC_EOS

								! 25     long    file_size[2];

								!BCC_EOS

								! 26     void*   ext_file_data_low;

								!BCC_EOS

								! 27     void*   ext_file_data_high;

								!BCC_EOS

								! 28     long    number_sector_s;

								!BCC_EOS

								! 29     short   entry_kind;

								!BCC_EOS

								! 30     short   extra_control_bits1;

								!BCC_EOS

								! 31     short   extra_control_bits2;

								!BCC_EOS

								! 32     short   extra_control_bits3;

								!BCC_EOS

								! 33     long    table_entry_sector_index[2];

								!BCC_EOS

								! 34     long    data_pointer[27   * 2];

								!BCC_EOS

								! 35 };

								!BCC_EOS

								! 36

								! 37 struct lsfs_file {

								! 38     long file_id[2];

								!BCC_EOS

								! 39     long table_entry_pointer[2];

								!BCC_EOS

								! 40     Table_Entry_Kind entry_kind;

								!BCC_EOS

								! 41     char* filename;

								!BCC_EOS

								! 42     long owner_id;

								!BCC_EOS

								! 43     long size[2];

								!BCC_EOS

								! 44     long creation_date[2];

								!BCC_EOS

								! 45     long access_time[2];

								!BCC_EOS

								! 46     long modification_time[2];

								!BCC_EOS

								! 47     long number_sector;

								!BCC_EOS

								! 48     long table_entry_sector_index[2];

								!BCC_EOS

								! 49     long data_pointer[27   * 2];

								!BCC_EOS

								! 50 };

								!BCC_EOS

								! 51

								! 52 struct Directory_Table

								! 53 {

								! 54     Table_Entry entries[16  ];

								!BCC_EOS

								! 55

								! 56 };

								!BCC_EOS

								! 57 # 3 "implementation/lsfs.c"

								! 3 extern FSCI fsci;

								!BCC_EOS

								! 4

								! 5 int lsfs_disk_getattr(find_file, path)

								! 6 lsfs_file* find_file;

								export	_lsfs_disk_getattr

								_lsfs_disk_getattr:

								!BCC_EOS

								! 7 char* path;

								!BCC_EOS

								! 8 {

								! 9     int i;

								!BCC_EOS

								! 10     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

								! 11     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

								! 12

								! 13

								! 14     Directory_Table *dir_table = lsfs_find_directory(path, 1 );

								dec	sp

								dec	sp

								! Debug: list int = const 1 (used reg = )

								mov	ax,*1

								push	ax

								! Debug: list * char path = [S+$10+4] (used reg = )

								push	6[bp]

								! Debug: func () * struct Directory_Table = lsfs_find_directory+0 (used reg = )

								call	_lsfs_find_directory

								add	sp,*4

								! Debug: eq * struct Directory_Table = ax+0 to * struct Directory_Table dir_table = [S+$E-$E] (used reg = )

								mov	-$C[bp],ax

								!BCC_EOS

								! 15

								! 16     for (i = 0; i < 16  ; ++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

								! 17     {

								br 	.2C

								.2D:

								! 18         if(strcmp( filename

								! 18 ->chars, dir_table->entries[i].filename ) == 0) {

								! Debug: ptradd int i = [S+$E-8] to [$10] struct Table_Entry dir_table = [S+$E-$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:

								! 19             find_file->file_id[0] = dir_table->entries[i].file_id;

								! Debug: ptradd int i = [S+$E-8] to [$10] struct Table_Entry dir_table = [S+$E-$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] long find_file = [S+$E+2] (used reg = bx)

								mov	si,4[bp]

								! Debug: eq [2] long = bx+$100 to long = [si+0] (used reg = )

								mov	ax,bx

								add	ax,#$100

								xor	bx,bx

								mov	[si],ax

								mov	2[si],bx

								!BCC_EOS

								! 20             find_file->entry_kind = dir_table->entries[i].entry_kind;

								! Debug: ptradd int i = [S+$E-8] to [$10] struct Table_Entry dir_table = [S+$E-$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

								! 21             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+$E-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

								! 22             find_file->filename = dir_table->entries[i].filename;

								! Debug: ptradd int i = [S+$E-8] to [$10] struct Table_Entry dir_table = [S+$E-$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

								! 23             find_file->table_entry_sector_index[0] = dir_table->entries[i].table_entry_sector_index;

								! Debug: ptradd int i = [S+$E-8] to [$10] struct Table_Entry dir_table = [S+$E-$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

								! 24             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

								! 25             find_file->size[0] = dir_table->entries[i].file_size;

								! Debug: ptradd int i = [S+$E-8] to [$10] struct Table_Entry dir_table = [S+$E-$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+$18 (used reg = bx)

								! Debug: eq [2] long = bx+$108 to long = [si+$18] (used reg = )

								mov	ax,bx

								add	ax,#$108

								xor	bx,bx

								mov	$18[si],ax

								mov	$1A[si],bx

								!BCC_EOS

								! 26             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

								! 27             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

								! 28             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

								! 29             memcpy(find_file->data_pointer, dir_table->entries[i].data_pointer, 27   * 8);

								! Debug: list int = const $D8 (used reg = )

								mov	ax,#$D8

								push	ax

								! Debug: ptradd int i = [S+$10-8] to [$10] 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 * long = const 0 to [$36] long = bx+$128 (used reg = )

								! Debug: list * long = bx+$128 (used reg = )

								add	bx,#$128

								push	bx

								mov	bx,4[bp]

								! Debug: cast * long = const 0 to [$36] long = bx+$44 (used reg = )

								! Debug: list * long = bx+$44 (used reg = )

								add	bx,*$44

								push	bx

								! Debug: func () void = memcpy+0 (used reg = )

								call	_memcpy

								add	sp,*6

								!BCC_EOS

								! 30             find_file->number_sector = 1;

								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

								! 31             return 1;

								mov	ax,*1

								add	sp,*8

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 32         }

								! 33     }

								.2E:

								! 34     return 0;

								.2B:

								! Debug: preinc int i = [S+$E-8] (used reg = )

								mov	ax,-6[bp]

								inc	ax

								mov	-6[bp],ax

								.2C:

								! Debug: lt int = const $10 to int i = [S+$E-8] (used reg = )

								mov	ax,-6[bp]

								cmp	ax,*$10

								blt 	.2D

								.31:

								.2A:

								xor	ax,ax

								add	sp,*8

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 35 }

								! 36

								! 37 Directory_Table* lsfs_find_directory(path, drop_filename)

								! Register BX SI used in function lsfs_disk_getattr

								! 38 char *path;

								export	_lsfs_find_directory

								_lsfs_find_directory:

								!BCC_EOS

								! 39 short drop_filename;

								!BCC_EOS

								! 40 {

								! 41     int number_of_traversal;

								!BCC_EOS

								! 42     int i, j;

								!BCC_EOS

								! 43     String_Array *split_path;

								!BCC_EOS

								! 44     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 $2000 (used reg = )

								mov	ax,#$2000

								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

								! 45

								! 46     disk_service_read_data_from_disk(fsci.master_table_index[0], 16  , 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 int = const $10 (used reg = )

								mov	ax,*$10

								push	ax

								! Debug: list long = [fsci+$100] (used reg = )

								push	[_fsci+$102]

								push	[_fsci+$100]

								! Debug: func () int = disk_service_read_data_from_disk+0 (used reg = )

								call	_disk_service_read_data_from_disk

								add	sp,*$A

								!BCC_EOS

								! 47     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

								! 48

								! 49     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

								! 50

								! 51     if (drop_filename)

								mov	ax,6[bp]

								test	ax,ax

								je  	.32

								.33:

								! 52     {

								! 53         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

								! 54     }

								! 55

								! 56

								! 57     for (i = 0; i < number_of_traversal; ++i)

								.32:

								! Debug: eq int = const 0 to int i = [S+$10-$A] (used reg = )

								xor	ax,ax

								mov	-8[bp],ax

								!BCC_EOS

								!BCC_EOS

								! 58     {

								jmp .36

								.37:

								! 59         for (j = 0; j < 16  ; ++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

								! 60         {

								jmp .3A

								.3B:

								! 61             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 [$10] 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 	.3C

								.3D:

								! 62             {

								! 63                 int index_sector = dir_table->entries[j].data_pointer[0];

								dec	sp

								dec	sp

								! Debug: ptradd int j = [S+$12-$C] to [$10] 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: ptradd int = const 0 to [$36] long = bx+$128 (used reg = )

								! Debug: eq long = [bx+$128] to int index_sector = [S+$12-$12] (used reg = )

								mov	bx,$128[bx]

								mov	-$10[bp],bx

								!BCC_EOS

								! 64

								! 65                 disk_service_read_data_from_disk(index_sector, 16  , dir_table);

								! Debug: list * struct Directory_Table dir_table = [S+$12-$10] (used reg = )

								push	-$E[bp]

								! Debug: list int = const $10 (used reg = )

								mov	ax,*$10

								push	ax

								! Debug: list int index_sector = [S+$16-$12] (used reg = )

								push	-$10[bp]

								! Debug: func () int = disk_service_read_data_from_disk+0 (used reg = )

								call	_disk_service_read_data_from_disk

								add	sp,*6

								!BCC_EOS

								! 66                 break;

								inc	sp

								inc	sp

								jmp .38

								!BCC_EOS

								! 67             }

								inc	sp

								inc	sp

								! 68         }

								.3C:

								! 69     }

								.39:

								! Debug: preinc int j = [S+$10-$C] (used reg = )

								mov	ax,-$A[bp]

								inc	ax

								mov	-$A[bp],ax

								.3A:

								! Debug: lt int = const $10 to int j = [S+$10-$C] (used reg = )

								mov	ax,-$A[bp]

								cmp	ax,*$10

								jl 	.3B

								.3E:

								.38:

								! 70     return dir_table;

								.35:

								! Debug: preinc int i = [S+$10-$A] (used reg = )

								mov	ax,-8[bp]

								inc	ax

								mov	-8[bp],ax

								.36:

								! 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]

								jl 	.37

								.3F:

								.34:

								mov	ax,-$E[bp]

								add	sp,*$A

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 71 }

								! 72

								! 73 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

								! 74 lsfs_file *file;

								export	_lsfs_disk_read_data_from_file

								_lsfs_disk_read_data_from_file:

								!BCC_EOS

								! 75 int buffer_size;

								!BCC_EOS

								! 76 char *data;

								!BCC_EOS

								! 77 long offset_to_next_entry;

								!BCC_EOS

								! 78 unsigned int data_segment;

								!BCC_EOS

								! 79 {

								! 80     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

								! 81     int integer_o

								! 81 ffset = 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

								! 82     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

								! 83     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

								! 84     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

								! 85     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

								! 86     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

								! 87

								! 88

								! 89

								! 90

								! 91

								! 92     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

								! 93

								! 94     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 	.40

								.41:

								! 95     {

								! 96         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

								! 97     }

								! 98

								! 99     while(data_length > 0)

								.40:

								! 100     {

								br 	.43

								.44:

								! 101

								! 102         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 	.45

								.46:

								! 103         {

								! 104             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

								! 105

								! 106

								! 107             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 	.47

								.48:

								! 108             {

								! 109                 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

								! 110             }

								! 111             else

								! 112             {

								jmp .49

								.47:

								! 113                 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

								! 114             }

								! 115

								! 116             integer_datapointer = file->data_pointer[data_pointer_index];

								.49:

								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

								! 117             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 	.4A

								.4B:

								! 118             {

								! 119                 break;

								inc	sp

								inc	sp

								br 	.42

								!BCC_EOS

								! 120             }

								! 121             disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], 4  , tmp_buffer, 0x7e0);

								.4A:

								! Debug: list int = const $7E0 (used reg = )

								mov	ax,#$7E0

								push	ax

								! Debug: list * char tmp_buffer = [S+$1A-$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+$1E-$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,*$A

								!BCC_EOS

								! 122             memcpy((data + amount_read), data_segment, tmp_buffer, 0x7e0, amount_to_read);

								! Debug: list int amount_to_read = [S+$18-$12] (used reg = )

								push	-$10[bp]

								! Debug: list int = const $7E0 (used reg = )

								mov	ax,#$7E0

								push	ax

								! Debug: list * char tmp_buffer = [S+$1C-$18] (used reg = )

								push	-$16[bp]

								! Debug: list unsigned int data_segment = [S+$1E+$C] (used reg = )

								push	$E[bp]

								! Debug: ptradd int amount_read = [S+$20-$10] to * char data = [S+$20+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,*$A

								!BCC_EOS

								! 123             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

								! 124             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

								! 125             data_pointer_index = data_pointer_index + 2;

								! Debug: add int = const 2 to int data_pointer_index = [S+$18-$16] (used reg = )

								mov	ax,-$14[bp]

								! Debug: eq int = ax+2 to int data_pointer_index = [S+$18-$16] (used reg = )

								inc	ax

								inc	ax

								mov	-$14[bp],ax

								!BCC_EOS

								! 126

								! 127         }

								inc	sp

								inc	sp

								! 128         else if (remaining_offset < (4   * 512  ))

								br 	.4C

								.45:

								! Debug: lt int = const $800 to int remaining_offset = [S+$16-$14] (used reg = )

								mov	ax,-$12[bp]

								cmp	ax,#$800

								bge 	.4D

								.4E:

								! 129         {

								! 130             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

								! 131

								! 132

								! 133             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 	.4F

								.50:

								! 134             {

								! 135                 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

								! 136             }

								! 137             else

								! 138             {

								jmp .51

								.4F:

								! 139                 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

								! 140             }

								! 141

								! 142             disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], 4  , tmp_buffer, 0x7e0);

								.51:

								! Debug: list int = const $7E0 (used reg = )

								mov	ax,#$7E0

								push	ax

								! Debug: list * char tmp_buffer = [S+$1A-$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+$1E-$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,*$A

								!BCC_EOS

								! 143

								! 144             memcpy(data, data_segment, (tmp_buffer + remaining_offset), 0x7e0, amount_to_read);

								! Debug: list int amount_to_read = [S+$18-$12] (used reg = )

								push	-$10[bp]

								! Debug: list int = const $7E0 (used reg = )

								mov	ax,#$7E0

								push	ax

								! Debug: ptradd int remaining_offset = [S+$1C-$14] to * char tmp_buffer = [S+$1C-$18] (used reg = )

								mov	ax,-$12[bp]

								add	ax,-$16[bp]

								! Debug: list * char = ax+0 (used reg = )

								push	ax

								! Debug: list unsigned int data_segment = [S+$1E+$C] (used reg = )

								push	$E[bp]

								! Debug: list * char data = [S+$20+6] (used reg = )

								push	8[bp]

								! Debug: func () void = memcpy+0 (used reg = )

								call	_memcpy

								add	sp,*$A

								!BCC_EOS

								! 145             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

								! 146             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

								! 147             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

								! 148

								! 149             data_pointer_index = data_

								! 149 pointer_index + 2;

								! Debug: add int = const 2 to int data_pointer_index = [S+$18-$16] (used reg = )

								mov	ax,-$14[bp]

								! Debug: eq int = ax+2 to int data_pointer_index = [S+$18-$16] (used reg = )

								inc	ax

								inc	ax

								mov	-$14[bp],ax

								!BCC_EOS

								! 150

								! 151         }

								inc	sp

								inc	sp

								! 152         else

								! 153         {

								jmp .52

								.4D:

								! 154

								! 155             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

								! 156             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

								! 157         }

								! 158

								! 159     }

								.52:

								.4C:

								! 160 # 164

								! 164

								! 165     return amount_read;

								.43:

								! Debug: gt int = const 0 to int data_length = [S+$16-$E] (used reg = )

								mov	ax,-$C[bp]

								test	ax,ax

								bgt 	.44

								.53:

								.42:

								mov	ax,-$E[bp]

								add	sp,*$10

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 166

								! 167 }

								! 168

								! Register BX used in function lsfs_disk_read_data_from_file

								.data

								.bss


								! 0 errors detected