file.h

Go to the documentation of this file.

 
#ifndef SOLIDC_FILE_H
#define SOLIDC_FILE_H
 
#if !defined(_POSIX_C_SOURCE) && !defined(_WIN32)
#define _POSIX_C_SOURCE   200809L  // For fstat, fileno, pwrite, pread, fcntl, etc.
#define _FILE_OFFSET_BITS 64       // Ensure 64-bit off_t on 32-bit POSIX systems
#endif
 
#include "platform.h"
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
 
// Platform detection and feature setup
#ifdef _WIN32
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <io.h>
#include <windows.h>
 
// Define ssize_t for Windows if not already defined
#if defined(_MSC_VER) && !defined(_SSIZE_T_DEFINED)
typedef intptr_t ssize_t;
#define _SSIZE_T_DEFINED
#endif
 
// Windows-specific file handle type
typedef HANDLE native_handle_t;
#define INVALID_NATIVE_HANDLE INVALID_HANDLE_VALUE
 
#else  // POSIX systems
 
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
 
// POSIX file handle type
typedef int native_handle_t;
 
enum { INVALID_NATIVE_HANDLE = (-1) };
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum FileAttrFlags {
    FATTR_NONE = 0,            
    FATTR_FILE = 1 << 0,       
    FATTR_DIR = 1 << 1,        
    FATTR_SYMLINK = 1 << 2,    
    FATTR_CHARDEV = 1 << 3,    
    FATTR_BLOCKDEV = 1 << 4,   
    FATTR_FIFO = 1 << 5,       
    FATTR_SOCKET = 1 << 6,     
    FATTR_HIDDEN = 1 << 7,     
    FATTR_EXECUTABLE = 1 << 8, 
} FileAttrFlags;
 
typedef struct FileAttributes {
    uint32_t attrs;
 
    size_t size;
 
    time_t mtime;
} FileAttributes;
 
static inline bool fattr_has(const FileAttributes* attr, FileAttrFlags flag) { return (attr->attrs & flag) != 0; }
 
static inline bool fattr_is_file(const FileAttributes* attr) { return (attr->attrs & FATTR_FILE) != 0; }
 
static inline bool fattr_is_dir(const FileAttributes* attr) { return (attr->attrs & FATTR_DIR) != 0; }
 
static inline bool fattr_is_symlink(const FileAttributes* attr) { return (attr->attrs & FATTR_SYMLINK) != 0; }
 
static inline bool fattr_is_device(const FileAttributes* attr) {
    return (attr->attrs & (FATTR_CHARDEV | FATTR_BLOCKDEV)) != 0;
}
 
int populate_file_attrs(const char* path, FileAttributes* attr);
 
typedef struct {
    FILE* stream;                  
    FileAttributes attr;           // File attributes
    native_handle_t native_handle; 
} file_t;
 
typedef enum {
    FILE_SUCCESS = 0,         
    FILE_ERROR_INVALID_ARGS,  
    FILE_ERROR_OPEN_FAILED,   
    FILE_ERROR_IO_FAILED,     
    FILE_ERROR_LOCK_FAILED,   
    FILE_ERROR_MEMORY_FAILED, 
    FILE_ERROR_SYSTEM_ERROR   
} file_result_t;
 
file_result_t file_open(file_t* file, const char* filename, const char* mode);
 
void file_close(file_t* file);
 
file_result_t file_truncate(file_t* file, int64_t length);
 
file_result_t filesize_tostring(uint64_t size, char* buf, size_t len);
 
size_t file_read(const file_t* file, void* buffer, size_t size, size_t count);
 
size_t file_write(file_t* file, const void* buffer, size_t size, size_t count);
 
size_t file_write_string(file_t* file, const char* str);
 
ssize_t file_pread(const file_t* file, void* buffer, size_t size, int64_t offset);
 
ssize_t file_pwrite(file_t* file, const void* buffer, size_t size, int64_t offset);
 
void* file_readall(file_t* file, size_t* size_out);
 
file_result_t file_lock(const file_t* file);
 
file_result_t file_unlock(const file_t* file);
 
file_result_t file_copy(const file_t* src, file_t* dst);
 
void* file_mmap(const file_t* file, size_t length, bool read_access, bool write_access);
 
file_result_t file_munmap(void* addr, size_t length);
 
file_result_t file_flush(file_t* file);
 
int64_t file_tell(const file_t* file);
 
file_result_t file_seek(file_t* file, int64_t offset, int whence);
 
#ifdef __cplusplus
}
#endif
 
#endif /* SOLIDC_FILE_H */