Defeated 16-bit, we can now load the kernel by path

build.sh

@@ -1,4 +1,4 @@
-bcc -S main.c implementation/lsfs.c
+bcc -S main.c -o main.s
 echo -e "push bp
 mov bp,sp
 push 10[bp]

driver/disk.h

@@ -2,30 +2,36 @@ int data_from_disk(index, number_sectors, data_buffer, data_buffer_segment);
 int disk_service_read_data_from_disk(index, number_sectors, data_buffer, data_buffer_segment);
 
 int disk_service_read_data_from_disk(index, number_sectors, data_buffer, data_buffer_segment)
-long* index; 
+long index; 
 long number_sectors; 
 void* data_buffer;
-int data_buffer_segment;
+unsigned int data_buffer_segment;
 {
 
 	#asm
 	#define index 4[bp]; // Note that this is a 32-bit argument.
     #define number_sectors 8[bp];
-    #define data_buffer 10[bp];
+    #define data_buffer 12[bp];
-    #define data_buffer_segment 12[bp];
+    #define data_buffer_segment 14[bp];
 	
 	push bp
     mov bp,sp
 	pusha
-
 	lsfs_load_data:
 	    mov ax, index
+		call 0x0000:0x7C2A
 	    mov WORD [DAPACK.lba_addr_dw_low], ax
 	    mov bx, number_sectors
+	    mov ax, bx
+	    call 0x0000:0x7C2A
 	    mov WORD [DAPACK.blkcnt],          bx
 	    mov cx, data_buffer_segment  
+	    mov ax, cx
+	    call 0x0000:0x7C2A
 	    mov WORD [DAPACK.db_addr_segment], cx
 	    mov dx, data_buffer;
+	    mov ax, dx
+	    call 0x0000:0x7C2A
 	    mov WORD [DAPACK.db_addr_offset],  dx
 	    mov si, #DAPACK                          ; address of
 	    mov ah, #0x42                            ; READ

implementation/lsfs.c

@@ -1,26 +1,81 @@
 #include "lsfs.h"
-#include "../main.h"
+/* #include "../std_singos/string.h" */
-
+extern FSCI fsci;
-struct lsfs_file {
+
-    long file_id[2];
+int lsfs_disk_getattr(find_file, path) 
-    long table_entry_pointer[2];
+lsfs_file* find_file; 
-    Table_Entry_Kind entry_kind;
+char* path;
-    char* filename;
+{
-    long owner_id;
+    int i;
-    long size[2];
+    String_Array *split_path = string_split_c(path, '/', false);
-    long creation_date[2]; 
+    Length_String *filename = split_path->strings[split_path->length-1]; 
-    long access_time[2];
+    
-    long modification_time[2];
+    /* Start from the master table*/
-    long number_sector;
+    Directory_Table *dir_table = lsfs_find_directory(path, true);
-    long table_entry_sector_index[2];
+
-    long data_pointer[NUM_DATA_POINTERS * 2];
+    for (i = 0; i < DEFAULT_TABLE_SIZE; ++i)
-};
+    {
-
+        if(strcmp( filename->chars, dir_table->entries[i].filename ) == 0) {
-int lsfs_disk_read_data_from_file(file, buffer_size, data,  offset_to_next_entry) 
+            find_file->file_id[0] = dir_table->entries[i].file_id;
+            find_file->entry_kind = dir_table->entries[i].entry_kind;
+            find_file->table_entry_pointer[0] = i;
+            find_file->filename = dir_table->entries[i].filename;
+            find_file->table_entry_sector_index[0] = dir_table->entries[i].table_entry_sector_index;
+            find_file->owner_id = 1;
+            find_file->size[0] = dir_table->entries[i].file_size; /* dir_table->entries[i].data_pointer[0]; ;*/
+            find_file->creation_date[0] = 0;
+            find_file->access_time[0] = 0;
+            find_file->modification_time[0] = 0;
+            memcpy(find_file->data_pointer, dir_table->entries[i].data_pointer, NUM_DATA_POINTERS * 8);
+            find_file->number_sector = 1; /* TODO: should be loaded from disk.*/
+            return 1;
+        }
+    }
+    return 0;
+}
+
+Directory_Table* lsfs_find_directory(path, drop_filename)
+char *path;
+short drop_filename; 
+{
+    int number_of_traversal;
+    int i, j;
+    String_Array *split_path;
+    Directory_Table *dir_table = calloc(1, sizeof(Directory_Table));
+    /* printf("Table index: %lu \n",fsci.master_table_index ); */
+    disk_service_read_data_from_disk(fsci.master_table_index[0], DEFAULT_TABLE_SIZE, dir_table, 0x7e0);
+    split_path = string_split_c(path, '/', false);
+
+    number_of_traversal = split_path->length;
+
+    if (drop_filename)
+    {
+        number_of_traversal -= 1;
+    }
+
+    /* Start from the master table */
+    for (i = 0; i < number_of_traversal; ++i)
+    {
+        for (j = 0; j < DEFAULT_TABLE_SIZE; ++j)
+        {
+            if (strcmp(dir_table->entries[j].filename, split_path->strings[i]->chars) == 0)
+            {
+                int index_sector = dir_table->entries[j].data_pointer[0];
+                /* printf("Table index: %lu \n",index_sector ); */
+                disk_service_read_data_from_disk(index_sector, DEFAULT_TABLE_SIZE, dir_table);
+                break;
+            }
+        }
+    }
+    return dir_table;
+}
+
+int lsfs_disk_read_data_from_file(file, buffer_size, data,  offset_to_next_entry, data_segment) 
 lsfs_file *file;
 int buffer_size; 
 char *data; 
 long offset_to_next_entry;
+unsigned int data_segment;
 {
     int integer_file_size = file->size;
     int integer_offset = offset_to_next_entry;
@@ -36,6 +91,7 @@ long offset_to_next_entry;
 
     int data_pointer_index = 0; /*  start at first data pointer.  */
     
+    dump_ax(file->size);
     if (data_length > buffer_size)
     {
         data_length = buffer_size;
@@ -63,11 +119,14 @@ long offset_to_next_entry;
             {
                 break;
             }
-            disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], DEFAULT_DATA_POINTER_SIZE, tmp_buffer);
+            disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], DEFAULT_DATA_POINTER_SIZE, tmp_buffer, 0x7e0);
-            memcpy((data + amount_read), tmp_buffer, amount_to_read);
+            print_newline();
+            dump_ax(file->data_pointer[data_pointer_index]);
+            print_newline();
+            memcpy((data + amount_read), data_segment, tmp_buffer, 0x7e0, amount_to_read);
             data_length -= amount_to_read;
             amount_read += amount_to_read;
-            data_pointer_index++;
+            data_pointer_index = data_pointer_index + 2; /* Rember that we only use 32-bit, and thats why we jump to at a time*/
             /* free(tmp_buffer); */
         }
         else if (remaining_offset < (DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE)) 
@@ -84,14 +143,14 @@ long offset_to_next_entry;
                 amount_to_read = ((DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE) - remaining_offset);
             }
 
-            disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], DEFAULT_DATA_POINTER_SIZE, tmp_buffer);
+            disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], DEFAULT_DATA_POINTER_SIZE, tmp_buffer, 0x7e0);
 
-            memcpy(data, (tmp_buffer + remaining_offset), amount_to_read);
+            memcpy(data, data_segment, (tmp_buffer + remaining_offset), 0x7e0, amount_to_read);
             data_length -= amount_to_read;
             amount_read += amount_to_read;
             remaining_offset -= amount_to_read;
 
-            data_pointer_index++;
+            data_pointer_index = data_pointer_index + 2; /* Rember that we only use 32-bit, and thats why we jump to at a time*/
             /* free(tmp_buffer); */
         }
         else 

implementation/lsfs.h

@@ -1,6 +1,280 @@
 #ifndef LSFS_H
 #define LSFS_H
+#include "../main.h"
+
 
 typedef struct lsfs_file lsfs_file;
+typedef struct Directory_Table Directory_Table;
+typedef struct Table_Entry Table_Entry;
+
+int lsfs_disk_getattr(find_file, path, fsci);
+int lsfs_disk_read_data_from_file(file, buffer_size, data,  offset_to_next_entry);
+Directory_Table* lsfs_find_directory(path, drop_filename, fsci);
+
+typedef enum Table_Entry_Kind
+{
+    /* These are specific values since, is has to corrospond to the implementation in assembly*/
+    ENTRY_EMPTY = 0,
+    ENTRY_FILE = 1,
+    ENTRY_DIRECTORY = 2,
+} Table_Entry_Kind;
+
+struct Table_Entry 
+{
+    char    filename[256]; 
+    unsigned long    file_id[2];
+    unsigned long    file_size[2];
+    void*   ext_file_data_low;
+    void*   ext_file_data_high;
+    long    number_sector_s; /* <- Just try to remove the last undercore and compile .          */
+    short   entry_kind;
+    short   extra_control_bits1;
+    short   extra_control_bits2;
+    short   extra_control_bits3;
+    long    table_entry_sector_index[2];
+    long    data_pointer[NUM_DATA_POINTERS * 2]; /* if it is a directory, the first pointer will be to the next table. */
+};
+
+struct lsfs_file {
+    unsigned long file_id[2];
+    long table_entry_pointer[2];
+    Table_Entry_Kind entry_kind;
+    char* filename;
+    long owner_id;
+    unsigned long size[2];
+    long creation_date[2]; 
+    long access_time[2];
+    long modification_time[2];
+    long number_sector;
+    long table_entry_sector_index[2];
+    long data_pointer[NUM_DATA_POINTERS * 2];
+};
+
+struct Directory_Table 
+{
+    Table_Entry entries[DEFAULT_TABLE_SIZE];
+
+}; 
+
+/*typedef struct File_System_Control_Information 
+{
+    char filesystem_information[256];
+    long master_table_index[2];
+    long this_partition_offset_on_disk[2];
+    long next_free_sector[2];
+    long next_uniqe_id[2]; /* both files and directories gets this. 
+    long next_sector_reuse_pointer[2];
+    long last_sector_index_on_partition[2];
+    long maximum_sectors_on_disk[2];
+    long sector_size_on_disk[2];
+    long not_used[48];
+
+} FSCI;
+*/
+
+int lsfs_disk_getattr(find_file, path, fsci) 
+lsfs_file* find_file; 
+char *path;
+FSCI *fsci;
+{
+    int i;
+    String_Array *split_path = string_split_c(path, '/', false);
+    Length_String *filename = split_path->strings[split_path->length-1]; 
+    
+    /* Start from the master table*/
+    Directory_Table *dir_table = lsfs_find_directory(path, true, fsci);
+
+    for (i = 0; i < DEFAULT_TABLE_SIZE; i++)
+    {
+    	int j;
+        print(dir_table->entries[i].filename);
+        print(filename->chars);
+        print_newline();
+        print_newline();
+        print("Size of table_entry: ");
+        dump_ax(sizeof(Table_Entry));
+        print_newline();
+        print_newline();
+        if(strcmp( filename->chars, dir_table->entries[i].filename ) == 0) {
+            find_file->file_id[0] = dir_table->entries[i].file_id[0];
+            find_file->entry_kind = dir_table->entries[i].entry_kind;
+            find_file->table_entry_pointer[0] = i;
+            find_file->filename = dir_table->entries[i].filename;
+            find_file->table_entry_sector_index[0] = dir_table->entries[i].table_entry_sector_index;
+            find_file->owner_id = 1;
+            find_file->size[0] = dir_table->entries[i].file_size[0]; /* dir_table->entries[i].data_pointer[0]; ;*/
+            find_file->creation_date[0] = 0;
+            find_file->access_time[0] = 0;
+            find_file->modification_time[0] = 0;
+            dump_ax(dir_table->entries[i].data_pointer[0]);
+            /* memcpy(find_file->data_pointer, dir_table->entries[i].data_pointer, NUM_DATA_POINTERS * 8); */
+            for (j = 0; j < NUM_DATA_POINTERS; j = j + 2)
+            {
+            	find_file->data_pointer[j] = dir_table->entries[i].data_pointer[j];
+            	dump_ax(find_file->data_pointer[j]);
+            }
+
+
+            find_file->number_sector = 1; /* TODO: should be loaded from disk.*/
+            return 1;
+        }
+    }
+    return 0;
+}
+
+Directory_Table* lsfs_find_directory(path, drop_filename, fsci)
+char *path;
+short drop_filename; 
+FSCI *fsci;
+{
+    int number_of_traversal;
+    int i, j;
+    String_Array *split_path;
+    Directory_Table *dir_table = calloc(1, sizeof(Directory_Table));
+    /* printf("Table index: %lu \n",fsci->master_table_index ); */
+    dump_ax(fsci->master_table_index[0]);
+    disk_service_read_data_from_disk(fsci->master_table_index[0], (long) DEFAULT_TABLE_SIZE, dir_table, 0x7e0);
+    print(dir_table->entries[0].filename);
+    split_path = string_split_c(path, '/', false);
+
+    number_of_traversal = split_path->length;
+	
+
+    if (drop_filename)
+    {
+        number_of_traversal -= 1;
+    }
+
+    /* Start from the master table */
+    for (i = 0; i < number_of_traversal; ++i)
+    {
+        for (j = 0; j < DEFAULT_TABLE_SIZE; ++j)
+        {
+        	print_newline();
+        	print("New: ");
+        	print(dir_table->entries[j].filename);
+        	print("vs ");
+        	print(split_path->strings[i]->chars);
+        	print_newline(); 
+            if (strcmp(dir_table->entries[j].filename, split_path->strings[i]->chars) == 0)
+            {
+                long index_sector = dir_table->entries[j].data_pointer[0];
+                /* printf("Table index: %lu \n",index_sector ); */
+				/* print(dir_table->entries[j].filename); */
+                dump_ax(index_sector);
+                disk_service_read_data_from_disk(index_sector, (long) DEFAULT_TABLE_SIZE, dir_table, 0x7e0);
+                break;
+            }
+        }
+    }
+    return dir_table;
+}
+
+int lsfs_disk_read_data_from_file(file, buffer_size, data, offset_to_next_entry, data_segment) 
+lsfs_file *file;
+unsigned int buffer_size; 
+char *data; 
+long offset_to_next_entry;
+unsigned int data_segment;
+{
+    unsigned int integer_file_size = file->size[0];
+    unsigned int integer_offset = offset_to_next_entry;
+    unsigned int integer_datapointer = 0;
+    unsigned int data_length = integer_file_size - integer_offset;
+    unsigned int amount_read = 0;
+    unsigned int amount_to_read = 0;
+    unsigned int remaining_offset = offset_to_next_entry;
+    void *next_data;
+    /* printf("READ: buffer_size: %d\n", buffer_size); */
+    /* printf("READ: Data length: %d\n", data_length); */
+    /* printf("READ: Offset length: %d\n", offset_to_next_entry); */
+
+
+    int data_pointer_index = 0; /*  start at first data pointer.  */
+
+    
+
+    if (data_length > buffer_size)
+    {
+        data_length = buffer_size;
+    }
+
+    while(data_length > 0) /*  We have more to write   */
+    {
+        /* printf("READ: Remaing Data length: %d\n", data_length); */
+        if (remaining_offset == 0)
+        {
+            char *tmp_buffer = calloc(DEFAULT_DATA_POINTER_SIZE, SECTOR_SIZE);
+            /* assert(tmp_buffer); */
+
+            if (data_length < (DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE)) 
+            {
+                amount_to_read = data_length;
+            }
+            else 
+            {
+                amount_to_read = (DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE);
+            }
+            /* disk_service_read_data_from_disk(lsfs_sector_offset index, uint32_t number_sector, void* data_buffer) */
+            integer_datapointer = file->data_pointer[data_pointer_index];
+            if (integer_datapointer == 0) 
+            {
+                break;
+            }
+            print_newline();
+            dump_ax(file->data_pointer[data_pointer_index]);
+            print_newline();
+            next_data = data + amount_read;
+            dump_ax(next_data);
+            print_newline();
+            disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], (long) DEFAULT_DATA_POINTER_SIZE, next_data, data_segment);
+            
+            /* memcpy((data + amount_read), data_segment, tmp_buffer, 0x7e0, amount_to_read); */
+            
+            data_length -= amount_to_read;
+            amount_read += amount_to_read;
+            data_pointer_index = data_pointer_index + 2; /* Rember that we only use 32-bit, and thats why we jump to at a time*/
+            /* free(tmp_buffer); */
+        }
+        else if (remaining_offset < (DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE)) 
+        {
+            char *tmp_buffer = calloc(1, (DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE));
+            /* assert(tmp_buffer); */
+
+            if (data_length < ((DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE) - remaining_offset) ) 
+            {
+                amount_to_read = data_length;
+            }
+            else 
+            {
+                amount_to_read = ((DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE) - remaining_offset);
+            }
+
+            disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], (long) DEFAULT_DATA_POINTER_SIZE, tmp_buffer, 0x7e0);
+
+            memcpy(data, data_segment, (tmp_buffer + remaining_offset), 0x7e0, amount_to_read);
+            data_length -= amount_to_read;
+            amount_read += amount_to_read;
+            remaining_offset -= amount_to_read;
+
+            data_pointer_index = data_pointer_index + 2; /* Rember that we only use 32-bit, and thats why we jump to at a time*/
+            /* free(tmp_buffer); */
+        }
+        else 
+        {
+            /*  We have to skip a whole data pointer:  */
+            remaining_offset -= (DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE);
+            data_pointer_index = data_pointer_index + 2;
+        }
+
+    }
+    /*
+    time_t current_time;
+    time ( &current_time );
+    file->access_time = current_time;
+    */
+    return amount_read;
+
+}
 
 #endif

main.c

@@ -4,6 +4,7 @@
 /* */
 #include "main.h"
 
+
 int main(selector, pointer_parameter_segment, pointer_parameter_struct) 
 int selector;
 void* pointer_parameter_segment;
@@ -12,19 +13,19 @@ void* pointer_parameter_struct;
     /*  selectot should be a "selector" for which disk service*/
     /*  one wnats to use. */
     /*  0 should not be used, to try to ensure that a value has been set explicitly.  */
-    FSCI fsci;
     
     Service_Action service_action;
     Directory_Table current_table;
     Parameter_Struct parameter_struct;
     int local_segment = 0x7e0;
-    unsigned int heap_start = 0x2000;
+    unsigned int heap_start = 0x2200;
     unsigned int heap_end = 0xffff;
     int stack_segment = 0x8fc0;
     int path_length;
-    long index_as_long; 
+    long index_as_long = 0; 
 
     char *local_path = 0; 
+    FSCI *fsci = 0x2000;
     service_action = selector;
 
     switch (service_action)
@@ -35,20 +36,36 @@ void* pointer_parameter_struct;
                 What do we need to know: 
                 Index of FSCI
             */
+            set_heap_settings(heap_start, heap_end);
             index_as_long = pointer_parameter_struct;
-            disk_service_read_data_from_disk(index_as_long, 1, &fsci, stack_segment);
+            disk_service_read_data_from_disk(index_as_long, (long) 1, fsci, local_segment);
             print("File System has been loaded: ");
             print_newline();
-            set_heap_settings(heap_start, heap_end);
+            print(fsci->filesystem_information);
-            print_stack(fsci.filesystem_information);
+            print_newline();
+            dump_ax(fsci->master_table_index[0]);
             print_newline();
         } break;
         case SERVICE_FIND_ENTRY:
         {
             String_Array *path_array;
+            lsfs_file* find_file;
             int i;
+            dump_ax(fsci->master_table_index[0]);
+            disk_service_read_data_from_disk(fsci->master_table_index[0], (long) DEFAULT_TABLE_SIZE, &current_table, stack_segment);
+            print("Current table: ");
+            print_newline();
+            print_stack(current_table.entries[0].filename);
+            print_newline();
+            print_stack(current_table.entries[1].filename);
+            print_newline();
+            print_stack(current_table.entries[2].filename);
+            print_newline();
+
+            
             memcpy(&parameter_struct, stack_segment, pointer_parameter_struct, pointer_parameter_segment, sizeof(Parameter_Struct));
             path_length = strlen(parameter_struct.path, pointer_parameter_segment); 
+            dump_ax(path_length);
             local_path = malloc(256);
             memcpy(local_path, local_segment, parameter_struct.path, pointer_parameter_segment, path_length);
             local_path[path_length] = 0; 
@@ -66,16 +83,23 @@ void* pointer_parameter_struct;
             print_newline();
             print_newline();
 
+            find_file = calloc(sizeof(lsfs_file), 1);
+            lsfs_disk_getattr(find_file, local_path, fsci);
             print_newline();
-            disk_service_read_data_from_disk(fsci.master_table_index[0], DEFAULT_TABLE_SIZE, &current_table, stack_segment);
+            print("Loding SingOS kernel: ");
-            print("Current table: ");
+            print(find_file->filename);
-            print_newline();
-            print_stack(current_table.entries[0].filename);
             print_newline();
-            print_stack(current_table.entries[1].filename);
+            print("Kernel file id: ");
+            dump_ax(find_file->file_id[0]);
             print_newline();
-            print_stack(current_table.entries[2].filename);
+            print("Kernel file size: ");
+            dump_ax(find_file->size[0]);
             print_newline();
+            print("Kernel first data pointer: ");
+            dump_ax(find_file->data_pointer[0]);
+
+            lsfs_disk_read_data_from_file(find_file, 0xffff, 0x00, (long) 0x0, 0x50);
+            
 
         } break;
         case SERIVCE_READ_DATA: 

main.h

@@ -1,14 +1,17 @@
 #ifndef MAIN_H
 #define MAIN_H
 
+#define false 0
+#define true 1
+
 #define SPACE_MBR_RECORD 2048 /* Sectors*/
 #define SPACE_VBR_RECORD 2048 /* Sectors*/
 #define SIZE_FSCI_RECORD    1 /* Sectors*/
 #define DEFAULT_ENTRY_SIZE  1 /* Sectors*/
 #define SECTOR_SIZE 512 /* BYTES*/
 #define NUMBER_OF_MBR_PARTITIONS 4
-#define DEFAULT_FILE_SIZE 4 /* This is in sectors*/
+#define DEFAULT_FILE_SIZE 8 /* This is in sectors*/
-#define DEFAULT_DATA_POINTER_SIZE 4 /* This is in sectors*/
+#define DEFAULT_DATA_POINTER_SIZE 8 /* This is in sectors*/
 #define DEFAULT_TABLE_SIZE 16 
 #define NUM_DATA_POINTERS 27 
 
@@ -17,27 +20,17 @@
 
 #include "std_singos/string.h"
 #include "driver/disk.h"
-#include "implementation/lsfs.h" 
 
 void dump_ax(input);
 void print_stack(argument);
 void print_newline();
 
-typedef struct Directory_Table Directory_Table;
-typedef struct Struct_Table_Entry Table_Entry;
 typedef struct struct_partition_control partition_control;
 typedef struct File_System_Control_Information FSCI;
 typedef struct meta_information_format mif;
 typedef struct tag_record tag_record;
 typedef struct Parameter_Struct Parameter_Struct;
 
-typedef enum Table_Entry_Kind
-{
-    /* These are specific values since, is has to corrospond to the implementation in assembly*/
-    ENTRY_EMPTY = 0,
-    ENTRY_FILE = 1,
-    ENTRY_DIRECTORY = 2,
-} Table_Entry_Kind;
 
 typedef enum Service_Action
 {
@@ -48,22 +41,6 @@ typedef enum Service_Action
 
 } Service_Action;
 
-struct Struct_Table_Entry 
-{
-    char    filename[256]; 
-    long    file_id[2];
-    long    file_size[2];
-    void*   ext_file_data_low;
-    void*   ext_file_data_high;
-    long    number_sector_s; /* <- Just try to remove the last undercore and compile .          */
-    short   entry_kind;
-    short   extra_control_bits1;
-    short   extra_control_bits2;
-    short   extra_control_bits3;
-    long    table_entry_sector_index[2];
-    long    data_pointer[NUM_DATA_POINTERS * 2]; /* if it is a directory, the first pointer will be to the next table. */
-}; 
-
 struct File_System_Control_Information 
 {
     char filesystem_information[256];
@@ -79,11 +56,6 @@ struct File_System_Control_Information
 
 };
 
-typedef struct Directory_Table 
-{
-    Table_Entry entries[DEFAULT_TABLE_SIZE];
-
-}; 
 
 struct Parameter_Struct 
 {
@@ -94,7 +66,8 @@ struct Parameter_Struct
     int buffer_size;
     int data_length;
     int byte_offset_into_file;
-    Table_Entry_Kind entry_kind;
+    short entry_kind;
 };
 
+#include "implementation/lsfs.h" 
 #endif

std_singos/string.h

@@ -165,6 +165,64 @@ int num_bytes;
     #endasm
 }
 
+int strcmp(source_1, source_2) 
+char* source_1;
+char* source_2;
+{
+    int i;
+    int count;
+
+    count = strlen(source_1, 0x7e0);
+    if (count != strlen(source_2, 0x7e0)) 
+    {
+        return -1;
+    }
+
+
+    for (i = 0; i < count; i++)
+    {
+        if(source_1[i] != source_2[i])
+        {
+            return -1; 
+        } 
+    }
+
+    return 0;
+    /*
+    #asm
+    #define DESTINATION 4[bp];
+    #define DESTINATION_SEGMENT 6[bp];
+    #define SOURCE 8[bp];
+    #define SOURCE_SEGMENT 10[bp];
+    ; Compares two strings
+    ; IN si: the first (zero terminated) string
+    ; IN di: the second (zero terminated) string
+    ; OUT SF and ZF (same semantics as cmp)
+    strcmp_stringcompare:
+        push bx
+        push si
+        push di
+    .strcmp_loop:
+        mov bl, [si]
+        mov bh, [di]
+        cmp bl, bh
+        jne .strcmp_end
+        test bl, bl     ; bl and bh are the same, so bl = 0 => dl = 0
+        jz .strcmp_end
+        inc si
+        inc di
+        jmp .strcmp_loop
+    .strcmp_end:
+        pop di
+        pop si
+        pop bx
+
+        ret
+
+    #endasm
+    */
+}
+
 String_Array *string_split_c(string, delim, keep_delim)
 char *string;
 char delim;