SingOS
/
lsfs_16-bit


								push bp

								mov bp,sp

								push 10[bp]

								push 8[bp]

								push 6[bp]

								call _main

								add sp, #0x6

								pop bp

								retf

								 ! 1

								! 1 # 1 "main.c"

								! 1 # 1 "std_singos/stdio.h"

								! 1 void print(string);

								!BCC_EOS

								! 2 void* dump_ax_return(input);

								!BCC_EOS

								! 3

								! 4 void print(string)

								! 5 char* string;

								export	_print

								_print:

								!BCC_EOS

								! 6 {

								! 7 #asm

								!BCC_ASM

								_print.string	set	2


								    push bp

								    mov bp,sp

								    mov si,4[bp]

								    call 0x0000:0x7C47

								    pop bp

								! 13 endasm

								!BCC_ENDASM

								! 14 }

								ret

								! 15

								! 16 void print_stack(argument)

								! 17 {

								export	_print_stack

								_print_stack:

								! 18 #asm

								!BCC_ASM

								_print_stack.argument	set	2


								    push bp

								    mov bp,sp

								    push ds

								    push ax


								    mov ax, ss

								    mov ds, ax

								    mov si,4[bp]

								    call 0x0000:0x7C47


								    pop ax

								    pop ds

								    pop bp

								! 32 endasm

								!BCC_ENDASM

								! 33 }

								ret

								! 34

								! 35 void* dump_ax_return(input)

								! 36 void* input;

								export	_dump_ax_return

								_dump_ax_return:

								!BCC_EOS

								! 37 {

								! 38     return input;

								push	bp

								mov	bp,sp

								push	di

								push	si

								mov	ax,4[bp]

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 39 }

								! 40

								! 41 void dump_ax(input)

								! 42 void* input;

								export	_dump_ax

								_dump_ax:

								!BCC_EOS

								! 43 {

								! 44     dump_ax_return(input)

								push	bp

								mov	bp,sp

								push	di

								push	si

								! 45 #asm

								! Debug: list * void input = [S+6+2] (used reg = )

								push	4[bp]

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

								call	_dump_ax_return

								inc	sp

								inc	sp

								!BCC_EOS

								!BCC_ASM

								_dump_ax.input	set	8

								.dump_ax.input	set	4

								    push bp

								    mov bp,sp

								    call 0x000:0x7C2A

								    pop bp

								! 50 endasm

								!BCC_ENDASM

								!BCC_EOS

								! 51 }

								pop	si

								pop	di

								pop	bp

								ret

								! 52

								! 53 void print_newline()

								! 54 {

								export	_print_newline

								_print_newline:

								! 55 #asm

								!BCC_ASM


								    printCRLF:

								    mov ah, #0xE

								    mov al, #13

								    int #0x10

								    mov al, #10

								    int #0x10

								    ret

								! 63 endasm

								!BCC_ENDASM

								! 64 }

								ret

								! 65 # 1 "std_singos/stdlib.h"

								! 1 unsigned int global_heap_start = 0;

								export	_global_heap_start

								_global_heap_start:

								.word	0

								!BCC_EOS

								! 2 unsigned int global_heap_end = 0;

								export	_global_heap_end

								_global_heap_end:

								.word	0

								!BCC_EOS

								! 3 unsigned int global_heap_next = 0;

								export	_global_heap_next

								_global_heap_next:

								.word	0

								!BCC_EOS

								! 4

								! 5 void* malloc(num_bytes);

								!BCC_EOS

								! 6 void* calloc(number_elements, size);

								!BCC_EOS

								! 7 int set_heap_settings(param_start, param_end);

								!BCC_EOS

								! 8 unsigned int get_heap_next();

								!BCC_EOS

								! 9

								! 10 void* malloc(num_bytes)

								! 11 int num_bytes;

								.text

								export	_malloc

								_malloc:

								!BCC_EOS

								! 12 {

								! 13 	unsigned int allocated_pointer = global_heap_next;

								push	bp

								mov	bp,sp

								push	di

								push	si

								dec	sp

								dec	sp

								! Debug: eq unsigned int = [global_heap_next+0] to unsigned int allocated_pointer = [S+8-8] (used reg = )

								mov	ax,[_global_heap_next]

								mov	-6[bp],ax

								!BCC_EOS

								! 14 	global_heap_next = global_heap_next + num_bytes;

								! Debug: add int num_bytes = [S+8+2] to unsigned int = [global_heap_next+0] (used reg = )

								mov	ax,[_global_heap_next]

								add	ax,4[bp]

								! Debug: eq unsigned int = ax+0 to unsigned int = [global_heap_next+0] (used reg = )

								mov	[_global_heap_next],ax

								!BCC_EOS

								! 15 	if (global_heap_next > global_heap_end)

								! Debug: gt unsigned int = [global_heap_end+0] to unsigned int = [global_heap_next+0] (used reg = )

								mov	ax,[_global_heap_next]

								cmp	ax,[_global_heap_end]

								jbe 	.1

								.2:

								! 16 	{

								! 17 		return 0;

								xor	ax,ax

								inc	sp

								inc	sp

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 18 	}

								! 19

								! 20 	return allocated_pointer;

								.1:

								mov	ax,-6[bp]

								inc	sp

								inc	sp

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 21 }

								! 22

								! 23 void* calloc(number_elements, size)

								! 24 unsigned int number_elements;

								export	_calloc

								_calloc:

								!BCC_EOS

								! 25 unsigned int size;

								!BCC_EOS

								! 26 {

								! 27 	int i;

								!BCC_EOS

								! 28 	char* temp_pointer;

								!BCC_EOS

								! 29 	unsigned int num_bytes = number_elements * size;

								push	bp

								mov	bp,sp

								push	di

								push	si

								add	sp,*-6

								! Debug: mul unsigned int size = [S+$C+4] to unsigned int number_elements = [S+$C+2] (used reg = )

								mov	ax,4[bp]

								mov	cx,6[bp]

								imul	cx

								! Debug: eq unsigned int = ax+0 to unsigned int num_bytes = [S+$C-$C] (used reg = )

								mov	-$A[bp],ax

								!BCC_EOS

								! 30 	void* allocated_pointer = global_heap_next;

								dec	sp

								dec	sp

								! Debug: eq unsigned int = [global_heap_next+0] to * void allocated_pointer = [S+$E-$E] (used reg = )

								mov	bx,[_global_heap_next]

								mov	-$C[bp],bx

								!BCC_EOS

								! 31 	global_heap_next = global_heap_next + num_bytes;

								! Debug: add unsigned int num_bytes = [S+$E-$C] to unsigned int = [global_heap_next+0] (used reg = )

								mov	ax,[_global_heap_next]

								add	ax,-$A[bp]

								! Debug: eq unsigned int = ax+0 to unsigned int = [global_heap_next+0] (used reg = )

								mov	[_global_heap_next],ax

								!BCC_EOS

								! 32 	if (global_heap_next > global_heap_end)

								! Debug: gt unsigned int = [global_heap_end+0] to unsigned int = [global_heap_next+0] (used reg = )

								mov	ax,[_global_heap_next]

								cmp	ax,[_global_heap_end]

								jbe 	.3

								.4:

								! 33 	{

								! 34 		return 0;

								xor	ax,ax

								add	sp,*8

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 35 	}

								! 36

								! 37

								! 38 	temp_pointer = allocated_pointer;

								.3:

								! Debug: eq * void allocated_pointer = [S+$E-$E] to * char temp_pointer = [S+$E-$A] (used reg = )

								mov	bx,-$C[bp]

								mov	-8[bp],bx

								!BCC_EOS

								! 39 	for (i = 0; i < num_bytes; ++i)

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

								xor	ax,ax

								mov	-6[bp],ax

								!BCC_EOS

								!BCC_EOS

								! 40 	{

								jmp .7

								.8:

								! 41 		*temp_pointer = 0;

								mov	bx,-8[bp]

								! Debug: eq int = const 0 to char = [bx+0] (used reg = )

								xor	al,al

								mov	[bx],al

								!BCC_EOS

								! 42 		temp_pointer++;

								! Debug: postinc * char temp_pointer = [S+$E-$A] (used reg = )

								mov	bx,-8[bp]

								inc	bx

								mov	-8[bp],bx

								!BCC_EOS

								! 43 	}

								! 44

								! 45 	return allocated_pointer;

								.6:

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

								mov	ax,-6[bp]

								inc	ax

								mov	-6[bp],ax

								.7:

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

								mov	ax,-6[bp]

								cmp	ax,-$A[bp]

								jb 	.8

								.9:

								.5:

								mov	ax,-$C[bp]

								add	sp,*8

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 46 }

								! 47

								! 48 int set_heap_settings(param_start, param_end)

								! Register BX used in function calloc

								! 49 unsigned int param_start;

								export	_set_heap_settings

								_set_heap_settings:

								!BCC_EOS

								! 50 unsigned int param_end;

								!BCC_EOS

								! 51 {

								! 52 	global_heap_start = param_start;

								push	bp

								mov	bp,sp

								push	di

								push	si

								! Debug: eq unsigned int param_start = [S+6+2] to unsigned int = [global_heap_start+0] (used reg = )

								mov	ax,4[bp]

								mov	[_global_heap_start],ax

								!BCC_EOS

								! 53 	global_heap_next = param_start;

								! Debug: eq unsigned int param_start = [S+6+2] to unsigned int = [global_heap_next+0] (used reg = )

								mov	ax,4[bp]

								mov	[_global_heap_next],ax

								!BCC_EOS

								! 54 	global_heap_end = param_end;

								! Debug: eq unsigned int param_end = [S+6+4] to unsigned int = [global_heap_end+0] (used reg = )

								mov	ax,6[bp]

								mov	[_global_heap_end],ax

								!BCC_EOS

								! 55 	return 0;

								xor	ax,ax

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 56 }

								! 57

								! 58 unsigned int get_heap_next()

								! 59 {

								export	_get_heap_next

								_get_heap_next:

								! 60 	return global_heap_next;

								push	bp

								mov	bp,sp

								push	di

								push	si

								mov	ax,[_global_heap_next]

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 61 # 16 "main.h"

								! 16 }

								! 17 # 2 "std_singos/string.h"

								! 2 type

								! 2 def struct Length_String {

								! 3     short dynamic;

								!BCC_EOS

								! 4     unsigned int length;

								!BCC_EOS

								! 5     char *chars;

								!BCC_EOS

								! 6 } Length_String;

								!BCC_EOS

								! 7

								! 8 typedef struct String_Array {

								! 9     unsigned int length;

								!BCC_EOS

								! 10     Length_String **strings;

								!BCC_EOS

								! 11 } String_Array;

								!BCC_EOS

								! 12

								! 13 void strcpy (destination, destination_segment, source, source_segment );

								!BCC_EOS

								! 14 int strlen (source, source_segment);

								!BCC_EOS

								! 15 void memcpy (destination, destination_segment, source, source_segment, num_bytes );

								!BCC_EOS

								! 16

								! 17

								! 18 String_Array *string_split_c(string, delim, keep_delim);

								!BCC_EOS

								! 19 Length_String *make_length_string(length, chars);

								!BCC_EOS

								! 20 Length_String *make_length_string_c(cstring);

								!BCC_EOS

								! 21 String_Array *length_string_split(string, delim, keep_delim);

								!BCC_EOS

								! 22 String_Array *create_length_string_array(array_size);

								!BCC_EOS

								! 23 Length_String *create_length_string(length, chars);

								!BCC_EOS

								! 24

								! 25

								! 26

								! 27 int strlen (source, source_segment)

								! 28 {

								export	_strlen

								_strlen:

								! 29 #asm

								!BCC_ASM

								_strlen.source	set	2

								_strlen.source_segment	set	4


								push bp

								    mov bp,sp

								    push ds

								    push bx


								    mov ax, 6[bp];

								    mov ds, ax


								    mov bx, 4[bp];


								    label_strlen:

								       mov cx, #0x0            ; Set counte to zero

								    .label_strlen_loop:

								       mov BYTE al, [bx]

								       cmp al, #0x0

								       je .label_strlen_done

								       inc cx                  ; Count 1

								       inc bx                  ; Look at next char

								       jmp .label_strlen_loop

								    .label_strlen_done:

								       mov ax, cx


								    pop bx

								    pop ds

								    pop bp

								! 57 endasm

								!BCC_ENDASM

								! 58 }

								ret

								! 59

								! 60 void strcpy (destination, destination_segment, source, source_segment )

								! 61 char *destination;

								export	_strcpy

								_strcpy:

								!BCC_EOS

								! 62 int destination_segment;

								!BCC_EOS

								! 63 char *source;

								!BCC_EOS

								! 64 int source_segment;

								!BCC_EOS

								! 65 {

								! 66 #asm

								!BCC_ASM

								_strcpy.source	set	6

								_strcpy.destination	set	2

								_strcpy.source_segment	set	8

								_strcpy.destination_segment	set	4

								    ; copy two strings

								    ; IN si: the first (zero terminated) string

								    ; IN di: the second (zero terminated) string

								    ; OUT SF and ZF (same semantics as cmp)


								! 72  76


								    push bp

								    mov bp,sp

								    label_strcpy:

								        push ax

								        push bx

								        push di

								        push es

								        push si

								        push ds

								        mov ax, 4[bp]; ;

								        mov di, ax

								        mov ax, 6[bp]; ;

								        mov es, ax

								        mov ax, 8[bp]; ;

								        mov si, ax

								        mov ax, 10[bp]; ;

								        mov ds, ax

								        mov cx, 0x050  ;TODO(Jrn) Hardcded number of bytes to copy

								    .label_strcpy_loop:

								        movsb

								        cmp cx, 0x0

								        je .label_strcpy_end

								        dec cx

								        jmp .label_strcpy_loop

								    .label_strcpy_end:

								        pop ds

								        pop si

								        pop es

								        pop di

								        pop bx

								        pop ax

								        pop bp


								! 110 endasm

								!BCC_ENDASM

								! 111 }

								ret

								! 112

								! 113 void memcpy (destination, destination_segment, source, source_segment, num_bytes)

								! 114 void *destination;

								export	_memcpy

								_memcpy:

								!BCC_EOS

								! 115 int destination_segment;

								!BCC_EOS

								! 116 void *source;

								!BCC_EOS

								! 117 int source_segment;

								!BCC_EOS

								! 118 int num_bytes;

								!BCC_EOS

								! 119 {

								! 120 #asm

								!BCC_ASM

								_memcpy.source	set	6

								_memcpy.destination	set	2

								_memcpy.num_bytes	set	$A

								_memcpy.source_segment	set	8

								_memcpy.destination_segment	set	4

								    ; copy two strings

								    ; IN si: the first (zero terminated) string

								    ; IN di: the second (zero terminated) string

								    ; OUT SF and ZF (same semantics as cmp)


								! 126  131


								    push bp

								    mov bp,sp

								    label_memcpy:

								        push ax

								        push bx

								        push di

								        push es

								        push si

								        push ds

								        mov ax, 4[bp]; ;

								        mov di, ax

								        mov ax, 6[bp]; ;

								        mov es, ax

								        mov ax, 8[bp]; ;

								        mov si, ax

								        mov ax, 10[bp]; ;

								        mov ds, ax

								        mov cx, 12[bp];

								    .label_memcpy_loop:

								        movsb

								        cmp cx, 0x0

								        je .label_memcpy_end

								        dec cx

								        jmp .label_memcpy_loop

								    .label_memcpy_end:

								        pop ds

								        pop si

								        pop es

								        pop di

								        pop bx

								        pop ax

								        pop bp


								! 165 endasm

								!BCC_ENDASM

								! 166 }

								ret

								! 167

								! 168 String_Array *string_split_c(string, delim, keep_delim)

								! 169 char *string;

								export	_string_split_c

								_string_split_c:

								!BCC_EOS

								! 170 char delim;

								!BCC_EOS

								! 171 short keep_delim;

								!BCC_EOS

								! 172 {

								! 173     return length_string_split(make_length_string_c(string), delim, keep_delim);

								push	bp

								mov	bp,sp

								push	di

								push	si

								! Debug: list short keep_delim = [S+6+6] (used reg = )

								push	8[bp]

								! Debug: list char delim = [S+8+4] (used reg = )

								mov	al,6[bp]

								xor	ah,ah

								push	ax

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

								push	4[bp]

								! Debug: func () * struct Length_String = make_length_string_c+0 (used reg = )

								call	_make_length_string_c

								inc	sp

								inc	sp

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

								push	ax

								! Debug: func () * struct String_Array = length_string_split+0 (used reg = )

								call	_length_string_split

								add	sp,*6

								! Debug: cast * struct String_Array = const 0 to * struct String_Array = ax+0 (used reg = )

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 174 }

								! 175

								! 176 Length_String *make_length_string_c(cstring)

								! 177 char *cstring;

								export	_make_length_string_c

								_make_length_string_c:

								!BCC_EOS

								! 178 {

								! 179     return make_length_string(strlen(cstring, 0x7e0), cstring);

								push	bp

								mov	bp,sp

								push	di

								push	si

								! Debug: list * char cstring = [S+6+2] (used reg = )

								push	4[bp]

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

								mov	ax,#$7E0

								push	ax

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

								push	4[bp]

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

								call	_strlen

								add	sp,*4

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

								push	ax

								! Debug: func () * struct Length_String = make_length_string+0 (used reg = )

								call	_make_length_string

								add	sp,*4

								! Debug: cast * struct Length_String = const 0 to * struct Length_String = ax+0 (used reg = )

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 180 }

								! 181

								! 182 Length_String *make_length_string(length, chars)

								! 183 unsigned int length;

								export	_make_length_string

								_make_length_string:

								!BCC_EOS

								! 184 char *chars;

								!BCC_EOS

								! 185 {

								! 186

								! 187     Length_String *legth_string = malloc(sizeof(Length_String));

								push	bp

								mov	bp,sp

								push	di

								push	si

								dec	sp

								dec	sp

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

								mov	ax,*6

								push	ax

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

								call	_malloc

								inc	sp

								inc	sp

								! Debug: eq * void = ax+0 to * struct Length_String legth_string = [S+8-8] (used reg = )

								mov	-6[bp],ax

								!BCC_EOS

								! 188     char *copy = malloc(length + 1);

								dec	sp

								dec	sp

								! Debug: add int = const 1 to unsigned int length = [S+$A+2] (used reg = )

								mov	ax,4[bp]

								! Debug: list unsigned int = ax+1 (used reg = )

								inc	ax

								push	ax

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

								call	_malloc

								inc	sp

								inc	sp

								! Debug: eq * void = ax+0 to * char copy = [S+$A-$A] (used reg = )

								mov	-8[bp],ax

								!BCC_EOS

								! 189     memcpy(copy, 0x7e0, chars, 0x7e0, length);

								! Debug: list unsigned int length = [S+$A+2] (used reg = )

								push	4[bp]

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

								mov	ax,#$7E0

								push	ax

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

								push	6[bp]

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

								mov	ax,#$7E0

								push	ax

								! Debug: list * char copy = [S+$12-$A] (used reg = )

								push	-8[bp]

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

								call	_memcpy

								add	sp,*$A

								!BCC_EOS

								! 190     copy[length] = '';

								! Debug: ptradd unsigned int length = [S+$A+2] to * char copy = [S+$A-$A] (used reg = )

								mov	ax,4[bp]

								add	ax,-8[bp]

								mov	bx,ax

								! Debug: eq int = const 0 to char = [bx+0] (used reg = )

								xor	al,al

								mov	[bx],al

								!BCC_EOS

								! 191

								! 192     legth_string->dynamic = 0;

								mov	bx,-6[bp]

								! Debug: eq int = const 0 to short = [bx+0] (used reg = )

								xor	ax,ax

								mov	[bx],ax

								!BCC_EOS

								! 193     legth_string->length = length;

								mov	bx,-6[bp]

								! Debug: eq unsigned int length = [S+$A+2] to unsigned int = [bx+2] (used reg = )

								mov	ax,4[bp]

								mov	2[bx],ax

								!BCC_EOS

								! 194     legth_string->chars = (char *)chars;

								mov	bx,-6[bp]

								! Debug: eq * char chars = [S+$A+4] to * char = [bx+4] (used reg = )

								mov	si,6[bp]

								mov	4[bx],si

								!BCC_EOS

								! 195

								! 196     return legth_string;

								mov	ax,-6[bp]

								add	sp,*4

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 197 }

								! 198

								! 199 String_Array *length_string_split(string, delim, keep_delim)

								! Register BX SI used in function make_length_string

								! 200 Length_String *string;

								export	_length_string_split

								_length_string_split:

								!BCC_EOS

								! 201 char delim;

								!BCC_EOS

								! 202 short keep_delim;

								!BCC_EOS

								! 203 {

								! 204     unsigned int i;

								!BCC_EOS

								! 205     unsi

								! 205 gned int last;

								!BCC_EOS

								! 206

								! 207     unsigned int count = 0;

								push	bp

								mov	bp,sp

								push	di

								push	si

								add	sp,*-6

								! Debug: eq int = const 0 to unsigned int count = [S+$C-$C] (used reg = )

								xor	ax,ax

								mov	-$A[bp],ax

								!BCC_EOS

								! 208     unsigned int insert_index = 0;

								dec	sp

								dec	sp

								! Debug: eq int = const 0 to unsigned int insert_index = [S+$E-$E] (used reg = )

								xor	ax,ax

								mov	-$C[bp],ax

								!BCC_EOS

								! 209     String_Array *result;

								!BCC_EOS

								! 210     int k;

								!BCC_EOS

								! 211

								! 212     i = 0;

								add	sp,*-4

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

								xor	ax,ax

								mov	-6[bp],ax

								!BCC_EOS

								! 213     last = 0;

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

								xor	ax,ax

								mov	-8[bp],ax

								!BCC_EOS

								! 214     while(i < string->length) {

								jmp .B

								.C:

								! 215         if (string->chars[i] == delim) {

								mov	bx,4[bp]

								! Debug: ptradd unsigned int i = [S+$12-8] to * char = [bx+4] (used reg = )

								mov	ax,-6[bp]

								add	ax,4[bx]

								mov	bx,ax

								! Debug: logeq char delim = [S+$12+4] to char = [bx+0] (used reg = )

								mov	al,[bx]

								cmp	al,6[bp]

								jne 	.D

								.E:

								! 216             if (i > last+1) {

								! Debug: add int = const 1 to unsigned int last = [S+$12-$A] (used reg = )

								mov	ax,-8[bp]

								! Debug: gt unsigned int = ax+1 to unsigned int i = [S+$12-8] (used reg = )

								inc	ax

								cmp	ax,-6[bp]

								jae 	.F

								.10:

								! 217                 ++count;

								! Debug: preinc unsigned int count = [S+$12-$C] (used reg = )

								mov	ax,-$A[bp]

								inc	ax

								mov	-$A[bp],ax

								!BCC_EOS

								! 218             }

								! 219             last = i;

								.F:

								! Debug: eq unsigned int i = [S+$12-8] to unsigned int last = [S+$12-$A] (used reg = )

								mov	ax,-6[bp]

								mov	-8[bp],ax

								!BCC_EOS

								! 220         }

								! 221         ++i;

								.D:

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

								mov	ax,-6[bp]

								inc	ax

								mov	-6[bp],ax

								!BCC_EOS

								! 222     }

								! 223     if (i > last+1) {

								.B:

								mov	bx,4[bp]

								! Debug: lt unsigned int = [bx+2] to unsigned int i = [S+$12-8] (used reg = )

								mov	ax,-6[bp]

								cmp	ax,2[bx]

								jb 	.C

								.11:

								.A:

								! Debug: add int = const 1 to unsigned int last = [S+$12-$A] (used reg = )

								mov	ax,-8[bp]

								! Debug: gt unsigned int = ax+1 to unsigned int i = [S+$12-8] (used reg = )

								inc	ax

								cmp	ax,-6[bp]

								jae 	.12

								.13:

								! 224         ++count;

								! Debug: preinc unsigned int count = [S+$12-$C] (used reg = )

								mov	ax,-$A[bp]

								inc	ax

								mov	-$A[bp],ax

								!BCC_EOS

								! 225     }

								! 226

								! 227     result = create_length_string_array(count);

								.12:

								! Debug: list unsigned int count = [S+$12-$C] (used reg = )

								push	-$A[bp]

								! Debug: func () * struct String_Array = create_length_string_array+0 (used reg = )

								call	_create_length_string_array

								inc	sp

								inc	sp

								! Debug: eq * struct String_Array = ax+0 to * struct String_Array result = [S+$12-$10] (used reg = )

								mov	-$E[bp],ax

								!BCC_EOS

								! 228

								! 229     if (keep_delim)

								mov	ax,8[bp]

								test	ax,ax

								je  	.14

								.15:

								! 230     {

								! 231         k = 0;

								! Debug: eq int = const 0 to int k = [S+$12-$12] (used reg = )

								xor	ax,ax

								mov	-$10[bp],ax

								!BCC_EOS

								! 232     }

								! 233     else

								! 234     {

								jmp .16

								.14:

								! 235         k = 1;

								! Debug: eq int = const 1 to int k = [S+$12-$12] (used reg = )

								mov	ax,*1

								mov	-$10[bp],ax

								!BCC_EOS

								! 236     }

								! 237

								! 238     i = 0;

								.16:

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

								xor	ax,ax

								mov	-6[bp],ax

								!BCC_EOS

								! 239     last = 0;

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

								xor	ax,ax

								mov	-8[bp],ax

								!BCC_EOS

								! 240     while(i < string->length) {

								jmp .18

								.19:

								! 241         if (string->chars[i] == delim) {

								mov	bx,4[bp]

								! Debug: ptradd unsigned int i = [S+$12-8] to * char = [bx+4] (used reg = )

								mov	ax,-6[bp]

								add	ax,4[bx]

								mov	bx,ax

								! Debug: logeq char delim = [S+$12+4] to char = [bx+0] (used reg = )

								mov	al,[bx]

								cmp	al,6[bp]

								jne 	.1A

								.1B:

								! 242             if (i > last+1) {

								! Debug: add int = const 1 to unsigned int last = [S+$12-$A] (used reg = )

								mov	ax,-8[bp]

								! Debug: gt unsigned int = ax+1 to unsigned int i = [S+$12-8] (used reg = )

								inc	ax

								cmp	ax,-6[bp]

								jae 	.1C

								.1D:

								! 243                 result->strings[insert_index++] = create_length_string(i-(last+k), string->chars+(last+k));

								! Debug: add int k = [S+$12-$12] to unsigned int last = [S+$12-$A] (used reg = )

								mov	ax,-8[bp]

								add	ax,-$10[bp]

								mov	bx,4[bp]

								! Debug: ptradd unsigned int = ax+0 to * char = [bx+4] (used reg = )

								add	ax,4[bx]

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

								push	ax

								! Debug: add int k = [S+$14-$12] to unsigned int last = [S+$14-$A] (used reg = )

								mov	ax,-8[bp]

								add	ax,-$10[bp]

								! Debug: sub unsigned int = ax+0 to unsigned int i = [S+$14-8] (used reg = )

								push	ax

								mov	ax,-6[bp]

								sub	ax,-$14[bp]

								inc	sp

								inc	sp

								! Debug: list unsigned int = ax+0 (used reg = )

								push	ax

								! Debug: func () * struct Length_String = create_length_string+0 (used reg = )

								call	_create_length_string

								add	sp,*4

								push	ax

								! Debug: postinc unsigned int insert_index = [S+$14-$E] (used reg = )

								mov	ax,-$C[bp]

								inc	ax

								mov	-$C[bp],ax

								mov	bx,-$E[bp]

								! Debug: ptradd unsigned int = ax-1 to * * struct Length_String = [bx+2] (used reg = )

								dec	ax

								shl	ax,*1

								add	ax,2[bx]

								mov	bx,ax

								! Debug: eq * struct Length_String (temp) = [S+$14-$14] to * struct Length_String = [bx+0] (used reg = )

								mov	si,-$12[bp]

								mov	[bx],si

								inc	sp

								inc	sp

								!BCC_EOS

								! 244             }

								! 245             last = i;

								.1C:

								! Debug: eq unsigned int i = [S+$12-8] to unsigned int last = [S+$12-$A] (used reg = )

								mov	ax,-6[bp]

								mov	-8[bp],ax

								!BCC_EOS

								! 246         }

								! 247         ++i;

								.1A:

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

								mov	ax,-6[bp]

								inc	ax

								mov	-6[bp],ax

								!BCC_EOS

								! 248     }

								! 249     if (i > last+1) {

								.18:

								mov	bx,4[bp]

								! Debug: lt unsigned int = [bx+2] to unsigned int i = [S+$12-8] (used reg = )

								mov	ax,-6[bp]

								cmp	ax,2[bx]

								jb 	.19

								.1E:

								.17:

								! Debug: add int = const 1 to unsigned int last = [S+$12-$A] (used reg = )

								mov	ax,-8[bp]

								! Debug: gt unsigned int = ax+1 to unsigned int i = [S+$12-8] (used reg = )

								inc	ax

								cmp	ax,-6[bp]

								jae 	.1F

								.20:

								! 250         result->strings[insert_index++] = create_length_string(i-(last+k), ((string->chars)+(last+k)));

								! Debug: add int k = [S+$12-$12] to unsigned int last = [S+$12-$A] (used reg = )

								mov	ax,-8[bp]

								add	ax,-$10[bp]

								mov	bx,4[bp]

								! Debug: ptradd unsigned int = ax+0 to * char = [bx+4] (used reg = )

								add	ax,4[bx]

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

								push	ax

								! Debug: add int k = [S+$14-$12] to unsigned int last = [S+$14-$A] (used reg = )

								mov	ax,-8[bp]

								add	ax,-$10[bp]

								! Debug: sub unsigned int = ax+0 to unsigned int i = [S+$14-8] (used reg = )

								push	ax

								mov	ax,-6[bp]

								sub	ax,-$14[bp]

								inc	sp

								inc	sp

								! Debug: list unsigned int = ax+0 (used reg = )

								push	ax

								! Debug: func () * struct Length_String = create_length_string+0 (used reg = )

								call	_create_length_string

								add	sp,*4

								push	ax

								! Debug: postinc unsigned int insert_index = [S+$14-$E] (used reg = )

								mov	ax,-$C[bp]

								inc	ax

								mov	-$C[bp],ax

								mov	bx,-$E[bp]

								! Debug: ptradd unsigned int = ax-1 to * * struct Length_String = [bx+2] (used reg = )

								dec	ax

								shl	ax,*1

								add	ax,2[bx]

								mov	bx,ax

								! Debug: eq * struct Length_String (temp) = [S+$14-$14] to * struct Length_String = [bx+0] (used reg = )

								mov	si,-$12[bp]

								mov	[bx],si

								inc	sp

								inc	sp

								!BCC_EOS

								! 251     }

								! 252

								! 253     return result;

								.1F:

								mov	ax,-$E[bp]

								add	sp,*$C

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 254

								! 255 }

								! 256

								! 257 String_Array *create_length_string_array(array_size)

								! Register BX SI used in function length_string_split

								! 258 int array_size;

								export	_create_length_string_array

								_create_length_string_array:

								!BCC_EOS

								! 259 {

								! 260     String_Array *result = malloc(sizeof(String_Array));

								push	bp

								mov	bp,sp

								push	di

								push	si

								dec	sp

								dec	sp

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

								mov	ax,*4

								push	ax

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

								call	_malloc

								inc	sp

								inc	sp

								! Debug: eq * void = ax+0 to * struct String_Array result = [S+8-8] (used reg = )

								mov	-6[bp],ax

								!BCC_EOS

								! 261     result->length = array_size;

								mov	bx,-6[bp]

								! Debug: eq int array_size = [S+8+2] to unsigned int = [bx+0] (used reg = )

								mov	ax,4[bp]

								mov	[bx],ax

								!BCC_EOS

								! 262     result->strings = malloc(array_size * sizeof(Length_String));

								! Debug: mul int = const 6 to int array_size = [S+8+2] (used reg = )

								mov	ax,4[bp]

								mov	dx,ax

								shl	ax,*1

								add	ax,dx

								shl	ax,*1

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

								push	ax

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

								call	_malloc

								inc	sp

								inc	sp

								mov	bx,-6[bp]

								! Debug: eq * void = ax+0 to * * struct Length_String = [bx+2] (used reg = )

								mov	2[bx],ax

								!BCC_EOS

								! 263     return result;

								mov	ax,-6[bp]

								inc	sp

								inc	sp

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 264 }

								! 265

								! 266

								! 267 Length_String *create_length_string(length, chars)

								! Register BX used in function create_length_string_array

								! 268 unsigned int length;

								export	_create_length_string

								_create_length_string:

								!BCC_EOS

								! 269 char *chars;

								!BCC_EOS

								! 270 {

								! 271

								! 272     Length_String *legth_string = malloc(sizeof(Length_String));

								push	bp

								mov	bp,sp

								push	di

								push	si

								dec	sp

								dec	sp

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

								mov	ax,*6

								push	ax

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

								call	_malloc

								inc	sp

								inc	sp

								! Debug: eq * void = ax+0 to * struct Length_String legth_string = [S+8-8] (used reg = )

								mov	-6[bp],ax

								!BCC_EOS

								! 273     char *copy = malloc(length + 1);

								dec	sp

								dec	sp

								! Debug: add int = const 1 to unsigned int length = [S+$A+2] (used reg = )

								mov	ax,4[bp]

								! Debug: list unsigned int = ax+1 (used reg = )

								inc	ax

								push	ax

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

								call	_malloc

								inc	sp

								inc	sp

								! Debug: eq * void = ax+0 to * char copy = [S+$A-$A] (used reg = )

								mov	-8[bp],ax

								!BCC_EOS

								! 274     memcpy(copy, 0x7e0, chars, 0x7e0, length);

								! Debug: list unsigned int length = [S+$A+2] (used reg = )

								push	4[bp]

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

								mov	ax,#$7E0

								push	ax

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

								push	6[bp]

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

								mov	ax,#$7E0

								push	ax

								! Debug: list * char copy = [S+$12-$A] (used reg = )

								push	-8[bp]

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

								call	_memcpy

								add	sp,*$A

								!BCC_EOS

								! 275     copy[length] = '';

								! Debug: ptradd unsigned int length = [S+$A+2] to * char copy = [S+$A-$A] (used reg = )

								mov	ax,4[bp]

								add	ax,-8[bp]

								mov	bx,ax

								! Debug: eq int = const 0 to char = [bx+0] (used reg = )

								xor	al,al

								mov	[bx],al

								!BCC_EOS

								! 276

								! 277     legth_string->dynamic = 1;

								mov	bx,-6[bp]

								! Debug: eq int = const 1 to short = [bx+0] (used reg = )

								mov	ax,*1

								mov	[bx],ax

								!BCC_EOS

								! 278     legth_string->length = length;

								mov	bx,-6[bp]

								! Debug: eq unsigned int length = [S+$A+2] to unsigned int = [bx+2] (used reg = )

								mov	ax,4[bp]

								mov	2[bx],ax

								!BCC_EOS

								! 279     legth_string->chars = copy;

								mov	bx,-6[bp]

								! Debug: eq * char copy = [S+$A-$A] to * char = [bx+4] (used reg = )

								mov	si,-8[bp]

								mov	4[bx],si

								!BCC_EOS

								! 280

								! 281     return legth_string;

								mov	ax,-6[bp]

								add	sp,*4

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 282 # 18 "main.h"

								! 18 }

								! 19 # 1 "driver/disk.h"

								! 1 int data_from_disk(index, number_sectors, data_buffer, data_buffer_segment);

								! Register BX SI used in function create_length_string

								!BCC_EOS

								! 2 int disk_service_read_data_from_disk(index, number_sectors, data_buffer, data_buffer_segment);

								!BCC_EOS

								! 3

								! 4 int disk_service_read_data_from_disk(index, number_sectors, data_buffer, data_buffer_segment)

								! 5 long* index;

								export	_disk_service_read_data_from_disk

								_disk_service_read_data_from_disk:

								!BCC_EOS

								! 6 long number_sectors;

								!BCC_EOS

								! 7 void* data_buffer;

								!BCC_EOS

								! 8 int data_buffer_segment;

								!BCC_EOS

								! 9 {

								! 10

								! 11 #asm

								!BCC_ASM

								_disk_service_read_data_from_disk.data_buffer	set	8

								_disk_service_read_data_from_disk.number_sectors	set	4

								_disk_service_read_data_from_disk.data_buffer_segment	set	$A

								_disk_service_read_data_from_disk.index	set	2


								! 13 define number_sectors 8[bp];


									push bp

								    mov bp,sp

									pusha


									lsfs_load_data:

									    mov ax, 4[bp];

									    mov WORD [DAPACK.lba_addr_dw_low], ax

									    mov bx, 8[bp];

									    mov WORD [DAPACK.blkcnt],          bx

									    mov cx, 12[bp];

									    mov WORD [DAPACK.db_addr_segment], cx

									    mov dx, 10[bp]; ;

									    mov WORD [DAPACK.db_addr_offset],  dx

									    mov si, #DAPACK                          ; address of

									    mov ah, #0x42                            ; READ

									    mov dl, [global_disk_identifier]

									    int #0x13

									;call 0x0000:0x7C2A

									popa

									pop bp

									ret


									DAPACK:

									  DAPACK.dap_Size:         db  0x10

									  DAPACK.rev_byte:         db  0x0

									  DAPACK.blkcnt:           dw  0x0

									  DAPACK.db_addr_offset:   dw  0x0

									  DAPACK.db_addr_segment:  dw  0x0

									  DAPACK.lba_addr_dw_low:  dd  0x0

									  DAPACK.lba_addr_dw_high: dd  0x0


									global_disk_identifier: db 0x80


								! 51 endasm

								!BCC_ENDASM

								! 52 }

								ret

								! 53 # 4 "implementation/lsfs.h"

								! 4 typedef struct lsfs_file lsfs_file;

								!BCC_EOS

								! 5 # 22 "main.h"

								! 22 void dump_ax(input);

								!BCC_EOS

								! 23 void print_stack(argument);

								!BCC_EOS

								! 24 void print_newline();

								!BCC_EOS

								! 25

								! 26 typedef struct Directory_Table Directory_Table;

								!BCC_EOS

								! 27 typedef struct Struct_Table_Entry Table_Entry;

								!BCC_EOS

								! 28 typedef struct struct_partition_control partition_control;

								!BCC_EOS

								! 29 typedef struct File_System_Control_Information FSCI;

								!BCC_EOS

								! 30 typedef struct meta_information_format mif;

								!BCC_EOS

								! 31 typedef struct tag_record tag_record;

								!BCC_EOS

								! 32 typedef struct Parameter_Struct Parameter_Struct;

								!BCC_EOS

								! 33

								! 34 typedef enum Table_Entry_Kind

								! 35 {

								! 36

								! 37     ENTRY_EMPTY = 0,

								! 38     ENTRY_FILE = 1,

								! 39     ENTRY_DIRECTORY = 2,

								! 40 } Table_Entry_Kind;

								!BCC_EOS

								! 41

								! 42 typedef enum Service_Action

								! 43 {

								! 44     SERIVCE_LOAD_DISK  = 1,

								! 45     SERVICE_FIND_ENTRY = 2,

								! 46     SERIVCE_READ_DATA  = 3,

								! 47     SERIVCE_WRITE_DATA = 4,

								! 48

								! 49 } Service_Action;

								!BCC_EOS

								! 50

								! 51 struct Struct_Table_Entry

								! 52 {

								! 53     char    filename[256];

								!BCC_EOS

								! 54     long    file_id[2];

								!BCC_EOS

								! 55     long    file_size[2];

								!BCC_EOS

								! 56     void*   ext_file_data_low;

								!BCC_EOS

								! 57     void*   ext_file_data_high;

								!BCC_EOS

								! 58     long    number_sector_s;

								!BCC_EOS

								! 59     short   entry_kind;

								!BCC_EOS

								! 60     short   extra_control_bits1;

								!BCC_EOS

								! 61     short   extra_control_bits2;

								!BCC_EOS

								! 62     short   extra_control_bits3;

								!BCC_EOS

								! 63     long    table_entry_sector_index[2];

								!BCC_EOS

								! 64     long    data_pointer[27   * 2];

								!BCC_EOS

								! 65 };

								!BCC_EOS

								! 66

								! 67 struct File_Syst

								! 67 em_Control_Information

								! 68 {

								! 69     char filesystem_information[256];

								!BCC_EOS

								! 70     long master_table_index[2];

								!BCC_EOS

								! 71     long this_partition_offset_on_disk[2];

								!BCC_EOS

								! 72     long next_free_sector[2];

								!BCC_EOS

								! 73     long next_uniqe_id[2];

								!BCC_EOS

								! 74     long next_sector_reuse_pointer[2];

								!BCC_EOS

								! 75     long last_sector_index_on_partition[2];

								!BCC_EOS

								! 76     long maximum_sectors_on_disk[2];

								!BCC_EOS

								! 77     long sector_size_on_disk[2];

								!BCC_EOS

								! 78     long not_used[48];

								!BCC_EOS

								! 79

								! 80 };

								!BCC_EOS

								! 81

								! 82 typedef struct Directory_Table

								! 83 {

								! 84     Table_Entry entries[16  ];

								!BCC_EOS

								! 85

								! 86 };

								!BCC_EOS

								! 87

								! 88 struct Parameter_Struct

								! 89 {

								! 90     char* path;

								!BCC_EOS

								! 91     char* new_path;

								!BCC_EOS

								! 92     int buffer_segment;

								!BCC_EOS

								! 93     int buffer_address;

								!BCC_EOS

								! 94     int buffer_size;

								!BCC_EOS

								! 95     int data_length;

								!BCC_EOS

								! 96     int byte_offset_into_file;

								!BCC_EOS

								! 97     Table_Entry_Kind entry_kind;

								!BCC_EOS

								! 98 };

								!BCC_EOS

								! 99 # 7 "main.c"

								! 7 int main(selector, pointer_parameter_segment, pointer_parameter_struct)

								! 8 int selector;

								export	_main

								_main:

								!BCC_EOS

								! 9 void* pointer_parameter_segment;

								!BCC_EOS

								! 10 void* pointer_parameter_struct;

								!BCC_EOS

								! 11 {

								! 12

								! 13

								! 14

								! 15     FSCI fsci;

								!BCC_EOS

								! 16

								! 17     Service_Action service_action;

								!BCC_EOS

								! 18     Directory_Table current_table;

								!BCC_EOS

								! 19     Parameter_Struct parameter_struct;

								!BCC_EOS

								! 20     int local_segment = 0x7e0;

								push	bp

								mov	bp,sp

								push	di

								push	si

								add	sp,#-$2214

								! Debug: eq int = const $7E0 to int local_segment = [S+$221A-$221A] (used reg = )

								mov	ax,#$7E0

								mov	-$2218[bp],ax

								!BCC_EOS

								! 21     unsigned int heap_start = 0x2000;

								dec	sp

								dec	sp

								! Debug: eq int = const $2000 to unsigned int heap_start = [S+$221C-$221C] (used reg = )

								mov	ax,#$2000

								mov	-$221A[bp],ax

								!BCC_EOS

								! 22     unsigned int heap_end = 0xffff;

								dec	sp

								dec	sp

								! Debug: eq unsigned int = const $FFFF to unsigned int heap_end = [S+$221E-$221E] (used reg = )

								mov	ax,#$FFFF

								mov	-$221C[bp],ax

								!BCC_EOS

								! 23     int stack_segment = 0x8fc0;

								dec	sp

								dec	sp

								! Debug: eq unsigned int = const $8FC0 to int stack_segment = [S+$2220-$2220] (used reg = )

								mov	ax,#$8FC0

								mov	-$221E[bp],ax

								!BCC_EOS

								! 24     int path_length;

								!BCC_EOS

								! 25     long index_as_long;

								!BCC_EOS

								! 26

								! 27     char *local_path = 0;

								add	sp,*-8

								! Debug: eq int = const 0 to * char local_path = [S+$2228-$2228] (used reg = )

								xor	ax,ax

								mov	-$2226[bp],ax

								!BCC_EOS

								! 28     service_action = selector;

								! Debug: eq int selector = [S+$2228+2] to int service_action = [S+$2228-$208] (used reg = )

								mov	ax,4[bp]

								mov	-$206[bp],ax

								!BCC_EOS

								! 29

								! 30     switch (service_action)

								mov	ax,-$206[bp]

								! 31     {

								br 	.23

								! 32         case SERIVCE_LOAD_DISK:

								! 33         {

								.24:

								! 34

								! 35

								! 36

								! 37

								! 38             index_as_long = pointer_parameter_struct;

								! Debug: eq * void pointer_parameter_struct = [S+$2228+6] to long index_as_long = [S+$2228-$2226] (used reg = )

								mov	ax,8[bp]

								xor	bx,bx

								mov	-$2224[bp],ax

								mov	-$2222[bp],bx

								!BCC_EOS

								! 39             disk_service_read_data_from_disk(index_as_long, 1, &fsci, stack_segment);

								! Debug: list int stack_segment = [S+$2228-$2220] (used reg = )

								push	-$221E[bp]

								! Debug: list * struct File_System_Control_Information fsci = S+$222A-$206 (used reg = )

								lea	bx,-$204[bp]

								push	bx

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

								mov	ax,*1

								push	ax

								! Debug: list long index_as_long = [S+$222E-$2226] (used reg = )

								push	-$2222[bp]

								push	-$2224[bp]

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

								call	_disk_service_read_data_from_disk

								add	sp,*$A

								!BCC_EOS

								! 40             print("File System has been loaded: ");

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

								mov	bx,#.25

								push	bx

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

								call	_print

								inc	sp

								inc	sp

								!BCC_EOS

								! 41             print_newline();

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

								call	_print_newline

								!BCC_EOS

								! 42             set_heap_settings(heap_start, heap_end);

								! Debug: list unsigned int heap_end = [S+$2228-$221E] (used reg = )

								push	-$221C[bp]

								! Debug: list unsigned int heap_start = [S+$222A-$221C] (used reg = )

								push	-$221A[bp]

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

								call	_set_heap_settings

								add	sp,*4

								!BCC_EOS

								! 43             print_stack(fsci.filesystem_information);

								! Debug: list * char fsci = S+$2228-$206 (used reg = )

								lea	bx,-$204[bp]

								push	bx

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

								call	_print_stack

								inc	sp

								inc	sp

								!BCC_EOS

								! 44             print_newline();

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

								call	_print_newline

								!BCC_EOS

								! 45         } break;

								br 	.21

								!BCC_EOS

								! 46         case SERVICE_FIND_ENTRY:

								! 47         {

								.26:

								! 48             String_Array *path_array;

								!BCC_EOS

								! 49             int i;

								!BCC_EOS

								! 50             memcpy(&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+$222E+4] (used reg = )

								push	6[bp]

								! Debug: list * void pointer_parameter_struct = [S+$2230+6] (used reg = )

								push	8[bp]

								! Debug: list int stack_segment = [S+$2232-$2220] (used reg = )

								push	-$221E[bp]

								! Debug: list * struct Parameter_Struct parameter_struct = S+$2234-$2218 (used reg = )

								lea	bx,-$2216[bp]

								push	bx

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

								call	_memcpy

								add	sp,*$A

								!BCC_EOS

								! 51             path_length = strlen(parameter_struct.path, pointer_parameter_segment);

								! Debug: list * void pointer_parameter_segment = [S+$222C+4] (used reg = )

								push	6[bp]

								! Debug: list * char parameter_struct = [S+$222E-$2218] (used reg = )

								push	-$2216[bp]

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

								call	_strlen

								add	sp,*4

								! Debug: eq int = ax+0 to int path_length = [S+$222C-$2222] (used reg = )

								mov	-$2220[bp],ax

								!BCC_EOS

								! 52             local_path = malloc(256);

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

								mov	ax,#$100

								push	ax

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

								call	_malloc

								inc	sp

								inc	sp

								! Debug: eq * void = ax+0 to * char local_path = [S+$222C-$2228] (used reg = )

								mov	-$2226[bp],ax

								!BCC_EOS

								! 53

								! 53           memcpy(local_path, local_segment, parameter_struct.path, pointer_parameter_segment, path_length);

								! Debug: list int path_length = [S+$222C-$2222] (used reg = )

								push	-$2220[bp]

								! Debug: list * void pointer_parameter_segment = [S+$222E+4] (used reg = )

								push	6[bp]

								! Debug: list * char parameter_struct = [S+$2230-$2218] (used reg = )

								push	-$2216[bp]

								! Debug: list int local_segment = [S+$2232-$221A] (used reg = )

								push	-$2218[bp]

								! Debug: list * char local_path = [S+$2234-$2228] (used reg = )

								push	-$2226[bp]

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

								call	_memcpy

								add	sp,*$A

								!BCC_EOS

								! 54             local_path[path_length] = 0;

								! Debug: ptradd int path_length = [S+$222C-$2222] to * char local_path = [S+$222C-$2228] (used reg = )

								mov	ax,-$2220[bp]

								add	ax,-$2226[bp]

								mov	bx,ax

								! Debug: eq int = const 0 to char = [bx+0] (used reg = )

								xor	al,al

								mov	[bx],al

								!BCC_EOS

								! 55             print(local_path);

								! Debug: list * char local_path = [S+$222C-$2228] (used reg = )

								push	-$2226[bp]

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

								call	_print

								inc	sp

								inc	sp

								!BCC_EOS

								! 56

								! 57             path_array = string_split_c(local_path, '/', 0);

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

								xor	ax,ax

								push	ax

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

								mov	ax,*$2F

								push	ax

								! Debug: list * char local_path = [S+$2230-$2228] (used reg = )

								push	-$2226[bp]

								! Debug: func () * struct String_Array = string_split_c+0 (used reg = )

								call	_string_split_c

								add	sp,*6

								! Debug: eq * struct String_Array = ax+0 to * struct String_Array path_array = [S+$222C-$222A] (used reg = )

								mov	-$2228[bp],ax

								!BCC_EOS

								! 58

								! 59             print_newline();

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

								call	_print_newline

								!BCC_EOS

								! 60             print_newline();

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

								call	_print_newline

								!BCC_EOS

								! 61             for (i = 0; i < path_array->length; ++i)

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

								xor	ax,ax

								mov	-$222A[bp],ax

								!BCC_EOS

								!BCC_EOS

								! 62             {

								jmp .29

								.2A:

								! 63                 print(path_array->strings[i]->chars);

								mov	bx,-$2228[bp]

								! Debug: ptradd int i = [S+$222C-$222C] to * * struct Length_String = [bx+2] (used reg = )

								mov	ax,-$222A[bp]

								shl	ax,*1

								add	ax,2[bx]

								mov	bx,ax

								mov	bx,[bx]

								! Debug: list * char = [bx+4] (used reg = )

								push	4[bx]

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

								call	_print

								inc	sp

								inc	sp

								!BCC_EOS

								! 64                 print_newline();

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

								call	_print_newline

								!BCC_EOS

								! 65             }

								! 66             print_newline();

								.28:

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

								mov	ax,-$222A[bp]

								inc	ax

								mov	-$222A[bp],ax

								.29:

								mov	bx,-$2228[bp]

								! Debug: lt unsigned int = [bx+0] to int i = [S+$222C-$222C] (used reg = )

								mov	ax,-$222A[bp]

								cmp	ax,[bx]

								jb 	.2A

								.2B:

								.27:

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

								call	_print_newline

								!BCC_EOS

								! 67             print_newline();

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

								call	_print_newline

								!BCC_EOS

								! 68

								! 69             print_newline();

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

								call	_print_newline

								!BCC_EOS

								! 70             disk_service_read_data_from_disk(fsci.master_table_index[0], 16  , &current_table, stack_segment);

								! Debug: list int stack_segment = [S+$222C-$2220] (used reg = )

								push	-$221E[bp]

								! Debug: list * struct Directory_Table current_table = S+$222E-$2208 (used reg = )

								lea	bx,-$2206[bp]

								push	bx

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

								mov	ax,*$10

								push	ax

								! Debug: list long fsci = [S+$2232-$106] (used reg = )

								push	-$102[bp]

								push	-$104[bp]

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

								call	_disk_service_read_data_from_disk

								add	sp,*$A

								!BCC_EOS

								! 71             print("Current table: ");

								! Debug: list * char = .2C+0 (used reg = )

								mov	bx,#.2C

								push	bx

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

								call	_print

								inc	sp

								inc	sp

								!BCC_EOS

								! 72             print_newline();

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

								call	_print_newline

								!BCC_EOS

								! 73             print_stack(current_table.entries[0].filename);

								! Debug: list * char current_table = S+$222C-$2208 (used reg = )

								lea	bx,-$2206[bp]

								push	bx

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

								call	_print_stack

								inc	sp

								inc	sp

								!BCC_EOS

								! 74             print_newline();

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

								call	_print_newline

								!BCC_EOS

								! 75             print_stack(current_table.entries[1].filename);

								! Debug: list * char current_table = S+$222C-$2008 (used reg = )

								lea	bx,-$2006[bp]

								push	bx

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

								call	_print_stack

								inc	sp

								inc	sp

								!BCC_EOS

								! 76             print_newline();

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

								call	_print_newline

								!BCC_EOS

								! 77             print_stack(current_table.entries[2].filename);

								! Debug: list * char current_table = S+$222C-$1E08 (used reg = )

								lea	bx,-$1E06[bp]

								push	bx

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

								call	_print_stack

								inc	sp

								inc	sp

								!BCC_EOS

								! 78             print_newline();

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

								call	_print_newline

								!BCC_EOS

								! 79

								! 80         } break;

								jmp .21

								!BCC_EOS

								! 81         case SERIVCE_READ_DATA:

								! 82         {

								.2D:

								! 83 # 91

								! 91

								! 92             print("Hit READ case");

								! Debug: list * char = .2E+0 (used reg = )

								mov	bx,#.2E

								push	bx

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

								call	_print

								inc	sp

								inc	sp

								!BCC_EOS

								! 93         } break;

								jmp .21

								!BCC_EOS

								! 94         case SERIVCE_WRITE_DATA:

								! 95         {

								.2F:

								! 96             print("Hit WRITE case");

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

								mov	bx,#.30

								push	bx

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

								call	_print

								inc	sp

								inc	sp

								!BCC_EOS

								! 97         } break;

								jmp .21

								!BCC_EOS

								! 98         default:

								! 99         {

								.31:

								! 100             print("Default case");

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

								mov	bx,#.32

								push	bx

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

								call	_print

								inc	sp

								inc	sp

								!BCC_EOS

								! 101         }

								! 102     }

								! 103

								! 104     return 0;

								jmp .21

								.23:

								add	sp,*-4

								sub	ax,*1

								beq 	.24

								sub	ax,*1

								beq 	.26

								sub	ax,*1

								je 	.2D

								sub	ax,*1

								je 	.2F

								jmp	.31

								.21:

								..FFFF	=	-$222C

								add	sp,*4

								xor	ax,ax

								lea	sp,-4[bp]

								pop	si

								pop	di

								pop	bp

								ret

								!BCC_EOS

								! 105

								! 106 }

								! 107

								! Register BX used in function main

								.32:

								.33:

								.ascii	"Default case"

								.byte	0

								.30:

								.34:

								.ascii	"Hit WRITE case"

								.byte	0

								.2E:

								.35:

								.ascii	"Hit READ case"

								.byte	0

								.2C:

								.36:

								.ascii	"Current table: "

								.byte	0

								.25:

								.37:

								.ascii	"File System has been loaded: "

								.byte	0

								.bss


								! 0 errors detected