lsfs_16-bit/main.c

#include "main.h"

int main(selector, pointer_parameter_segment, pointer_parameter_struct) 
int selector;
void* pointer_parameter_segment;
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.  */
    
    Service_Action service_action;
    Directory_Table current_table;
    Parameter_Struct parameter_struct;
    int* local_segment; /* = 0x7e0; */
    unsigned int heap_start = 0x2200;
    unsigned int heap_end = 0xffff;
    int stack_segment = 0x8fc0;
    int path_length;
    long index_as_long = 0; 

    char *local_path = 0; 
    FSCI *fsci = global_heap_start - 0x200;
    service_action = selector;

    switch (service_action)
    {
        case SERIVCE_LOAD_DISK: 
        {
            /*
                What do we need to know: 
                Index of FSCI
            */
            memcpy(&parameter_struct, stack_segment, pointer_parameter_struct, pointer_parameter_segment, sizeof(Parameter_Struct));
            /*fsci = parameter_struct.buffer_segment; */ 
            local_segment = parameter_struct.buffer_segment;
            heap_start    = parameter_struct.buffer_address + 0x200;
            heap_end      = parameter_struct.buffer_size;
            index_as_long = parameter_struct.data_length;
            set_heap_settings(heap_start, heap_end);
            fsci = global_heap_start - 0x200;
            disk_service_read_data_from_disk(index_as_long, (long) 1, fsci, local_segment);
            print("File System has been loaded: ");
            print_newline();
            print(fsci->filesystem_information);
            print("16-bit implementation v0.2.1");
            print_newline();
        } break;
        case SERVICE_FIND_ENTRY:
        {
            String_Array *path_array;
            lsfs_file* find_file;
            int i;
            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); 
            local_path = malloc(256);
            memcpy(local_path, local_segment, parameter_struct.path, pointer_parameter_segment, path_length);
            local_path[path_length] = 0; 
            print("Read file: ");
            print(local_path);
            print_newline();

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

            find_file = calloc(sizeof(lsfs_file), 1);
            if ( !lsfs_disk_getattr(find_file, local_path, fsci) ) 
            {
                print("File not found");
                print_newline();
            }
            else
            {
                print("File has been read");
                print_newline();
            }
            /* 
            print_newline(); 
            print("Buffer_address: ");
            dump_ax(parameter_struct.buffer_address);
            print_newline(); 
            print("Buffer_segmnent: ");
            dump_ax(parameter_struct.buffer_segment);
            */
            lsfs_disk_read_data_from_file(find_file, parameter_struct.buffer_size, parameter_struct.buffer_address, (long) 0x0, parameter_struct.buffer_segment);
            

        } break;
        case SERIVCE_READ_DATA: 
        {
            /*
                What do we need to know: 
                    path
                     Buffer:
                    destination_segment
                    destination_address
                    buffer_size
                    offset_into_file
            */
            print("Hit READ case");
        } break;
        case SERIVCE_WRITE_DATA:
        {
            print("Hit WRITE case");
        } break;
        case SERIVCE_WRITE_FS_INFO:
        {
            /* print_newline(); */
            print(fsci->filesystem_information);
            /* print_newline(); */
        } break;

        default: 
        {
            print("Default case: ");
            dump_ax(service_action);
        }
    } 
    
    return 0;

}

/* void load_*/