lsfs_16-bit/main.c

// Adress to dump ax, 7C2A
// Address to print 7C47
//
//

#include "std_singos/string.h"
#include "std_singos/stdio.h"
#include "driver/disk.h"

#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_DATA_POINTER_SIZE 4 // This is in sectors
#define DEFAULT_TABLE_SIZE 16 
#define NUM_DATA_POINTERS 27 

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 lsfs_file lsfs_file;
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
{
    SERIVCE_LOAD_DISK  = 1,
    SERVICE_FIND_ENTRY = 2,
    SERIVCE_READ_DATA  = 3,
    SERIVCE_WRITE_DATA = 4,

} 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];
    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];

};

typedef struct Directory_Table 
{
    Table_Entry entries[DEFAULT_TABLE_SIZE];

}; 

struct Parameter_Struct 
{
    char* path;
    char* new_path;
    int buffer_segment;
    int buffer_address;
    int buffer_size;
    int data_length;
    int byte_offset_into_file;
    Table_Entry_Kind entry_kind;
};

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.  
    FSCI fsci;
    Service_Action service_action;
    Directory_Table current_table;
    Parameter_Struct parameter_struct;
    int local_segment = 0x7e0;
    int stack_segment = 0x8fc0;
    int path_length;
    long index_as_long; 

    char local_path[256]; 
    service_action = selector;

    switch (service_action)
    {
        case SERIVCE_LOAD_DISK: 
        {
            /*
                What do we need to know: 
                Index of FSCI
            */
            index_as_long = pointer_parameter_struct;
            disk_service_read_data_from_disk(index_as_long, 1, &fsci, stack_segment);
            print("File System has been loaded: ");
            print_newline();
            print_stack(fsci.filesystem_information);
            print_newline();
        } break;
        case SERVICE_FIND_ENTRY:
        {
            memcpy(&parameter_struct, stack_segment, pointer_parameter_struct, pointer_parameter_segment, sizeof(Parameter_Struct));
            path_length = strlen(parameter_struct.path, pointer_parameter_segment); 
            memcpy(local_path, stack_segment, parameter_struct.path, pointer_parameter_segment, path_length);
            local_path[path_length] = 0; 
            print_stack(local_path);
            print_newline();
            disk_service_read_data_from_disk(fsci.master_table_index[0], 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();
        } 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;
        default: 
        {
            print("Default case");
        }
    } 
    
    return 0;

}

//void load_