push bp
mov bp,sp
push 10[bp]
push 8[bp]
push 6[bp]
call _main
add sp, #0x6
pop bp
retf
 ! 1 
! 1 # 1 "main.c"
! 1 # 1 "std_singos/stdio.h"
! 1 void print(string);
!BCC_EOS
! 2 void* dump_ax_return(input);
!BCC_EOS
! 3 
! 4 void print(string)
! 5 char* string;
export	_print
_print:
!BCC_EOS
! 6 {
! 7 #asm 
!BCC_ASM
_print.string	set	2
 
    push bp
    mov bp,sp
    mov si,4[bp]

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    new_print_print:
    ; Prints string in si
    ; IN si: zero terminated string to print
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
        mov ah, #0xE     ; Specify 'int 0x10' 'teletype output' function
                        ; [AL = Character, BH = Page Number, BL = Colour (in graphics mode)]
    .new_print_printchar:
        lodsb           ; Load byte at address SI into AL, and increment SI
        test al, al
        jz .new_print_done        ; If the character is zero (NUL), stop writing the string
        int #0x10         ; Otherwise, print the character via 'int 0x10'
        jmp .new_print_printchar  ; Repeat for the next character
    .new_print_done:

    pop bp
! 28 endasm
!BCC_ENDASM
! 29 }
ret
! 30 
! 31 
! 32 void print_stack(argument)
! 33 {
export	_print_stack
_print_stack:
! 34 #asm 
!BCC_ASM
_print_stack.argument	set	2
 
    push bp
    mov bp,sp
    push ds
    push ax

    mov ax, ss
    mov ds, ax
    mov si,4[bp]
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    print_stack_print:
    ; Prints string in si
    ; IN si: zero terminated string to print
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
        mov ah, #0xE     ; Specify 'int 0x10' 'teletype output' function
                        ; [AL = Character, BH = Page Number, BL = Colour (in graphics mode)]
    .print_stack_printchar:
        lodsb           ; Load byte at address SI into AL, and increment SI
        test al, al
        jz .print_stack_done        ; If the character is zero (NUL), stop writing the string
        int #0x10         ; Otherwise, print the character via 'int 0x10'
        jmp .print_stack_printchar  ; Repeat for the next character
    .print_stack_done:
    
    pop ax
    pop ds
    pop bp
! 61 endasm
!BCC_ENDASM
! 62 }
ret
! 63 
! 64 void* dump_ax_return(input)
! 65 void* input;
export	_dump_ax_return
_dump_ax_return:
!BCC_EOS
! 66 {
! 67     return
! 67  input;
push	bp
mov	bp,sp
push	di
push	si
mov	ax,4[bp]
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 68 }
! 69 
! 70 void dump_ax(input)
! 71 void* input;
export	_dump_ax
_dump_ax:
!BCC_EOS
! 72 {
! 73     dump_ax_return(input)
push	bp
mov	bp,sp
push	di
push	si
! 74 #asm
! Debug: list * void input = [S+6+2] (used reg = )
push	4[bp]
! Debug: func () * void = dump_ax_return+0 (used reg = )
call	_dump_ax_return
inc	sp
inc	sp
!BCC_EOS
!BCC_ASM
_dump_ax.input	set	8
.dump_ax.input	set	4
    push bp
    mov bp,sp

    pusha           ; save registers
    mov bx, ax
    mov ah, #0xE     ; Teletype output

    mov cx, #4       ; 4 nipples in a 16 bit word
    .dump_ax_loop:
    rol bx, #4       ; rotate to next nipple
    mov al, bl      ; we copy to al because we need to mask only the low 4 bits
    and al, #%1111   ; Do the masking
    add al, #48     ; convert to ASCII
    cmp al, #57     ; If we are greater than 9 ascii, we add 7 to make digit 10 be represented as 'A'
    jbe .dump_ax_skip       ;  -|-
    add al, #7       ;  -|-
    .dump_ax_skip:          ;  -|-
    int #0x10        ; BIOS call 'output'
    loop .dump_ax_loop

    popa            ; restore registers

    pop bp
! 98 endasm
!BCC_ENDASM
!BCC_EOS
! 99 }
pop	si
pop	di
pop	bp
ret
! 100 
! 101 void print_newline()
! 102 {
export	_print_newline
_print_newline:
! 103 #asm 
!BCC_ASM
 
    printCRLF:
    mov ah, #0xE
    mov al, #13
    int #0x10
    mov al, #10
    int #0x10
    ret
! 111 endasm
!BCC_ENDASM
! 112 }
ret
! 113 # 1 "std_singos/stdlib.h"
! 1 unsigned int global_heap_start = 0;
export	_global_heap_start
_global_heap_start:
.word	0
!BCC_EOS
! 2 unsigned int global_heap_end = 0;
export	_global_heap_end
_global_heap_end:
.word	0
!BCC_EOS
! 3 unsigned int global_heap_next = 0;
export	_global_heap_next
_global_heap_next:
.word	0
!BCC_EOS
! 4 
! 5 void* malloc(num_bytes);
!BCC_EOS
! 6 void* calloc(number_elements, size);
!BCC_EOS
! 7 int set_heap_settings(param_start, param_end);
!BCC_EOS
! 8 unsigned int get_heap_next();
!BCC_EOS
! 9 
! 10 void* malloc(num_bytes)
! 11 int num_bytes;
.text
export	_malloc
_malloc:
!BCC_EOS
! 12 {
! 13 	unsigned int allocated_pointer = global_heap_next;
push	bp
mov	bp,sp
push	di
push	si
dec	sp
dec	sp
! Debug: eq unsigned int = [global_heap_next+0] to unsigned int allocated_pointer = [S+8-8] (used reg = )
mov	ax,[_global_heap_next]
mov	-6[bp],ax
!BCC_EOS
! 14 	global_heap_next = global_heap_next + num_bytes;
! Debug: add int num_bytes = [S+8+2] to unsigned int = [global_heap_next+0] (used reg = )
mov	ax,[_global_heap_next]
add	ax,4[bp]
! Debug: eq unsigned int = ax+0 to unsigned int = [global_heap_next+0] (used reg = )
mov	[_global_heap_next],ax
!BCC_EOS
! 15 	if (global_heap_next > global_heap_end)
! Debug: gt unsigned int = [global_heap_end+0] to unsigned int = [global_heap_next+0] (used reg = )
mov	ax,[_global_heap_next]
cmp	ax,[_global_heap_end]
jbe 	.1
.2:
! 16 	{
! 17 		return 0; 
xor	ax,ax
inc	sp
inc	sp
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 18 	}
! 19 
! 20 	return allocated_pointer;
.1:
mov	ax,-6[bp]
inc	sp
inc	sp
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 21 }
! 22 
! 23 void* calloc(number_elements, size)
! 24 unsigned int number_elements;
export	_calloc
_calloc:
!BCC_EOS
! 25 unsigned int size;
!BCC_EOS
! 26 {
! 27 	int i;
!BCC_EOS
! 28 	char* temp_pointer;
!BCC_EOS
! 29 	unsigned int num_bytes = number_elements * size;
push	bp
mov	bp,sp
push	di
push	si
add	sp,*-6
! Debug: mul unsigned int size = [S+$C+4] to unsigned int number_elements = [S+$C+2] (used reg = )
mov	ax,4[bp]
mov	cx,6[bp]
imul	cx
! Debug: eq unsigned int = ax+0 to unsigned int num_bytes = [S+$C-$C] (used reg = )
mov	-$A[bp],ax
!BCC_EOS
! 30 	void* allocated_pointer = global_heap_next;
dec	sp
dec	sp
! Debug: eq unsigned int = [global_heap_next+0] to * void allocated_pointer = [S+$E-$E] (used reg = )
mov	bx,[_global_heap_next]
mov	-$C[bp],bx
!BCC_EOS
! 31 	global_heap_next = global_heap_next + num_bytes;
! Debug: add unsigned int num_bytes = [S+$E-$C] to unsigned int = [global_heap_next+0] (used reg = )
mov	ax,[_global_heap_next]
add	ax,-$A[bp]
! Debug: eq unsigned int = ax+0 to unsigned int = [global_heap_next+0] (used reg = )
mov	[_global_heap_next],ax
!BCC_EOS
! 32 	if (global_heap_next > global_heap_end)
! Debug: gt unsigned int = [global_heap_end+0] to unsigned int = [global_heap_next+0] (used reg = )
mov	ax,[_global_heap_next]
cmp	ax,[_global_heap_end]
jbe 	.3
.4:
! 33 	{
! 34 		return 0; 
xor	ax,ax
add	sp,*8
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 35 	}
! 36 
! 37 	
! 38 	temp_pointer = allocated_pointer;
.3:
! Debug: eq * void allocated_pointer = [S+$E-$E] to * char temp_pointer = [S+$E-$A] (used reg = )
mov	bx,-$C[bp]
mov	-8[bp],bx
!BCC_EOS
! 39 	for (i = 0; i < num_bytes; ++i)
! Debug: eq int = const 0 to int i = [S+$E-8] (used reg = )
xor	ax,ax
mov	-6[bp],ax
!BCC_EOS
!BCC_EOS
! 40 	{
jmp .7
.8:
! 41 		*temp_pointer = 0;
mov	bx,-8[bp]
! Debug: eq int = const 0 to char = [bx+0] (used reg = )
xor	al,al
mov	[bx],al
!BCC_EOS
! 42 		temp_pointer++;
! Debug: postinc * char temp_pointer = [S+$E-$A] (used reg = )
mov	bx,-8[bp]
inc	bx
mov	-8[bp],bx
!BCC_EOS
! 43 	}
! 44 
! 45 	return allocated_pointer;
.6:
! Debug: preinc int i = [S+$E-8] (used reg = )
mov	ax,-6[bp]
inc	ax
mov	-6[bp],ax
.7:
! Debug: lt unsigned int num_bytes = [S+$E-$C] to int i = [S+$E-8] (used reg = )
mov	ax,-6[bp]
cmp	ax,-$A[bp]
jb 	.8
.9:
.5:
mov	ax,-$C[bp]
add	sp,*8
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 46 }
! 47 
! 48 int set_heap_settings(param_start, param_end)
! Register BX used in function calloc
! 49 unsigned int param_start;
export	_set_heap_settings
_set_heap_settings:
!BCC_EOS
! 50 unsigned int param_end;
!BCC_EOS
! 51 {
! 52 	global_heap_start = param_start;
push	bp
mov	bp,sp
push	di
push	si
! Debug: eq unsigned int param_start = [S+6+2] to unsigned int = [global_heap_start+0] (used reg = )
mov	ax,4[bp]
mov	[_global_heap_start],ax
!BCC_EOS
! 53 	global
! 53 _heap_next = param_start;
! Debug: eq unsigned int param_start = [S+6+2] to unsigned int = [global_heap_next+0] (used reg = )
mov	ax,4[bp]
mov	[_global_heap_next],ax
!BCC_EOS
! 54 	global_heap_end = param_end;
! Debug: eq unsigned int param_end = [S+6+4] to unsigned int = [global_heap_end+0] (used reg = )
mov	ax,6[bp]
mov	[_global_heap_end],ax
!BCC_EOS
! 55 	return 0;
xor	ax,ax
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 56 }
! 57 
! 58 unsigned int get_heap_next() 
! 59 {
export	_get_heap_next
_get_heap_next:
! 60 	return global_heap_next;
push	bp
mov	bp,sp
push	di
push	si
mov	ax,[_global_heap_next]
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 61 # 19 "main.h"
! 19 }
! 20 # 2 "std_singos/string.h"
! 2 typedef struct Length_String {
! 3     short dynamic;
!BCC_EOS
! 4     unsigned int length;
!BCC_EOS
! 5     char *chars;
!BCC_EOS
! 6 } Length_String;
!BCC_EOS
! 7 
! 8 typedef struct String_Array {
! 9     unsigned int length;
!BCC_EOS
! 10     Length_String **strings;
!BCC_EOS
! 11 } String_Array;
!BCC_EOS
! 12 
! 13 void strcpy (destination, destination_segment, source, source_segment );
!BCC_EOS
! 14 int strlen (source, source_segment);
!BCC_EOS
! 15 void memcpy (destination, destination_segment, source, source_segment, num_bytes );
!BCC_EOS
! 16 
! 17  
! 18 String_Array *string_split_c(string, delim, keep_delim);
!BCC_EOS
! 19 Length_String *make_length_string(length, chars);
!BCC_EOS
! 20 Length_String *make_length_string_c(cstring);
!BCC_EOS
! 21 String_Array *length_string_split(string, delim, keep_delim);
!BCC_EOS
! 22 String_Array *create_length_string_array(array_size);
!BCC_EOS
! 23 Length_String *create_length_string(length, chars);
!BCC_EOS
! 24 
! 25 
! 26 
! 27 int strlen (source, source_segment)
! 28 {
export	_strlen
_strlen:
! 29 #asm
!BCC_ASM
_strlen.source	set	2
_strlen.source_segment	set	4


push bp
    mov bp,sp
    push ds
    push bx

    mov ax, 6[bp]; 
    mov ds, ax

    mov bx, 4[bp]; 

    label_strlen:
       mov cx, #0x0            ; Set counte to zero
    .label_strlen_loop: 
       mov BYTE al, [bx] 
       cmp al, #0x0 
       je .label_strlen_done 
       inc cx                  ; Count 1
       inc bx                  ; Look at next char
       jmp .label_strlen_loop
    .label_strlen_done:
       mov ax, cx 
    
    pop bx
    pop ds
    pop bp
! 57 endasm
!BCC_ENDASM
! 58 }
ret
! 59 
! 60 void strcpy (destination, destination_segment, source, source_segment )
! 61 char *destination;
export	_strcpy
_strcpy:
!BCC_EOS
! 62 int destination_segment;
!BCC_EOS
! 63 char *source;
!BCC_EOS
! 64 int source_segment;
!BCC_EOS
! 65 {
! 66 #asm
!BCC_ASM
_strcpy.source	set	6
_strcpy.destination	set	2
_strcpy.source_segment	set	8
_strcpy.destination_segment	set	4
    ; copy two strings
    ; IN si: the first (zero terminated) string
    ; IN di: the second (zero terminated) string
    ; OUT SF and ZF (same semantics as cmp)
    
! 72  76

    push bp
    mov bp,sp
    label_strcpy:
        push ax
        push bx
        push di
        push es
        push si
        push ds
        mov ax, 4[bp]; ; 
        mov di, ax
        mov ax, 6[bp]; ; 
        mov es, ax
        mov ax, 8[bp]; ; 
        mov si, ax
        mov ax, 10[bp]; ; 
        mov ds, ax
        mov cx, 0x050  ;TODO(Jrn) Hardcded number of bytes to copy
    .label_strcpy_loop:
        movsb
        cmp cx, 0x0
        je .label_strcpy_end
        dec cx
        jmp .label_strcpy_loop
    .label_strcpy_end:
        pop ds
        pop si
        pop es
        pop di
        pop bx
        pop ax
        pop bp

! 110 endasm
!BCC_ENDASM
! 111 }
ret
! 112 
! 113 void memcpy (destination, destination_segment, source, source_segment, num_bytes)
! 114 void *destination;
export	_memcpy
_memcpy:
!BCC_EOS
! 115 int destination_segment;
!BCC_EOS
! 116 void *source;
!BCC_EOS
! 117 int source_segment;
!BCC_EOS
! 118 int num_bytes;
!BCC_EOS
! 119 {
! 120 #asm
!BCC_ASM
_memcpy.source	set	6
_memcpy.destination	set	2
_memcpy.num_bytes	set	$A
_memcpy.source_segment	set	8
_memcpy.destination_segment	set	4
    ; copy two strings
    ; IN si: the first (zero terminated) string
    ; IN di: the second (zero terminated) string
    ; OUT SF and ZF (same semantics as cmp)
    
! 126  131

    push bp
    mov bp,sp
    label_memcpy:
        push ax
        push bx
        push di
        push es
        push si
        push ds
        mov ax, 4[bp]; ; 
        mov di, ax
        mov ax, 6[bp]; ; 
        mov es, ax
        mov ax, 8[bp]; ; 
        mov si, ax
        mov ax, 10[bp]; ; 
        mov ds, ax
        mov cx, 12[bp]; 
    .label_memcpy_loop:
        movsb
        cmp cx, 0x0
        je .label_memcpy_end
        dec cx
        jmp .label_memcpy_loop
    .label_memcpy_end:
        pop ds
        pop si
        pop es
        pop di
        pop bx
        pop ax
        pop bp

! 165 endasm
!BCC_ENDASM
! 166 }
ret
! 167 
! 168 int strcmp(source_1, source_2) 
! 169 char* source_1;
export	_strcmp
_strcmp:
!BCC_EOS
! 170 char* source_2;
!BCC_EOS
! 171 {
! 172     int i;
!BCC_EOS
! 173     int count;
!BCC_EOS
! 174 
! 175     count = strlen(source_1, 0x7e0);
push	bp
mov	bp,sp
push	di
push	si
add	sp,*-4
! Debug: list int = const $7E0 (used reg = )
mov	ax,#$7E0
push	ax
! Debug: list * char source_1 = [S+$C+2] (used reg = )
push	4[bp]
! Debug: func () int = strlen+0 (used reg = )
call	_strlen
add	sp,*4
! Debug: eq int = ax+0 to int count = [S+$A-$A] (used reg = )
mov	-8[bp],ax
!BCC_EOS
! 176     if (count != strlen(source_2, 0x7e0)) 
! Debug: list int = const $7E0 (used reg = )
mov	ax,#$7E0
push	ax
! Debug: list * char source_2 = [S+$C+4] (used reg = )
push	6[bp]
! Debug: func () int = strlen+0 (used reg = )
call	_strlen
add	sp,*4
! Debug: ne int = ax+0 to int count = [S+$A-$A] (used reg = )
! Debug: expression subtree swapping
cmp	ax,-8[bp]
je  	.A
.B:
! 177     {
! 178         return -1;
mov	ax,*-1
add	sp,*4
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 179     }
! 180 
! 181 
! 182     for (i = 0; i < count; i++)
.A:
! Debug: eq int = const 0 to int i = [S+$A-8] (used reg = )
xor	ax,ax
mov	-6[bp],ax
!BCC_EOS
!BCC_EOS
! 183     {
jmp .E
.F:
! 184         if(source_1[i] != source_2[i])
! Debug: ptradd int i = [S+$A-8] to * char source_2 = [S+$A+4] (used reg = )
mov	ax,-6[bp]
add	ax,6[bp]
mov	bx,ax
! Debug: ptradd int i = [S+$A-8] to * char source_1 = [S+$A+2] (used reg = bx)
mov	ax,-6[bp]
add	ax,4[bp]
mov	si,ax
! Debug: ne char = [bx+0] to char = [si+0] (used reg = )
mov	al,[si]
cmp	al,[bx]
je  	.10
.11:
! 185         {
! 186             return -1; 
mov	ax,*-1
add	sp,*4
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 187         } 
! 188     }
.10:
! 189 
! 190     return 0;
.D:
! Debug: postinc int i = [S+$A-8] (used reg = )
mov	ax,-6[bp]
inc	ax
mov	-6[bp],ax
.E:
! Debug: lt int count = [S+$A-$A] to int i = [S+$A-8] (used reg = )
mov	ax,-6[bp]
cmp	ax,-8[bp]
jl 	.F
.12:
.C:
xor	ax,ax
add	sp,*4
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 191 # 223
! 223     
! 224 }
! 225 
! 226 String_Array *string_split_c(string, delim, keep_delim)
! Register BX SI used in function strcmp
! 227 char *string;
export	_string_split_c
_string_split_c:
!BCC_EOS
! 228 char delim; 
!BCC_EOS
! 229 short keep_delim; 
!BCC_EOS
! 230 {
! 231     return length_string_split(make_length_string_c(string), delim, keep_delim);
push	bp
mov	bp,sp
push	di
push	si
! Debug: list short keep_delim = [S+6+6] (used reg = )
push	8[bp]
! Debug: list char delim = [S+8+4] (used reg = )
mov	al,6[bp]
xor	ah,ah
push	ax
! Debug: list * char string = [S+$A+2] (used reg = )
push	4[bp]
! Debug: func () * struct Length_String = make_length_string_c+0 (used reg = )
call	_make_length_string_c
inc	sp
inc	sp
! Debug: list * struct Length_String = ax+0 (used reg = )
push	ax
! Debug: func () * struct String_Array = length_string_split+0 (used reg = )
call	_length_string_split
add	sp,*6
! Debug: cast * struct String_Array = const 0 to * struct String_Array = ax+0 (used reg = )
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 232 }
! 233 
! 234 Length_String *make_length_string_c(cstring)
! 235 char *cstring; 
export	_make_length_string_c
_make_length_string_c:
!BCC_EOS
! 236 {
! 237     return make_length_string(strlen(cstring, 0x7e0), cstring);
push	bp
mov	bp,sp
push	di
push	si
! Debug: list * char cstring = [S+6+2] (used reg = )
push	4[bp]
! Debug: list int = const $7E0 (used reg = )
mov	ax,#$7E0
push	ax
! Debug: list * char cstring = [S+$A+2] (used reg = )
push	4[bp]
! Debug: func () int = strlen+0 (used reg = )
call	_strlen
add	sp,*4
! Debug: list int = ax+0 (used reg = )
push	ax
! Debug: func () * struct Length_String = make_length_string+0 (used reg = )
call	_make_length_string
add	sp,*4
! Debug: cast * struct Length_String = const 0 to * struct Length_String = ax+0 (used reg = )
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 238 }
! 239 
! 240 Length_S
! 240 tring *make_length_string(length, chars) 
! 241 unsigned int length;
export	_make_length_string
_make_length_string:
!BCC_EOS
! 242 char *chars;
!BCC_EOS
! 243 {
! 244 
! 245     Length_String *legth_string = malloc(sizeof(Length_String));
push	bp
mov	bp,sp
push	di
push	si
dec	sp
dec	sp
! Debug: list int = const 6 (used reg = )
mov	ax,*6
push	ax
! Debug: func () * void = malloc+0 (used reg = )
call	_malloc
inc	sp
inc	sp
! Debug: eq * void = ax+0 to * struct Length_String legth_string = [S+8-8] (used reg = )
mov	-6[bp],ax
!BCC_EOS
! 246     char *copy = malloc(length + 1); 
dec	sp
dec	sp
! Debug: add int = const 1 to unsigned int length = [S+$A+2] (used reg = )
mov	ax,4[bp]
! Debug: list unsigned int = ax+1 (used reg = )
inc	ax
push	ax
! Debug: func () * void = malloc+0 (used reg = )
call	_malloc
inc	sp
inc	sp
! Debug: eq * void = ax+0 to * char copy = [S+$A-$A] (used reg = )
mov	-8[bp],ax
!BCC_EOS
! 247     memcpy(copy, 0x7e0, chars, 0x7e0, length);
! Debug: list unsigned int length = [S+$A+2] (used reg = )
push	4[bp]
! Debug: list int = const $7E0 (used reg = )
mov	ax,#$7E0
push	ax
! Debug: list * char chars = [S+$E+4] (used reg = )
push	6[bp]
! Debug: list int = const $7E0 (used reg = )
mov	ax,#$7E0
push	ax
! Debug: list * char copy = [S+$12-$A] (used reg = )
push	-8[bp]
! Debug: func () void = memcpy+0 (used reg = )
call	_memcpy
add	sp,*$A
!BCC_EOS
! 248     copy[length] = '';
! Debug: ptradd unsigned int length = [S+$A+2] to * char copy = [S+$A-$A] (used reg = )
mov	ax,4[bp]
add	ax,-8[bp]
mov	bx,ax
! Debug: eq int = const 0 to char = [bx+0] (used reg = )
xor	al,al
mov	[bx],al
!BCC_EOS
! 249 
! 250     legth_string->dynamic = 0;
mov	bx,-6[bp]
! Debug: eq int = const 0 to short = [bx+0] (used reg = )
xor	ax,ax
mov	[bx],ax
!BCC_EOS
! 251     legth_string->length = length;
mov	bx,-6[bp]
! Debug: eq unsigned int length = [S+$A+2] to unsigned int = [bx+2] (used reg = )
mov	ax,4[bp]
mov	2[bx],ax
!BCC_EOS
! 252     legth_string->chars = (char *)chars;
mov	bx,-6[bp]
! Debug: eq * char chars = [S+$A+4] to * char = [bx+4] (used reg = )
mov	si,6[bp]
mov	4[bx],si
!BCC_EOS
! 253 
! 254     return legth_string;
mov	ax,-6[bp]
add	sp,*4
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 255 }
! 256 
! 257 String_Array *length_string_split(string, delim, keep_delim) 
! Register BX SI used in function make_length_string
! 258 Length_String *string; 
export	_length_string_split
_length_string_split:
!BCC_EOS
! 259 char delim;
!BCC_EOS
! 260 short keep_delim;
!BCC_EOS
! 261 {
! 262     unsigned int i;
!BCC_EOS
! 263     unsigned int last;
!BCC_EOS
! 264 
! 265     unsigned int count = 0;
push	bp
mov	bp,sp
push	di
push	si
add	sp,*-6
! Debug: eq int = const 0 to unsigned int count = [S+$C-$C] (used reg = )
xor	ax,ax
mov	-$A[bp],ax
!BCC_EOS
! 266     unsigned int insert_index = 0;
dec	sp
dec	sp
! Debug: eq int = const 0 to unsigned int insert_index = [S+$E-$E] (used reg = )
xor	ax,ax
mov	-$C[bp],ax
!BCC_EOS
! 267     String_Array *result;
!BCC_EOS
! 268     int k;
!BCC_EOS
! 269     
! 270     i = 0;
add	sp,*-4
! Debug: eq int = const 0 to unsigned int i = [S+$12-8] (used reg = )
xor	ax,ax
mov	-6[bp],ax
!BCC_EOS
! 271     last = 0;
! Debug: eq int = const 0 to unsigned int last = [S+$12-$A] (used reg = )
xor	ax,ax
mov	-8[bp],ax
!BCC_EOS
! 272     while(i < string->length) {
jmp .14
.15:
! 273         if (string->chars[i] == delim) {
mov	bx,4[bp]
! Debug: ptradd unsigned int i = [S+$12-8] to * char = [bx+4] (used reg = )
mov	ax,-6[bp]
add	ax,4[bx]
mov	bx,ax
! Debug: logeq char delim = [S+$12+4] to char = [bx+0] (used reg = )
mov	al,[bx]
cmp	al,6[bp]
jne 	.16
.17:
! 274             if (i > last+1) {
! Debug: add int = const 1 to unsigned int last = [S+$12-$A] (used reg = )
mov	ax,-8[bp]
! Debug: gt unsigned int = ax+1 to unsigned int i = [S+$12-8] (used reg = )
inc	ax
cmp	ax,-6[bp]
jae 	.18
.19:
! 275                 ++count;
! Debug: preinc unsigned int count = [S+$12-$C] (used reg = )
mov	ax,-$A[bp]
inc	ax
mov	-$A[bp],ax
!BCC_EOS
! 276             }
! 277             last = i;
.18:
! Debug: eq unsigned int i = [S+$12-8] to unsigned int last = [S+$12-$A] (used reg = )
mov	ax,-6[bp]
mov	-8[bp],ax
!BCC_EOS
! 278         }
! 279         ++i;
.16:
! Debug: preinc unsigned int i = [S+$12-8] (used reg = )
mov	ax,-6[bp]
inc	ax
mov	-6[bp],ax
!BCC_EOS
! 280     }
! 281     if (i > last+1) {
.14:
mov	bx,4[bp]
! Debug: lt unsigned int = [bx+2] to unsigned int i = [S+$12-8] (used reg = )
mov	ax,-6[bp]
cmp	ax,2[bx]
jb 	.15
.1A:
.13:
! Debug: add int = const 1 to unsigned int last = [S+$12-$A] (used reg = )
mov	ax,-8[bp]
! Debug: gt unsigned int = ax+1 to unsigned int i = [S+$12-8] (used reg = )
inc	ax
cmp	ax,-6[bp]
jae 	.1B
.1C:
! 282         ++count;
! Debug: preinc unsigned int count = [S+$12-$C] (used reg = )
mov	ax,-$A[bp]
inc	ax
mov	-$A[bp],ax
!BCC_EOS
! 283     }
! 284 
! 285     result = create_length_string_array(count);
.1B:
! Debug: list unsigned int count = [S+$12-$C] (used reg = )
push	-$A[bp]
! Debug: func () * struct String_Array = create_length_string_array+0 (used reg = )
call	_create_length_string_array
inc	sp
inc	sp
! Debug: eq * struct String_Array = ax+0 to * struct String_Array result = [S+$12-$10] (used reg = )
mov	-$E[bp],ax
!BCC_EOS
! 286 
! 287     if (keep_delim) 
mov	ax,8[bp]
test	ax,ax
je  	.1D
.1E:
! 288     {
! 289         k = 0;
! Debug: eq int = const 0 to int k = [S+$12-$12] (used reg = )
xor	ax,ax
mov	-$10[bp],ax
!BCC_EOS
! 290     }
! 291     else 
! 292     {
jmp .1F
.1D:
! 293         k = 1;
! Debug: eq int = const 1 to int k = [S+$12-$12] (used reg = )
mov	ax,*1
mov	-$10[bp],ax
!BCC_EOS
! 294     }
! 295     
! 296     i = 0;
.1F:
! Debug: eq int = const 0 to unsigned int i = [S+$12-8] (used reg = )
xor	ax,ax
mov	-6[bp],ax
!BCC_EOS
! 297     last = 0;
! Debug: eq int = const 0 to unsigned int last = [S+$12-$A] (used reg = )
xor	ax,ax
mov	-8[bp],ax
!BCC_EOS
! 298     while(i < string->length) {
jmp .21
.22:
! 299         if (string->chars[i] == delim) {
mov	bx,4[bp]
! Debug: ptradd unsigned int i = [S+$12-8] to * char = [bx+4] (used reg = )
mov	ax,-6[bp]
add	ax,4[bx]
mov	bx,ax
! Debug: logeq char delim = [S+$12+4] to char = [bx+0] (used reg = )
mov	al,[bx]
cmp	al,6[bp]
jne 	.23
.24:
! 300             if (i > last+1) {
! Debug: add int = const 1 to unsigned int last = [S+$12-$A] (used reg = )
mov	ax,-8[bp]
! Debug: gt unsigned int = ax+1 to unsigned int i = [S+$12-8] (used reg = )
inc	ax
cmp	ax,-6[bp]
jae 	.25
.26:
! 301                 result->strings[insert_index++] = create_length_string(i-(last+k), string->chars+(last+k));
! Debug: add int k = [S+$12-$12] to unsigned int last = [S+$12-$A] (used reg = )
mov	ax,-8[bp]
add	ax,-$10[bp]
mov	bx,4[bp]
! Debug: ptradd unsigned int = ax+0 to * char = [bx+4] (used reg = )
add	ax,4[bx]
! Debug: list * char = ax+0 (used reg = )
push	ax
! Debug: add int k = [S+$14-$12] to unsigned int last = [S+$14-$A] (used reg = )
mov	ax,-8[bp]
add	ax,-$10[bp]
! Debug: sub unsigned int = ax+0 to unsigned int i = [S+$14-8] (used reg = )
push	ax
mov	ax,-6[bp]
sub	ax,-$14[bp]
inc	sp
inc	sp
! Debug: list unsigned int = ax+0 (used reg = )
push	ax
! Debug: func () * struct Length_String = create_length_string+0 (used reg = )
call	_create_length_string
add	sp,*4
push	ax
! Debug: postinc unsigned int insert_index = [S+$14-$E] (used reg = )
mov	ax,-$C[bp]
inc	ax
mov	-$C[bp],ax
mov	bx,-$E[bp]
! Debug: ptradd unsigned int = ax-1 to * * struct Length_String = [bx+2] (used reg = )
dec	ax
shl	ax,*1
add	ax,2[bx]
mov	bx,ax
! Debug: eq * struct Length_String (temp) = [S+$14-$14] to * struct Length_String = [bx+0] (used reg = )
mov	si,-$12[bp]
mov	[bx],si
inc	sp
inc	sp
!BCC_EOS
! 302             }
! 303             last = i;
.25:
! Debug: eq unsigned int i = [S+$12-8] to unsigned int last = [S+$12-$A] (used reg = )
mov	ax,-6[bp]
mov	-8[bp],ax
!BCC_EOS
! 304         }
! 305         ++i;
.23:
! Debug: preinc unsigned int i = [S+$12-8] (used reg = )
mov	ax,-6[bp]
inc	ax
mov	-6[bp],ax
!BCC_EOS
! 306     }
! 307     if (i > last+1) {
.21:
mov	bx,4[bp]
! Debug: lt unsigned int = [bx+2] to unsigned int i = [S+$12-8] (used reg = )
mov	ax,-6[bp]
cmp	ax,2[bx]
jb 	.22
.27:
.20:
! Debug: add int = const 1 to unsigned int last = [S+$12-$A] (used reg = )
mov	ax,-8[bp]
! Debug: gt unsigned int = ax+1 to unsigned int i = [S+$12-8] (used reg = )
inc	ax
cmp	ax,-6[bp]
jae 	.28
.29:
! 308         result->strings[insert_index++] = create_length_string(i-(last+k), ((string->chars)+(last+k)));
! Debug: add int k = [S+$12-$12] to unsigned int last = [S+$12-$A] (used reg = )
mov	ax,-8[bp]
add	ax,-$10[bp]
mov	bx,4[bp]
! Debug: ptradd unsigned int = ax+0 to * char = [bx+4] (used reg = )
add	ax,4[bx]
! Debug: list * char = ax+0 (used reg = )
push	ax
! Debug: add int k = [S+$14-$12] to unsigned int last = [S+$14-$A] (used reg = )
mov	ax,-8[bp]
add	ax,-$10[bp]
! Debug: sub unsigned int = ax+0 to unsigned int i = [S+$14-8] (used reg = )
push	ax
mov	ax,-6[bp]
sub	ax,-$14[bp]
inc	sp
inc	sp
! Debug: list unsigned int = ax+0 (used reg = )
push	ax
! Debug: func () * struct Length_String = create_length_string+0 (used reg = )
call	_create_length_string
add	sp,*4
push	ax
! Debug: postinc unsigned int insert_index = [S+$14-$E] (used reg = )
mov	ax,-$C[bp]
inc	ax
mov	-$C[bp],ax
mov	bx,-$E[bp]
! Debug: ptradd unsigned int = ax-1 to * * struct Length_String = [bx+2] (used reg = )
dec	ax
shl	ax,*1
add	ax,2[bx]
mov	bx,ax
! Debug: eq * struct Length_String (temp) = [S+$14-$14] to * struct Length_String = [bx+0] (used reg = )
mov	si,-$12[bp]
mov	[bx],si
inc	sp
inc	sp
!BCC_EOS
! 309     }
! 310 
! 311     return result;
.28:
mov	ax,-$E[bp]
add	sp,*$C
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 312 
! 313 }
! 314 
! 315 String_Array *create_length_string_array(array_size)
! Register BX SI used in function length_string_split
! 316 int array_size; 
export	_create_length_string_array
_create_length_string_array:
!BCC_EOS
! 317 {
! 318     String_Array *result = malloc(sizeof(String_Array));
push	bp
mov	bp,sp
push	di
push	si
dec	sp
dec	sp
! Debug: list int = const 4 (used reg = )
mov	ax,*4
push	ax
! Debug: func () * void = malloc+0 (used reg = )
call	_malloc
inc	sp
inc	sp
! Debug: eq * void = ax+0 to * struct String_Array result = [S+8-8] (used reg = )
mov	-6[bp],ax
!BCC_EOS
! 319     result->length = array_size;
mov	bx,-6[bp]
! Debug: eq int array_size = [S+8+2] to unsigned int = [bx+0] (used reg = )
mov	ax,4[bp]
mov	[bx],ax
!BCC_EOS
! 320     result->strings = malloc(array_size * sizeof(Length_String));
! Debug: mul int = const 6 to int array_size = [S+8+2] (used reg = )
mov	ax,4[bp]
mov	dx,ax
shl	ax,*1
add	ax,dx
shl	ax,*1
! Debug: list int = ax+0 (used reg = )
push	ax
! Debug: func () * void = malloc+0 (used reg = )
call	_malloc
inc	sp
inc	sp
mov	bx,-6[bp]
! Debug: eq * void = ax+0 to * * struct Length_String = [bx+2] (used reg = )
mov	2[bx],ax
!BCC_EOS
! 321     return result;
mov	ax,-6[bp]
inc	sp
inc	sp
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 322 }
! 323 
! 324 
! 325 Length_String *create_length_string(length, chars) 
! Register BX used in function create_length_string_array
! 326 unsigned int length;
export	_create_length_string
_create_length_string:
!BCC_EOS
! 327 char *chars;
!BCC_EOS
! 328 {
! 329     
! 330     Length_String *legth_string = malloc(sizeof(Length_String));
push	bp
mov	bp,sp
push	di
push	si
dec	sp
dec	sp
! Debug: list int = const 6 (used reg = )
mov	ax,*6
push	ax
! Debug: func () * void = malloc+0 (used reg = )
call	_malloc
inc	sp
inc	sp
! Debug: eq * void = ax+0 to * struct Length_String legth_string = [S+8-8] (used reg = )
mov	-6[bp],ax
!BCC_EOS
! 331     char *copy = malloc(length + 1); 
dec	sp
dec	sp
! Debug: add int = const 1 to unsigned int length = [S+$A+2] (used reg = )
mov	ax,4[bp]
! Debug: list unsigned int = ax+1 (used reg = )
inc	ax
push	ax
! Debug: func () * void = malloc+0 (used reg = )
call	_malloc
inc	sp
inc	sp
! Debug: eq * void = ax+0 to * char copy = [S+$A-$A] (used reg = )
mov	-8[bp],ax
!BCC_EOS
! 332     memcpy(copy, 0x7e0, chars, 0x7e0, length);
! Debug: list unsigned int length = [S+$A+2] (used reg = )
push	4[bp]
! Debug: list int = const $7E0 (used reg = )
mov	ax,#$7E0
push	ax
! Debug: list * char chars = [S+$E+4] (used reg = )
push	6[bp]
! Debug: list int = const $7E0 (used reg = )
mov	ax,#$7E0
push	ax
! Debug: list * char copy = [S+$12-$A] (used reg = )
push	-8[bp]
! Debug: func () void = memcpy+0 (used reg = )
call	_memcpy
add	sp,*$A
!BCC_EOS
! 333     copy[length] = '';
! Debug: ptradd unsigned int length = [S+$A+2] to * char copy = [S+$A-$A] (used reg = )
mov	ax,4[bp]
add	ax,-8[bp]
mov	bx,ax
! Debug: eq int = const 0 to char = [bx+0] (used reg = )
xor	al,al
mov	[bx],al
!BCC_EOS
! 334 
! 335     legth_
! 335 string->dynamic = 1;
mov	bx,-6[bp]
! Debug: eq int = const 1 to short = [bx+0] (used reg = )
mov	ax,*1
mov	[bx],ax
!BCC_EOS
! 336     legth_string->length = length;
mov	bx,-6[bp]
! Debug: eq unsigned int length = [S+$A+2] to unsigned int = [bx+2] (used reg = )
mov	ax,4[bp]
mov	2[bx],ax
!BCC_EOS
! 337     legth_string->chars = copy;
mov	bx,-6[bp]
! Debug: eq * char copy = [S+$A-$A] to * char = [bx+4] (used reg = )
mov	si,-8[bp]
mov	4[bx],si
!BCC_EOS
! 338 
! 339     return legth_string;
mov	ax,-6[bp]
add	sp,*4
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 340 # 21 "main.h"
! 21 }
! 22 # 1 "driver/disk.h"
! 1 int data_from_disk(index, number_sectors, data_buffer, data_buffer_segment);
! Register BX SI used in function create_length_string
!BCC_EOS
! 2 int disk_service_read_data_from_disk(index, number_sectors, data_buffer, data_buffer_segment);
!BCC_EOS
! 3 
! 4 int disk_service_read_data_from_disk(index, number_sectors, data_buffer, data_buffer_segment)
! 5 long index; 
export	_disk_service_read_data_from_disk
_disk_service_read_data_from_disk:
!BCC_EOS
! 6 long number_sectors; 
!BCC_EOS
! 7 void* data_buffer;
!BCC_EOS
! 8 unsigned int data_buffer_segment;
!BCC_EOS
! 9 {
! 10 
! 11 #asm
!BCC_ASM
_disk_service_read_data_from_disk.data_buffer	set	$A
_disk_service_read_data_from_disk.number_sectors	set	6
_disk_service_read_data_from_disk.data_buffer_segment	set	$C
_disk_service_read_data_from_disk.index	set	2
! 12  16

	push bp
    mov bp,sp
	pusha
	lsfs_load_data:
	    mov ax, 4[bp];  
	    mov WORD [DAPACK.lba_addr_dw_low], ax
	    mov bx, 8[bp]; 
	    mov WORD [DAPACK.blkcnt],          bx
	    mov cx, 14[bp];   
	    mov WORD [DAPACK.db_addr_segment], cx
	    mov dx, 12[bp]; ;
	    mov WORD [DAPACK.db_addr_offset],  dx
	    mov si, #DAPACK                          ; address of
	    mov ah, #0x42                            ; READ
	    mov dl, [global_disk_identifier] 
	    int #0x13
	popa
	pop bp
	ret


	DAPACK:
	  DAPACK.dap_Size:         db  0x10 
	  DAPACK.rev_byte:         db  0x0  
	  DAPACK.blkcnt:           dw  0x0  
	  DAPACK.db_addr_offset:   dw  0x0  
	  DAPACK.db_addr_segment:  dw  0x0  
	  DAPACK.lba_addr_dw_low:  dd  0x0  
	  DAPACK.lba_addr_dw_high: dd  0x0  
	
	global_disk_identifier: db 0x80

! 49 endasm
!BCC_ENDASM
! 50 } 
ret
! 51 # 24 "main.h"
! 24 void dump_ax(input);
!BCC_EOS
! 25 void print_stack(argument);
!BCC_EOS
! 26 void print_newline();
!BCC_EOS
! 27 
! 28 typedef struct struct_partition_control partition_control;
!BCC_EOS
! 29 typedef struct File_System_Control_Information FSCI;
!BCC_EOS
! 30 typedef struct meta_information_format mif;
!BCC_EOS
! 31 typedef struct tag_record tag_record;
!BCC_EOS
! 32 typedef struct Parameter_Struct Parameter_Struct;
!BCC_EOS
! 33 
! 34 
! 35 typedef enum Service_Action
! 36 {
! 37     SERIVCE_LOAD_DISK  = 1,
! 38     SERVICE_FIND_ENTRY = 2,
! 39     SERIVCE_READ_DATA  = 3,
! 40     SERIVCE_WRITE_DATA = 4,
! 41     SERIVCE_WRITE_FS_INFO = 10,
! 42 
! 43 } Service_Action;
!BCC_EOS
! 44 
! 45 struct File_System_Control_Information 
! 46 {
! 47     char filesystem_information[256];
!BCC_EOS
! 48     long master_table_index[2];
!BCC_EOS
! 49     long this_partition_offset_on_disk[2];
!BCC_EOS
! 50     long next_free_sector[2];
!BCC_EOS
! 51 
! 51     long next_uniqe_id[2]; 
!BCC_EOS
! 52     long next_sector_reuse_pointer[2];
!BCC_EOS
! 53     long last_sector_index_on_partition[2];
!BCC_EOS
! 54     long maximum_sectors_on_disk[2];
!BCC_EOS
! 55     long sector_size_on_disk[2];
!BCC_EOS
! 56     long not_used[48];
!BCC_EOS
! 57 
! 58 };
!BCC_EOS
! 59 
! 60 
! 61 struct Parameter_Struct 
! 62 {
! 63     char* path;
!BCC_EOS
! 64     char* new_path;
!BCC_EOS
! 65     unsigned int buffer_segment;
!BCC_EOS
! 66     unsigned int buffer_address;
!BCC_EOS
! 67     unsigned int buffer_size;
!BCC_EOS
! 68     unsigned int data_length;
!BCC_EOS
! 69     unsigned int byte_offset_into_file;
!BCC_EOS
! 70     short entry_kind;
!BCC_EOS
! 71 };
!BCC_EOS
! 72 # 6 "implementation/lsfs.h"
! 6 typedef struct lsfs_file lsfs_file;
!BCC_EOS
! 7 typedef struct Directory_Table Directory_Table;
!BCC_EOS
! 8 typedef struct Table_Entry Table_Entry;
!BCC_EOS
! 9 
! 10 int lsfs_disk_getattr(find_file, path, fsci);
!BCC_EOS
! 11 int lsfs_disk_read_data_from_file(file, buffer_size, data,  offset_to_next_entry);
!BCC_EOS
! 12 Directory_Table* lsfs_find_directory(path, drop_filename, fsci);
!BCC_EOS
! 13 
! 14 typedef enum Table_Entry_Kind
! 15 {
! 16     
! 17     ENTRY_EMPTY = 0,
! 18     ENTRY_FILE = 1,
! 19     ENTRY_DIRECTORY = 2,
! 20 } Table_Entry_Kind;
!BCC_EOS
! 21 
! 22 struct Table_Entry 
! 23 {
! 24     char    filename[256]; 
!BCC_EOS
! 25     unsigned long    file_id[2];
!BCC_EOS
! 26     unsigned long    file_size[2];
!BCC_EOS
! 27     void*   ext_file_data_low;
!BCC_EOS
! 28     void*   ext_file_data_high;
!BCC_EOS
! 29     long    number_sector_s; 
!BCC_EOS
! 30     short   entry_kind;
!BCC_EOS
! 31     short   extra_control_bits1;
!BCC_EOS
! 32     short   extra_control_bits2;
!BCC_EOS
! 33     short   extra_control_bits3;
!BCC_EOS
! 34     long    table_entry_sector_index[2];
!BCC_EOS
! 35     long    data_pointer[27   * 2]; 
!BCC_EOS
! 36 };
!BCC_EOS
! 37 
! 38 struct lsfs_file {
! 39     unsigned long file_id[2];
!BCC_EOS
! 40     long table_entry_pointer[2];
!BCC_EOS
! 41     Table_Entry_Kind entry_kind;
!BCC_EOS
! 42     char* filename;
!BCC_EOS
! 43     long owner_id;
!BCC_EOS
! 44     unsigned long size[2];
!BCC_EOS
! 45     long creation_date[2]; 
!BCC_EOS
! 46     long access_time[2];
!BCC_EOS
! 47     long modification_time[2];
!BCC_EOS
! 48     long number_sector;
!BCC_EOS
! 49     long table_entry_sector_index[2];
!BCC_EOS
! 50     long data_pointer[27   * 2];
!BCC_EOS
! 51 };
!BCC_EOS
! 52 
! 53 struct Directory_Table 
! 54 {
! 55     Table_Entry entries[8   ];
!BCC_EOS
! 56 
! 57 }; 
!BCC_EOS
! 58 # 75
! 75 int lsfs_disk_getattr(find_file, path, fsci) 
! 76 lsfs_file* find_file; 
export	_lsfs_disk_getattr
_lsfs_disk_getattr:
!BCC_EOS
! 77 char *path;
!BCC_EOS
! 78 FSCI *fsci;
!BCC_EOS
! 79 {
! 80     int i;
!BCC_EOS
! 81     String_Array *split_path = string_split_c(path, '/', 0 );
push	bp
mov	bp,sp
push	di
push	si
add	sp,*-4
! Debug: list int = const 0 (used reg = )
xor	ax,ax
push	ax
! Debug: list int = const $2F (used reg = )
mov	ax,*$2F
push	ax
! Debug: list * char path = [S+$E+4] (used reg = )
push	6[bp]
! Debug: func () * struct String_Array = string_split_c+0 (used reg = )
call	_string_split_c
add	sp,*6
! Debug: eq * struct String_Array = ax+0 to * struct String_Array split_path = [S+$A-$A] (used reg = )
mov	-8[bp],ax
!BCC_EOS
! 82     Length_String *filename = split_path->strings[split_path->length-1]; 
dec	sp
dec	sp
mov	bx,-8[bp]
! Debug: sub int = const 1 to unsigned int = [bx+0] (used reg = )
mov	bx,[bx]
mov	si,-8[bp]
! Debug: ptradd unsigned int = bx-1 to * * struct Length_String = [si+2] (used reg = )
mov	ax,bx
dec	ax
shl	ax,*1
add	ax,2[si]
mov	bx,ax
! Debug: eq * struct Length_String = [bx+0] to * struct Length_String filename = [S+$C-$C] (used reg = )
mov	bx,[bx]
mov	-$A[bp],bx
!BCC_EOS
! 83     
! 84     
! 85     Directory
! 85 _Table *dir_table = lsfs_find_directory(path, 1 , fsci);
dec	sp
dec	sp
! Debug: list * struct File_System_Control_Information fsci = [S+$E+6] (used reg = )
push	8[bp]
! Debug: list int = const 1 (used reg = )
mov	ax,*1
push	ax
! Debug: list * char path = [S+$12+4] (used reg = )
push	6[bp]
! Debug: func () * struct Directory_Table = lsfs_find_directory+0 (used reg = )
call	_lsfs_find_directory
add	sp,*6
! Debug: eq * struct Directory_Table = ax+0 to * struct Directory_Table dir_table = [S+$E-$E] (used reg = )
mov	-$C[bp],ax
!BCC_EOS
! 86 
! 87     for (i = 0; i < 8   ; i++)
! Debug: eq int = const 0 to int i = [S+$E-8] (used reg = )
xor	ax,ax
mov	-6[bp],ax
!BCC_EOS
!BCC_EOS
! 88     {
br 	.2C
.2D:
! 89     	int j;
!BCC_EOS
! 90 # 99
! 99         
! 100         if(strcmp( filename->chars, dir_table->entries[i].filename ) == 0) {
dec	sp
dec	sp
! Debug: ptradd int i = [S+$10-8] to [8] struct Table_Entry dir_table = [S+$10-$E] (used reg = )
mov	ax,-6[bp]
mov	cx,#$200
imul	cx
add	ax,-$C[bp]
mov	bx,ax
! Debug: cast * char = const 0 to [$100] char = bx+0 (used reg = )
! Debug: list * char = bx+0 (used reg = )
push	bx
mov	bx,-$A[bp]
! Debug: list * char = [bx+4] (used reg = )
push	4[bx]
! Debug: func () int = strcmp+0 (used reg = )
call	_strcmp
add	sp,*4
! Debug: logeq int = const 0 to int = ax+0 (used reg = )
test	ax,ax
bne 	.2E
.2F:
! 101             find_file->file_id[0] = dir_table->entries[i].file_id[0];
! Debug: ptradd int i = [S+$10-8] to [8] struct Table_Entry dir_table = [S+$10-$E] (used reg = )
mov	ax,-6[bp]
mov	cx,#$200
imul	cx
add	ax,-$C[bp]
mov	bx,ax
! Debug: ptradd int = const 0 to [2] unsigned long = bx+$100 (used reg = )
! Debug: ptradd int = const 0 to [2] unsigned long find_file = [S+$10+2] (used reg = bx)
mov	si,4[bp]
! Debug: eq unsigned long = [bx+$100] to unsigned long = [si+0] (used reg = )
mov	ax,$100[bx]
mov	bx,$102[bx]
mov	[si],ax
mov	2[si],bx
!BCC_EOS
! 102             find_file->entry_kind = dir_table->entries[i].entry_kind;
! Debug: ptradd int i = [S+$10-8] to [8] struct Table_Entry dir_table = [S+$10-$E] (used reg = )
mov	ax,-6[bp]
mov	cx,#$200
imul	cx
add	ax,-$C[bp]
mov	bx,ax
mov	si,4[bp]
! Debug: eq short = [bx+$118] to int = [si+$10] (used reg = )
mov	bx,$118[bx]
mov	$10[si],bx
!BCC_EOS
! 103             find_file->table_entry_pointer[0] = i;
mov	bx,4[bp]
! Debug: ptradd int = const 0 to [2] long = bx+8 (used reg = )
! Debug: eq int i = [S+$10-8] to long = [bx+8] (used reg = )
mov	ax,-6[bp]
cwd
mov	si,dx
mov	8[bx],ax
mov	$A[bx],si
!BCC_EOS
! 104             find_file->filename = dir_table->entries[i].filename;
! Debug: ptradd int i = [S+$10-8] to [8] struct Table_Entry dir_table = [S+$10-$E] (used reg = )
mov	ax,-6[bp]
mov	cx,#$200
imul	cx
add	ax,-$C[bp]
mov	bx,ax
mov	si,4[bp]
! Debug: eq [$100] char = bx+0 to * char = [si+$12] (used reg = )
mov	$12[si],bx
!BCC_EOS
! 105             find_file->table_entry_sector_index[0] = dir_table->entries[i].table_entry_sector_index;
! Debug: ptradd int i = [S+$10-8] to [8] struct Table_Entry dir_table = [S+$10-$E] (used reg = )
mov	ax,-6[bp]
mov	cx,#$200
imul	cx
add	ax,-$C[bp]
mov	bx,ax
mov	si,4[bp]
! Debug: ptradd int = const 0 to [2] long = si+$3C (used reg = bx)
! Debug: eq [2] long = bx+$120 to long = [si+$3C] (used reg = )
mov	ax,bx
add	ax,#$120
xor	bx,bx
mov	$3C[si],ax
mov	$3E[si],bx
!BCC_EOS
! 106             find_file->owner_id = 1;
mov	bx,4[bp]
! Debug: eq int = const 1 to long = [bx+$14] (used reg = )
mov	ax,*1
xor	si,si
mov	$14[bx],ax
mov	$16[bx],si
!BCC_EOS
! 107             find_file->size[0] = dir_table->entries[i].file_size[0]; 
! Debug: ptradd int i = [S+$10-8] to [8] struct Table_Entry dir_table = [S+$10-$E] (used reg = )
mov	ax,-6[bp]
mov	cx,#$200
imul	cx
add	ax,-$C[bp]
mov	bx,ax
! Debug: ptradd int = const 0 to [2] unsigned long = bx+$108 (used reg = )
mov	si,4[bp]
! Debug: ptradd int = const 0 to [2] unsigned long = si+$18 (used reg = bx)
! Debug: eq unsigned long = [bx+$108] to unsigned long = [si+$18] (used reg = )
mov	ax,$108[bx]
mov	bx,$10A[bx]
mov	$18[si],ax
mov	$1A[si],bx
!BCC_EOS
! 108             find_file->creation_date[0] = 0;
mov	bx,4[bp]
! Debug: ptradd int = const 0 to [2] long = bx+$20 (used reg = )
! Debug: eq int = const 0 to long = [bx+$20] (used reg = )
xor	ax,ax
xor	si,si
mov	$20[bx],ax
mov	$22[bx],si
!BCC_EOS
! 109             find_file->access_time[0] = 0;
mov	bx,4[bp]
! Debug: ptradd int = const 0 to [2] long = bx+$28 (used reg = )
! Debug: eq int = const 0 to long = [bx+$28] (used reg = )
xor	ax,ax
xor	si,si
mov	$28[bx],ax
mov	$2A[bx],si
!BCC_EOS
! 110             find_file->modification_time[0] = 0;
mov	bx,4[bp]
! Debug: ptradd int = const 0 to [2] long = bx+$30 (used reg = )
! Debug: eq int = const 0 to long = [bx+$30] (used reg = )
xor	ax,ax
xor	si,si
mov	$30[bx],ax
mov	$32[bx],si
!BCC_EOS
! 111             
! 112             for (j = 0; j < 27  ; j = j + 2)
! Debug: eq int = const 0 to int j = [S+$10-$10] (used reg = )
xor	ax,ax
mov	-$E[bp],ax
!BCC_EOS
!BCC_EOS
! 113             {
jmp .33
.34:
! 114             	find_file->data_pointer[j] = dir_table->entries[i].data_pointer[j];
! Debug: ptradd int i = [S+$10-8] to [8] struct Table_Entry dir_table = [S+$10-$E] (used reg = )
mov	ax,-6[bp]
mov	cx,#$200
imul	cx
add	ax,-$C[bp]
mov	bx,ax
! Debug: ptradd int j = [S+$10-$10] to [$36] long = bx+$128 (used reg = )
mov	ax,-$E[bp]
shl	ax,*1
shl	ax,*1
add	bx,ax
mov	si,4[bp]
! Debug: ptradd int j = [S+$10-$10] to [$36] long = si+$44 (used reg = bx)
mov	ax,-$E[bp]
shl	ax,*1
shl	ax,*1
add	si,ax
! Debug: eq long = [bx+$128] to long = [si+$44] (used reg = )
mov	ax,$128[bx]
mov	bx,$12A[bx]
mov	$44[si],ax
mov	$46[si],bx
!BCC_EOS
! 115             }
! 116 
! 117 
! 118             find_file->number_sector = 1; 
.32:
! Debug: add int = const 2 to int j = [S+$10-$10] (used reg = )
mov	ax,-$E[bp]
! Debug: eq int = ax+2 to int j = [S+$10-$10] (used reg = )
inc	ax
inc	ax
mov	-$E[bp],ax
.33:
! Debug: lt int = const $1B to int j = [S+$10-$10] (used reg = )
mov	ax,-$E[bp]
cmp	ax,*$1B
jl 	.34
.35:
.31:
mov	bx,4[bp]
! Debug: eq int = const 1 to long = [bx+$38] (used reg = )
mov	ax,*1
xor	si,si
mov	$38[bx],ax
mov	$3A[bx],si
!BCC_EOS
! 119             return 1;
mov	ax,*1
add	sp,*$A
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 120         }
! 121     }
.2E:
inc	sp
inc	sp
! 122     return 0;
.2B:
! Debug: postinc int i = [S+$E-8] (used reg = )
mov	ax,-6[bp]
inc	ax
mov	-6[bp],ax
.2C:
! Debug: lt int = const 8 to int i = [S+$E-8] (used reg = )
mov	ax,-6[bp]
cmp	ax,*8
blt 	.2D
.36:
.2A:
xor	ax,ax
add	sp,*8
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 123 }
! 124 
! 125 Directory_Table* lsfs_find_directory(path, drop_filename, fsci)
! Register BX SI used in function lsfs_disk_getattr
! 126 char *path;
export	_lsfs_find_directory
_lsfs_find_directory:
!BCC_EOS
! 127 short drop_filename; 
!BCC_EOS
! 128 FSCI *fsci;
!BCC_EOS
! 129 {
! 130     int number_of_traversal;
!BCC_EOS
! 131     int i, j;
!BCC_EOS
! 132     String_Array *split_path;
!BCC_EOS
! 133     Directory_Table *dir_table = calloc(1, sizeof(Directory_Table));
push	bp
mov	bp,sp
push	di
push	si
add	sp,*-$A
! Debug: list int = const $1000 (used reg = )
mov	ax,#$1000
push	ax
! Debug: list int = const 1 (used reg = )
mov	ax,*1
push	ax
! Debug: func () * void = calloc+0 (used reg = )
call	_calloc
add	sp,*4
! Debug: eq * void = ax+0 to * struct Directory_Table dir_table = [S+$10-$10] (used reg = )
mov	-$E[bp],ax
!BCC_EOS
! 134     
! 135     disk_service_read_data_from_disk(fsci->master_table_index[0], (long) 8   , dir_table, 0x7e0);
! Debug: list int = const $7E0 (used reg = )
mov	ax,#$7E0
push	ax
! Debug: list * struct Directory_Table dir_table = [S+$12-$10] (used reg = )
push	-$E[bp]
! Debug: list long = const 8 (used reg = )
mov	ax,*8
xor	bx,bx
push	bx
push	ax
mov	bx,8[bp]
! Debug: ptradd int = const 0 to [2] long = bx+$100 (used reg = )
! Debug: list long = [bx+$100] (used reg = )
push	$102[bx]
push	$100[bx]
! Debug: func () int = disk_service_read_data_from_disk+0 (used reg = )
call	_disk_service_read_data_from_disk
add	sp,*$C
!BCC_EOS
! 136     split_path = string_split_c(path, '/', 0 );
! Debug: list int = const 0 (used reg = )
xor	ax,ax
push	ax
! Debug: list int = const $2F (used reg = )
mov	ax,*$2F
push	ax
! Debug: list * char path = [S+$14+2] (used reg = )
push	4[bp]
! Debug: func () * struct String_Array = string_split_c+0 (used reg = )
call	_string_split_c
add	sp,*6
! Debug: eq * struct String_Array = ax+0 to * struct String_Array split_path = [S+$10-$E] (used reg = )
mov	-$C[bp],ax
!BCC_EOS
! 137 
! 138     number_of_traversal = split_path->length;
mov	bx,-$C[bp]
! Debug: eq unsigned int = [bx+0] to int number_of_traversal = [S+$10-8] (used reg = )
mov	bx,[bx]
mov	-6[bp],bx
!BCC_EOS
! 139 	
! 140 
! 141     if (drop_filename)
mov	ax,6[bp]
test	ax,ax
je  	.37
.38:
! 142     {
! 143         number_of_traversal -= 1;
! Debug: subab int = const 1 to int number_of_traversal = [S+$10-8] (used reg = )
mov	ax,-6[bp]
dec	ax
mov	-6[bp],ax
!BCC_EOS
! 144     }
! 145 
! 146     
! 147     for (i = 0; i < number_of_traversal; ++i)
.37:
! Debug: eq int = const 0 to int i = [S+$10-$A] (used reg = )
xor	ax,ax
mov	-8[bp],ax
!BCC_EOS
!BCC_EOS
! 148     {
br 	.3B
.3C:
! 149         for (j = 0; j < 8   ; ++j)
! Debug: eq int = const 0 to int j = [S+$10-$C] (used reg = )
xor	ax,ax
mov	-$A[bp],ax
!BCC_EOS
!BCC_EOS
! 150         {
jmp .3F
.40:
! 151 # 158
! 158             
! 159             if (strcmp(dir_table->entries[j].filename, split_path->strings[i]->chars) == 0)
mov	bx,-$C[bp]
! Debug: ptradd int i = [S+$10-$A] to * * struct Length_String = [bx+2] (used reg = )
mov	ax,-8[bp]
shl	ax,*1
add	ax,2[bx]
mov	bx,ax
mov	bx,[bx]
! Debug: list * char = [bx+4] (used reg = )
push	4[bx]
! Debug: ptradd int j = [S+$12-$C] to [8] struct Table_Entry dir_table = [S+$12-$10] (used reg = )
mov	ax,-$A[bp]
mov	cx,#$200
imul	cx
add	ax,-$E[bp]
mov	bx,ax
! Debug: cast * char = const 0 to [$100] char = bx+0 (used reg = )
! Debug: list * char = bx+0 (used reg = )
push	bx
! Debug: func () int = strcmp+0 (used reg = )
call	_strcmp
add	sp,*4
! Debug: logeq int = const 0 to int = ax+0 (used reg = )
test	ax,ax
jne 	.41
.42:
! 160             {
! 161                 long index_sector = dir_table->entries[j].data_pointer[0];
add	sp,*-4
! Debug: ptradd int j = [S+$14-$C] to [8] struct Table_Entry dir_table = [S+$14-$10] (used reg = )
mov	ax,-$A[bp]
mov	cx,#$200
imul	cx
add	ax,-$E[bp]
mov	bx,ax
! Debug: ptradd int = const 0 to [$36] long = bx+$128 (used reg = )
! Debug: eq long = [bx+$128] to long index_sector = [S+$14-$14] (used reg = )
mov	ax,$128[bx]
mov	bx,$12A[bx]
mov	-$12[bp],ax
mov	-$10[bp],bx
!BCC_EOS
! 162                 
! 163 				
! 164                 disk_service_read_data_from_disk(index_sector, (long) 8   , dir_table, 0x7e0);
! Debug: list int = const $7E0 (used reg = )
mov	ax,#$7E0
push	ax
! Debug: list * struct Directory_Table dir_table = [S+$16-$10] (used reg = )
push	-$E[bp]
! Debug: list long = const 8 (used reg = )
mov	ax,*8
xor	bx,bx
push	bx
push	ax
! Debug: list long index_sector = [S+$1C-$14] (used reg = )
push	-$10[bp]
push	-$12[bp]
! Debug: func () int = disk_service_read_data_from_disk+0 (used reg = )
call	_disk_service_read_data_from_disk
add	sp,*$C
!BCC_EOS
! 165                 break;
add	sp,*4
jmp .3D
!BCC_EOS
! 166             }
add	sp,*4
! 167 
! 167         }
.41:
! 168     }
.3E:
! Debug: preinc int j = [S+$10-$C] (used reg = )
mov	ax,-$A[bp]
inc	ax
mov	-$A[bp],ax
.3F:
! Debug: lt int = const 8 to int j = [S+$10-$C] (used reg = )
mov	ax,-$A[bp]
cmp	ax,*8
jl 	.40
.43:
.3D:
! 169     return dir_table;
.3A:
! Debug: preinc int i = [S+$10-$A] (used reg = )
mov	ax,-8[bp]
inc	ax
mov	-8[bp],ax
.3B:
! Debug: lt int number_of_traversal = [S+$10-8] to int i = [S+$10-$A] (used reg = )
mov	ax,-8[bp]
cmp	ax,-6[bp]
blt 	.3C
.44:
.39:
mov	ax,-$E[bp]
add	sp,*$A
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 170 }
! 171 
! 172 int lsfs_disk_read_data_from_file(file, buffer_size, data, offset_to_next_entry, data_segment) 
! Register BX used in function lsfs_find_directory
! 173 lsfs_file *file;
export	_lsfs_disk_read_data_from_file
_lsfs_disk_read_data_from_file:
!BCC_EOS
! 174 unsigned int buffer_size; 
!BCC_EOS
! 175 char *data; 
!BCC_EOS
! 176 long offset_to_next_entry;
!BCC_EOS
! 177 unsigned int data_segment;
!BCC_EOS
! 178 {
! 179     unsigned int integer_file_size = file->size[0];
push	bp
mov	bp,sp
push	di
push	si
dec	sp
dec	sp
mov	bx,4[bp]
! Debug: ptradd int = const 0 to [2] unsigned long = bx+$18 (used reg = )
! Debug: eq unsigned long = [bx+$18] to unsigned int integer_file_size = [S+8-8] (used reg = )
mov	bx,$18[bx]
mov	-6[bp],bx
!BCC_EOS
! 180     unsigned int integer_offset = offset_to_next_entry;
dec	sp
dec	sp
! Debug: eq long offset_to_next_entry = [S+$A+8] to unsigned int integer_offset = [S+$A-$A] (used reg = )
mov	ax,$A[bp]
mov	-8[bp],ax
!BCC_EOS
! 181     unsigned int integer_datapointer = 0;
dec	sp
dec	sp
! Debug: eq int = const 0 to unsigned int integer_datapointer = [S+$C-$C] (used reg = )
xor	ax,ax
mov	-$A[bp],ax
!BCC_EOS
! 182     unsigned int data_length = integer_file_size - integer_offset;
dec	sp
dec	sp
! Debug: sub unsigned int integer_offset = [S+$E-$A] to unsigned int integer_file_size = [S+$E-8] (used reg = )
mov	ax,-6[bp]
sub	ax,-8[bp]
! Debug: eq unsigned int = ax+0 to unsigned int data_length = [S+$E-$E] (used reg = )
mov	-$C[bp],ax
!BCC_EOS
! 183     unsigned int amount_read = 0;
dec	sp
dec	sp
! Debug: eq int = const 0 to unsigned int amount_read = [S+$10-$10] (used reg = )
xor	ax,ax
mov	-$E[bp],ax
!BCC_EOS
! 184     unsigned int amount_to_read = 0;
dec	sp
dec	sp
! Debug: eq int = const 0 to unsigned int amount_to_read = [S+$12-$12] (used reg = )
xor	ax,ax
mov	-$10[bp],ax
!BCC_EOS
! 185     unsigned int remaining_offset = offset_to_next_entry;
dec	sp
dec	sp
! Debug: eq long offset_to_next_entry = [S+$14+8] to unsigned int remaining_offset = [S+$14-$14] (used reg = )
mov	ax,$A[bp]
mov	-$12[bp],ax
!BCC_EOS
! 186     void *next_data;
!BCC_EOS
! 187     
! 188     
! 189     
! 190 
! 191 
! 192     int data_pointer_index = 0; 
add	sp,*-4
! Debug: eq int = const 0 to int data_pointer_index = [S+$18-$18] (used reg = )
xor	ax,ax
mov	-$16[bp],ax
!BCC_EOS
! 193 
! 194     
! 195 
! 196     if (data_length > buffer_size)
! Debug: gt unsigned int buffer_size = [S+$18+4] to unsigned int data_length = [S+$18-$E] (used reg = )
mov	ax,-$C[bp]
cmp	ax,6[bp]
jbe 	.45
.46:
! 197     {
! 198         data_length = buffer_size;
! Debug: eq unsigned int buffer_size = [S+$18+4] to unsigned int data_length = [S+$18-$E] (used reg = )
mov	ax,6[bp]
mov	-$C[bp],ax
!BCC_EOS
! 199     }
! 200 
! 201     while(data_length > 0) 
.45:
! 202     {
br 	.48
.49:
! 203         
! 204         if (remaining_offset == 0)
! Debug: logeq int = const 0 to unsigned int remaining_offset = [S+$18-$14] (used reg = )
mov	ax,-$12[bp]
test	ax,ax
bne 	.4A
.4B:
! 205         {
! 206             char *tmp_buffer = calloc(8  , 512  );
dec	sp
dec	sp
! Debug: list int = const $200 (used reg = )
mov	ax,#$200
push	ax
! Debug: list int = const 8 (used reg = )
mov	ax,*8
push	ax
! Debug: func () * void = calloc+0 (used reg = )
call	_calloc
add	sp,*4
! Debug: eq * void = ax+0 to * char tmp_buffer = [S+$1A-$1A] (used reg = )
mov	-$18[bp],ax
!BCC_EOS
! 207             
! 208 
! 209             if (data_length < (8   * 512  )) 
! Debug: lt int = const $1000 to unsigned int data_length = [S+$1A-$E] (used reg = )
mov	ax,-$C[bp]
cmp	ax,#$1000
jae 	.4C
.4D:
! 210             {
! 211                 amount_to_read = data_length;
! Debug: eq unsigned int data_length = [S+$1A-$E] to unsigned int amount_to_read = [S+$1A-$12] (used reg = )
mov	ax,-$C[bp]
mov	-$10[bp],ax
!BCC_EOS
! 212             }
! 213             else 
! 214             {
jmp .4E
.4C:
! 215                 amount_to_read = (8   * 512  );
! Debug: eq int = const $1000 to unsigned int amount_to_read = [S+$1A-$12] (used reg = )
mov	ax,#$1000
mov	-$10[bp],ax
!BCC_EOS
! 216             }
! 217             
! 218             integer_datapointer = file->data_pointer[data_pointer_index];
.4E:
mov	bx,4[bp]
! Debug: ptradd int data_pointer_index = [S+$1A-$18] to [$36] long = bx+$44 (used reg = )
mov	ax,-$16[bp]
shl	ax,*1
shl	ax,*1
add	bx,ax
! Debug: eq long = [bx+$44] to unsigned int integer_datapointer = [S+$1A-$C] (used reg = )
mov	bx,$44[bx]
mov	-$A[bp],bx
!BCC_EOS
! 219             if (integer_datapointer == 0) 
! Debug: logeq int = const 0 to unsigned int integer_datapointer = [S+$1A-$C] (used reg = )
mov	ax,-$A[bp]
test	ax,ax
jne 	.4F
.50:
! 220             {
! 221                 break;
inc	sp
inc	sp
br 	.47
!BCC_EOS
! 222             }
! 223             next_data = data + amount_read;
.4F:
! Debug: ptradd unsigned int amount_read = [S+$1A-$10] to * char data = [S+$1A+6] (used reg = )
mov	ax,-$E[bp]
add	ax,8[bp]
! Debug: eq * char = ax+0 to * void next_data = [S+$1A-$16] (used reg = )
mov	-$14[bp],ax
!BCC_EOS
! 224             disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], (long) 8  , next_data, data_segment);
! Debug: list unsigned int data_segment = [S+$1A+$C] (used reg = )
push	$E[bp]
! Debug: list * void next_data = [S+$1C-$16] (used reg = )
push	-$14[bp]
! Debug: list long = const 8 (used reg = )
mov	ax,*8
xor	bx,bx
push	bx
push	ax
mov	bx,4[bp]
! Debug: ptradd int data_pointer_index = [S+$22-$18] to [$36] long = bx+$44 (used reg = )
mov	ax,-$16[bp]
shl	ax,*1
shl	ax,*1
add	bx,ax
! Debug: list long = [bx+$44] (used reg = )
push	$46[bx]
push	$44[bx]
! Debug: func () int = disk_service_read_data_from_disk+0 (used reg = )
call	_disk_service_read_data_from_disk
add	sp,*$C
!BCC_EOS
! 225             
! 226             
! 227             
! 228             data_length -= amount_to_read;
! Debug: subab unsigned int amount_to_read = [S+$1A-$12] to unsigned int data_length = [S+$1A-$E] (used reg = )
mov	ax,-$C[bp]
sub	ax,-$10[bp]
mov	-$C[bp],ax
!BCC_EOS
! 229             amount_read += amount_to_read;
! Debug: addab unsigned int amount_to_read = [S+$1A-$12] to unsigned int amount_read = [S+$1A-$10] (used reg = )
mov	ax,-$E[bp]
add	ax,-$10[bp]
mov	-$E[bp],ax
!BCC_EOS
! 230             data_pointer_index = data_pointer_index + 2; 
! Debug: add int = const 2 to int data_pointer_index = [S+$1A-$18] (used reg = )
mov	ax,-$16[bp]
! Debug: eq int = ax+2 to int data_pointer_index = [S+$1A-$18] (used reg = )
inc	ax
inc	ax
mov	-$16[bp],ax
!BCC_EOS
! 231             
! 232         }
inc	sp
inc	sp
! 233         else if (remaining_offset < (8   * 512  )) 
br 	.51
.4A:
! Debug: lt int = const $1000 to unsigned int remaining_offset = [S+$18-$14] (used reg = )
mov	ax,-$12[bp]
cmp	ax,#$1000
bhis	.52
.53:
! 234         {
! 235             char *tmp_buffer = calloc(1, (8   * 512  ));
dec	sp
dec	sp
! Debug: list int = const $1000 (used reg = )
mov	ax,#$1000
push	ax
! Debug: list int = const 1 (used reg = )
mov	ax,*1
push	ax
! Debug: func () * void = calloc+0 (used reg = )
call	_calloc
add	sp,*4
! Debug: eq * void = ax+0 to * char tmp_buffer = [S+$1A-$1A] (used reg = )
mov	-$18[bp],ax
!BCC_EOS
! 236             
! 237 
! 238             if (data_length < ((8   * 512  ) - remaining_offset) ) 
! Debug: sub unsigned int remaining_offset = [S+$1A-$14] to int = const $1000 (used reg = )
mov	ax,#$1000
sub	ax,-$12[bp]
! Debug: lt unsigned int = ax+0 to unsigned int data_length = [S+$1A-$E] (used reg = )
cmp	ax,-$C[bp]
jbe 	.54
.55:
! 239             {
! 240                 amount_to_read = data_length;
! Debug: eq unsigned int data_length = [S+$1A-$E] to unsigned int amount_to_read = [S+$1A-$12] (used reg = )
mov	ax,-$C[bp]
mov	-$10[bp],ax
!BCC_EOS
! 241             }
! 242             else 
! 243             {
jmp .56
.54:
! 244                 amount_to_read = ((8   * 512  ) - remaining_off
! 244 set);
! Debug: sub unsigned int remaining_offset = [S+$1A-$14] to int = const $1000 (used reg = )
mov	ax,#$1000
sub	ax,-$12[bp]
! Debug: eq unsigned int = ax+0 to unsigned int amount_to_read = [S+$1A-$12] (used reg = )
mov	-$10[bp],ax
!BCC_EOS
! 245             }
! 246 
! 247             disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], (long) 8  , tmp_buffer, 0x7e0);
.56:
! Debug: list int = const $7E0 (used reg = )
mov	ax,#$7E0
push	ax
! Debug: list * char tmp_buffer = [S+$1C-$1A] (used reg = )
push	-$18[bp]
! Debug: list long = const 8 (used reg = )
mov	ax,*8
xor	bx,bx
push	bx
push	ax
mov	bx,4[bp]
! Debug: ptradd int data_pointer_index = [S+$22-$18] to [$36] long = bx+$44 (used reg = )
mov	ax,-$16[bp]
shl	ax,*1
shl	ax,*1
add	bx,ax
! Debug: list long = [bx+$44] (used reg = )
push	$46[bx]
push	$44[bx]
! Debug: func () int = disk_service_read_data_from_disk+0 (used reg = )
call	_disk_service_read_data_from_disk
add	sp,*$C
!BCC_EOS
! 248 
! 249             memcpy(data, data_segment, (tmp_buffer + remaining_offset), 0x7e0, amount_to_read);
! Debug: list unsigned int amount_to_read = [S+$1A-$12] (used reg = )
push	-$10[bp]
! Debug: list int = const $7E0 (used reg = )
mov	ax,#$7E0
push	ax
! Debug: ptradd unsigned int remaining_offset = [S+$1E-$14] to * char tmp_buffer = [S+$1E-$1A] (used reg = )
mov	ax,-$12[bp]
add	ax,-$18[bp]
! Debug: list * char = ax+0 (used reg = )
push	ax
! Debug: list unsigned int data_segment = [S+$20+$C] (used reg = )
push	$E[bp]
! Debug: list * char data = [S+$22+6] (used reg = )
push	8[bp]
! Debug: func () void = memcpy+0 (used reg = )
call	_memcpy
add	sp,*$A
!BCC_EOS
! 250             data_length -= amount_to_read;
! Debug: subab unsigned int amount_to_read = [S+$1A-$12] to unsigned int data_length = [S+$1A-$E] (used reg = )
mov	ax,-$C[bp]
sub	ax,-$10[bp]
mov	-$C[bp],ax
!BCC_EOS
! 251             amount_read += amount_to_read;
! Debug: addab unsigned int amount_to_read = [S+$1A-$12] to unsigned int amount_read = [S+$1A-$10] (used reg = )
mov	ax,-$E[bp]
add	ax,-$10[bp]
mov	-$E[bp],ax
!BCC_EOS
! 252             remaining_offset -= amount_to_read;
! Debug: subab unsigned int amount_to_read = [S+$1A-$12] to unsigned int remaining_offset = [S+$1A-$14] (used reg = )
mov	ax,-$12[bp]
sub	ax,-$10[bp]
mov	-$12[bp],ax
!BCC_EOS
! 253 
! 254             data_pointer_index = data_pointer_index + 2; 
! Debug: add int = const 2 to int data_pointer_index = [S+$1A-$18] (used reg = )
mov	ax,-$16[bp]
! Debug: eq int = ax+2 to int data_pointer_index = [S+$1A-$18] (used reg = )
inc	ax
inc	ax
mov	-$16[bp],ax
!BCC_EOS
! 255             
! 256         }
inc	sp
inc	sp
! 257         else 
! 258         {
jmp .57
.52:
! 259             
! 260             remaining_offset -= (8   * 512  );
! Debug: subab int = const $1000 to unsigned int remaining_offset = [S+$18-$14] (used reg = )
mov	ax,-$12[bp]
add	ax,#-$1000
mov	-$12[bp],ax
!BCC_EOS
! 261             data_pointer_index = data_pointer_index + 2;
! Debug: add int = const 2 to int data_pointer_index = [S+$18-$18] (used reg = )
mov	ax,-$16[bp]
! Debug: eq int = ax+2 to int data_pointer_index = [S+$18-$18] (used reg = )
inc	ax
inc	ax
mov	-$16[bp],ax
!BCC_EOS
! 262         }
! 263 
! 264     }
.57:
.51:
! 265 # 269
! 269     
! 270     return amount_read;
.48:
! Debug: gt int = const 0 to unsigned int data_length = [S+$18-$E] (used reg = )
mov	ax,-$C[bp]
test	ax,ax
bne 	.49
.58:
.47:
mov	ax,-$E[bp]
add	sp,*$12
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 271 
! 272 }
! 273 # 3 "main.c"
! 3 int main(selector, pointer_parameter_segment, pointer_parameter_struct) 
! Register BX used in function lsfs_disk_read_data_from_file
! 4 int selector;
export	_main
_main:
!BCC_EOS
! 5 void* pointer_parameter_segment;
!BCC_EOS
! 6 void* pointer_parameter_struct;
!BCC_EOS
! 7 {
! 8     
! 9     
! 10     
! 11     
! 12     Service_Action service_action;
!BCC_EOS
! 13     Directory_Table current_table;
!BCC_EOS
! 14     Parameter_Struct parameter_struct;
!BCC_EOS
! 15     int* local_segment; 
!BCC_EOS
! 16     unsigned int heap_start = 0x2200;
push	bp
mov	bp,sp
push	di
push	si
add	sp,#-$1016
! Debug: eq int = const $2200 to unsigned int heap_start = [S+$101C-$101C] (used reg = )
mov	ax,#$2200
mov	-$101A[bp],ax
!BCC_EOS
! 17     unsigned int heap_end = 0xffff;
dec	sp
dec	sp
! Debug: eq unsigned int = const $FFFF to unsigned int heap_end = [S+$101E-$101E] (used reg = )
mov	ax,#$FFFF
mov	-$101C[bp],ax
!BCC_EOS
! 18     int stack_segment = 0x8fc0;
dec	sp
dec	sp
! Debug: eq unsigned int = const $8FC0 to int stack_segment = [S+$1020-$1020] (used reg = )
mov	ax,#$8FC0
mov	-$101E[bp],ax
!BCC_EOS
! 19     int path_length;
!BCC_EOS
! 20     long index_as_long = 0; 
add	sp,*-6
! Debug: eq int = const 0 to long index_as_long = [S+$1026-$1026] (used reg = )
xor	ax,ax
xor	bx,bx
mov	-$1024[bp],ax
mov	-$1022[bp],bx
!BCC_EOS
! 21 
! 22     char *local_path = 0; 
dec	sp
dec	sp
! Debug: eq int = const 0 to * char local_path = [S+$1028-$1028] (used reg = )
xor	ax,ax
mov	-$1026[bp],ax
!BCC_EOS
! 23     FSCI *fsci = global_heap_start - 0x200;
dec	sp
dec	sp
! Debug: sub int = const $200 to unsigned int = [global_heap_start+0] (used reg = )
mov	ax,[_global_heap_start]
! Debug: eq unsigned int = ax-$200 to * struct File_System_Control_Information fsci = [S+$102A-$102A] (used reg = )
add	ax,#-$200
mov	-$1028[bp],ax
!BCC_EOS
! 24     service_action = selector;
! Debug: eq int selector = [S+$102A+2] to int service_action = [S+$102A-8] (used reg = )
mov	ax,4[bp]
mov	-6[bp],ax
!BCC_EOS
! 25 
! 26     switch (service_action)
mov	ax,-6[bp]
! 27     {
br 	.5B
! 28         case SERIVCE_LOAD_DISK: 
! 29         {
.5C:
! 30 
! 31 
! 32 
! 33             
! 34             memcpy(&parameter_struct, stack_segment, pointer_parameter_struct, pointer_parameter_segment, sizeof(Parameter_Struct));
! Debug: list int = const $10 (used reg = )
mov	ax,*$10
push	ax
! Debug: list * void pointer_parameter_segment = [S+$102C+4] (used reg = )
push	6[bp]
! Debug: list * void pointer_parameter_struct = [S+$102E+6] (used reg = )
push	8[bp]
! Debug: list int stack_segment = [S+$1030-$1020] (used reg = )
push	-$101E[bp]
! Debug: list * struct Parameter_Struct parameter_struct = S+$1032-$1018 (used reg = )
lea	bx,-$1016[bp]
push	bx
! Debug: func () void = memcpy+0 (used reg = )
call	_memcpy
add	sp,*$A
!BCC_EOS
! 35              
! 36             local_segment = parameter_struct.buffer_segment;
! Debug: eq unsigned int parameter_struct = [S+$102A-$1014] to * int local_segment = [S+$102A-$101A] (used reg = )
mov	bx,-$1012[bp]
mov	-$1018[bp],bx
!BCC_EOS
! 37             heap_start    = parameter_struct.buffer_address + 0x200;
! Debug: add int = const $200 to unsigned int parameter_struct = [S+$102A-$1012] (used reg = )
mov	ax,-$1010[bp]
! Debug: eq unsigned int = ax+$200 to unsigned int heap_start = [S+$102A-$101C] (used reg = )
add	ax,#$200
mov	-$101A[bp],ax
!BCC_EOS
! 38             heap_end      = parameter_struct.buffer_size;
! Debug: eq unsigned int parameter_struct = [S+$102A-$1010] to unsigned int heap_end = [S+$102A-$101E] (used reg = )
mov	ax,-$100E[bp]
mov	-$101C[bp],ax
!BCC_EOS
! 39             index_as_long = parameter_struct.data_length;
! Debug: eq unsigned int parameter_struct = [S+$102A-$100E] to long index_as_long = [S+$102A-$1026] (used reg = )
mov	ax,-$100C[bp]
xor	bx,bx
mov	-$1024[bp],ax
mov	-$1022[bp],bx
!BCC_EOS
! 40             set_heap_settings(heap_start, heap_end);
! Debug: list unsigned int heap_end = [S+$102A-$101E] (used reg = )
push	-$101C[bp]
! Debug: list unsigned int heap_start = [S+$102C-$101C] (used reg = )
push	-$101A[bp]
! Debug: func () int = set_heap_settings+0 (used reg = )
call	_set_heap_settings
add	sp,*4
!BCC_EOS
! 41             fsci = global_heap_start - 0x200;
! Debug: sub int = const $200 to unsigned int = [global_heap_start+0] (used reg = )
mov	ax,[_global_heap_start]
! Debug: eq unsigned int = ax-$200 to * struct File_System_Control_Information fsci = [S+$102A-$102A] (used reg = )
add	ax,#-$200
mov	-$1028[bp],ax
!BCC_EOS
! 42             disk_service_read_data_from_disk(index_as_long, (long) 1, fsci, local_segment);
! Debug: list * int local_segment = [S+$102A-$101A] (used reg = )
push	-$1018[bp]
! Debug: list * struct File_System_Control_Information fsci = [S+$102C-$102A] (used reg = )
push	-$1028[bp]
! Debug: list long = const 1 (used reg = )
mov	ax,*1
xor	bx,bx
push	bx
push	ax
! Debug: list long index_as_long = [S+$1032-$1026] (used reg = )
push	-$1022[bp]
push	-$1024[bp]
! Debug: func () int = disk_service_read_data_from_disk+0 (used reg = )
call	_disk_service_read_data_from_disk
add	sp,*$C
!BCC_EOS
! 43             print("File System has been loaded: ");
! Debug: list * char = .5D+0 (used reg = )
mov	bx,#.5D
push	bx
! Debug: func () void = print+0 (used reg = )
call	_print
inc	sp
inc	sp
!BCC_EOS
! 44             print_newline();
! Debug: func () void = print_newline+0 (used reg = )
call	_print_newline
!BCC_EOS
! 45             print(fsci->filesystem_information);
! Debug: cast * char = const 0 to [$100] char fsci = [S+$102A-$102A] (used reg = )
! Debug: list * char fsci = [S+$102A-$102A] (used reg = )
push	-$1028[bp]
! Debug: func () void = print+0 (used reg = )
call	_print
inc	sp
inc	sp
!BCC_EOS
! 46             p
! 46 rint("16-bit implementation v0.2.1");
! Debug: list * char = .5E+0 (used reg = )
mov	bx,#.5E
push	bx
! Debug: func () void = print+0 (used reg = )
call	_print
inc	sp
inc	sp
!BCC_EOS
! 47             print_newline();
! Debug: func () void = print_newline+0 (used reg = )
call	_print_newline
!BCC_EOS
! 48         } break;
br 	.59
!BCC_EOS
! 49         case SERVICE_FIND_ENTRY:
! 50         {
.5F:
! 51             String_Array *path_array;
!BCC_EOS
! 52             lsfs_file* find_file;
!BCC_EOS
! 53             int i;
!BCC_EOS
! 54             disk_service_read_data_from_disk(fsci->master_table_index[0], (long) 8   , &current_table, stack_segment);
! Debug: list int stack_segment = [S+$1030-$1020] (used reg = )
push	-$101E[bp]
! Debug: list * struct Directory_Table current_table = S+$1032-$1008 (used reg = )
lea	bx,-$1006[bp]
push	bx
! Debug: list long = const 8 (used reg = )
mov	ax,*8
xor	bx,bx
push	bx
push	ax
mov	bx,-$1028[bp]
! Debug: ptradd int = const 0 to [2] long = bx+$100 (used reg = )
! Debug: list long = [bx+$100] (used reg = )
push	$102[bx]
push	$100[bx]
! Debug: func () int = disk_service_read_data_from_disk+0 (used reg = )
call	_disk_service_read_data_from_disk
add	sp,*$C
!BCC_EOS
! 55 # 64
! 64             
! 65             
! 66             memcpy(&parameter_struct, stack_segment, pointer_parameter_struct, pointer_parameter_segment, sizeof(Parameter_Struct));
! Debug: list int = const $10 (used reg = )
mov	ax,*$10
push	ax
! Debug: list * void pointer_parameter_segment = [S+$1032+4] (used reg = )
push	6[bp]
! Debug: list * void pointer_parameter_struct = [S+$1034+6] (used reg = )
push	8[bp]
! Debug: list int stack_segment = [S+$1036-$1020] (used reg = )
push	-$101E[bp]
! Debug: list * struct Parameter_Struct parameter_struct = S+$1038-$1018 (used reg = )
lea	bx,-$1016[bp]
push	bx
! Debug: func () void = memcpy+0 (used reg = )
call	_memcpy
add	sp,*$A
!BCC_EOS
! 67             path_length = strlen(parameter_struct.path, pointer_parameter_segment); 
! Debug: list * void pointer_parameter_segment = [S+$1030+4] (used reg = )
push	6[bp]
! Debug: list * char parameter_struct = [S+$1032-$1018] (used reg = )
push	-$1016[bp]
! Debug: func () int = strlen+0 (used reg = )
call	_strlen
add	sp,*4
! Debug: eq int = ax+0 to int path_length = [S+$1030-$1022] (used reg = )
mov	-$1020[bp],ax
!BCC_EOS
! 68             local_path = malloc(256);
! Debug: list int = const $100 (used reg = )
mov	ax,#$100
push	ax
! Debug: func () * void = malloc+0 (used reg = )
call	_malloc
inc	sp
inc	sp
! Debug: eq * void = ax+0 to * char local_path = [S+$1030-$1028] (used reg = )
mov	-$1026[bp],ax
!BCC_EOS
! 69             memcpy(local_path, local_segment, parameter_struct.path, pointer_parameter_segment, path_length);
! Debug: list int path_length = [S+$1030-$1022] (used reg = )
push	-$1020[bp]
! Debug: list * void pointer_parameter_segment = [S+$1032+4] (used reg = )
push	6[bp]
! Debug: list * char parameter_struct = [S+$1034-$1018] (used reg = )
push	-$1016[bp]
! Debug: list * int local_segment = [S+$1036-$101A] (used reg = )
push	-$1018[bp]
! Debug: list * char local_path = [S+$1038-$1028] (used reg = )
push	-$1026[bp]
! Debug: func () void = memcpy+0 (used reg = )
call	_memcpy
add	sp,*$A
!BCC_EOS
! 70             local_path[path_length] = 0; 
! Debug: ptradd int path_length = [S+$1030-$1022] to * char local_path = [S+$1030-$1028] (used reg = )
mov	ax,-$1020[bp]
add	ax,-$1026[bp]
mov	bx,ax
! Debug: eq int = const 0 to char = [bx+0] (used reg = )
xor	al,al
mov	[bx],al
!BCC_EOS
! 71             print("Read file: ");
! Debug: list * char = .60+0 (used reg = )
mov	bx,#.60
push	bx
! Debug: func () void = print+0 (used reg = )
call	_print
inc	sp
inc	sp
!BCC_EOS
! 72             print(local_path);
! Debug: list * char local_path = [S+$1030-$1028] (used reg = )
push	-$1026[bp]
! Debug: func () void = print+0 (used reg = )
call	_print
inc	sp
inc	sp
!BCC_EOS
! 73             print_newline();
! Debug: func () void = print_newline+0 (used reg = )
call	_print_newline
!BCC_EOS
! 74 
! 75             path_array = string_split_c(local_path, '/', 0);
! Debug: list int = const 0 (used reg = )
xor	ax,ax
push	ax
! Debug: list int = const $2F (used reg = )
mov	ax,*$2F
push	ax
! Debug: list * char local_path = [S+$1034-$1028] (used reg = )
push	-$1026[bp]
! Debug: func () * struct String_Array = string_split_c+0 (used reg = )
call	_string_split_c
add	sp,*6
! Debug: eq * struct String_Array = ax+0 to * struct String_Array path_array = [S+$1030-$102C] (used reg = )
mov	-$102A[bp],ax
!BCC_EOS
! 76 
! 77             find_file = calloc(sizeof(lsfs_file), 1);
! Debug: list int = const 1 (used reg = )
mov	ax,*1
push	ax
! Debug: list int = const $11C (used reg = )
mov	ax,#$11C
push	ax
! Debug: func () * void = calloc+0 (used reg = )
call	_calloc
add	sp,*4
! Debug: eq * void = ax+0 to * struct lsfs_file find_file = [S+$1030-$102E] (used reg = )
mov	-$102C[bp],ax
!BCC_EOS
! 78             if ( !lsfs_disk_getattr(find_file, local_path, fsci) ) 
! Debug: list * struct File_System_Control_Information fsci = [S+$1030-$102A] (used reg = )
push	-$1028[bp]
! Debug: list * char local_path = [S+$1032-$1028] (used reg = )
push	-$1026[bp]
! Debug: list * struct lsfs_file find_file = [S+$1034-$102E] (used reg = )
push	-$102C[bp]
! Debug: func () int = lsfs_disk_getattr+0 (used reg = )
call	_lsfs_disk_getattr
add	sp,*6
test	ax,ax
jne 	.61
.62:
! 79             {
! 80                 print("File not found");
! Debug: list * char = .63+0 (used reg = )
mov	bx,#.63
push	bx
! Debug: func () void = print+0 (used reg = )
call	_print
inc	sp
inc	sp
!BCC_EOS
! 81                 print_newline();
! Debug: func () void = print_newline+0 (used reg = )
call	_print_newline
!BCC_EOS
! 82             }
! 83             else
! 84             {
jmp .64
.61:
! 85                 print("File has been read");
! Debug: list * char = .65+0 (used reg = )
mov	bx,#.65
push	bx
! Debug: func () void = print+0 (used reg = )
call	_print
inc	sp
inc	sp
!BCC_EOS
! 86                 print_newline();
! Debug: func () void = print_newline+0 (used reg = )
call	_print_newline
!BCC_EOS
! 87             }
! 88 # 95
! 95             
! 96             lsfs_disk_read_data_from_file(find_file, parameter_struct.buffer_size, parameter_struct.buffer_address, (long) 0x0, parameter_struct.buffer_segment);
.64:
! Debug: list unsigned int parameter_struct = [S+$1030-$1014] (used reg = )
push	-$1012[bp]
! Debug: list long = const 0 (used reg = )
xor	ax,ax
xor	bx,bx
push	bx
push	ax
! Debug: list unsigned int parameter_struct = [S+$1036-$1012] (used reg = )
push	-$1010[bp]
! Debug: list unsigned int parameter_struct = [S+$1038-$1010] (used reg = )
push	-$100E[bp]
! Debug: list * struct lsfs_file find_file = [S+$103A-$102E] (used reg = )
push	-$102C[bp]
! Debug: func () int = lsfs_disk_read_data_from_file+0 (used reg = )
call	_lsfs_disk_read_data_from_file
add	sp,*$C
!BCC_EOS
! 97             
! 98 
! 99         } break;
jmp .59
!BCC_EOS
! 100         case SERIVCE_READ_DATA: 
! 101         {
.66:
! 102 # 110
! 110             
! 111             print("Hit READ case");
! Debug: list * char = .67+0 (used reg = )
mov	bx,#.67
push	bx
! Debug: func () void = print+0 (used reg = )
call	_print
inc	sp
inc	sp
!BCC_EOS
! 112         } break;
jmp .59
!BCC_EOS
! 113         case SERIVCE_WRITE_DATA:
! 114         {
.68:
! 115             print("Hit WRITE case");
! Debug: list * char = .69+0 (used reg = )
mov	bx,#.69
push	bx
! Debug: func () void = print+0 (used reg = )
call	_print
inc	sp
inc	sp
!BCC_EOS
! 116         } break;
jmp .59
!BCC_EOS
! 117         case SERIVCE_WRITE_FS_INFO:
! 118         {
.6A:
! 119             
! 120             print(fsci->filesystem_information);
! Debug: cast * char = const 0 to [$100] char fsci = [S+$102A-$102A] (used reg = )
! Debug: list * char fsci = [S+$102A-$102A] (used reg = )
push	-$1028[bp]
! Debug: func () void = print+0 (used reg = )
call	_print
inc	sp
inc	sp
!BCC_EOS
! 121             
! 122         } break;
jmp .59
!BCC_EOS
! 123 
! 124         default: 
! 125         {
.6B:
! 126             print("Default case: ");
! Debug: list * char = .6C+0 (used reg = )
mov	bx,#.6C
push	bx
! Debug: func () void = print+0 (used reg = )
call	_print
inc	sp
inc	sp
!BCC_EOS
! 127             dump_ax(service_action);
! Debug: list int service_action = [S+$102A-8] (used reg = )
push	-6[bp]
! Debug: func () void = dump_ax+0 (used reg = )
call	_dump_ax
inc	sp
inc	sp
!BCC_EOS
! 128         }
! 129     } 
! 130     
! 131     return 0;
jmp .59
.5B:
add	sp,*-6
sub	ax,*1
beq 	.5C
sub	ax,*1
beq 	.5F
sub	ax,*1
je 	.66
sub	ax,*1
je 	.68
sub	ax,*6
je 	.6A
jmp	.6B
.59:
..FFFF	=	-$1030
add	sp,*6
xor	ax,ax
lea	sp,-4[bp]
pop	si
pop	di
pop	bp
ret
!BCC_EOS
! 132 
! 133 }
! 134 
! Register BX used in function main
.6C:
.6D:
.ascii	"Default case: "
.byte	0
.69:
.6E:
.ascii	"Hit WRITE case"
.byte	0
.67:
.6F:
.ascii	"Hit READ case"
.byte	0
.65:
.70:
.ascii	"File has been read"
.byte	0
.63:
.71:
.ascii	"File not found"
.byte	0
.60:
.72:
.ascii	"Read file: "
.byte	0
.5E:
.73:
.ascii	"16-bit implementation v0.2.1"
.byte	0
.5D:
.74:
.ascii	"File System has been loaded: "
.byte	0
.bss

! 0 errors detected