144 lines
3.9 KiB
C
144 lines
3.9 KiB
C
#include "filesystem.h"
|
|
#include "../String/StringBuilder.h"
|
|
#include "io_includes.h"
|
|
|
|
void __file_destructMembers(void* _f){ fclose((FileHandle)_f); }
|
|
|
|
kt_define(FileHandle, __file_destructMembers, NULL)
|
|
|
|
bool file_exists(const char* path){
|
|
if(path[0]=='.'){
|
|
if(path[1]==0 || (path[1]==path_sep && path[2]==0))
|
|
return false; // . or ./ is not a file
|
|
// else if(path[1]=='.' && path[2]==path_sep)
|
|
//TODO path_resolve because windows doesnt recognize .\ pattern
|
|
}
|
|
|
|
#if KFS_USE_WINDOWS_H
|
|
DWORD dwAttrib = GetFileAttributes(path);
|
|
return (bool)(
|
|
(dwAttrib != INVALID_FILE_ATTRIBUTES) && // file exists
|
|
!(dwAttrib & FILE_ATTRIBUTE_DIRECTORY)); // file is not directory
|
|
#else
|
|
struct stat stats;
|
|
i32 rez=stat(path, &stats);
|
|
return (bool)(
|
|
(rez!=-1) && // file exists
|
|
!(S_ISDIR(stats.st_mode))); // file is not directory
|
|
#endif
|
|
}
|
|
|
|
Maybe file_delete(const char* path, bool recursive){
|
|
throw(ERR_NOTIMPLEMENTED);
|
|
return MaybeNull;
|
|
}
|
|
|
|
char* FileOpenMode_toStr(FileOpenMode m){
|
|
char* p;
|
|
switch(m){
|
|
case FileOpenMode_Read: p="rb"; break;
|
|
case FileOpenMode_Write: p="wb"; break;
|
|
case FileOpenMode_Append: p="ab"; break;
|
|
case FileOpenMode_ReadWrite: p="wb+"; break;
|
|
case FileOpenMode_ReadAppend: p="ab+"; break;
|
|
default:
|
|
dbg(m);
|
|
throw(ERR_UNEXPECTEDVAL);
|
|
}
|
|
return p;
|
|
}
|
|
|
|
Maybe file_open(const char* path, FileOpenMode mode){
|
|
FileHandle file=fopen(path, FileOpenMode_toStr(mode));
|
|
LinearAllocator _al; LinearAllocator_construct(&_al, 128);
|
|
allocator_ptr al=&_al.base;
|
|
if(!file)
|
|
safethrow(cptr_concat(al, "can't open file ", (char*)path), LinearAllocator_destruct(&_al));
|
|
LinearAllocator_destruct(&_al);
|
|
return SUCCESS(UniHeapPtr(FileHandle,file));
|
|
}
|
|
|
|
Maybe file_close(FileHandle file){
|
|
if(!file)
|
|
safethrow(ERR_NULLPTR,;);
|
|
if(fclose(file))
|
|
safethrow(ERR_IO,;);
|
|
return MaybeNull;
|
|
}
|
|
|
|
#define ioWriteCheck() \
|
|
if(rezult==EOF) \
|
|
safethrow(ERR_IO_EOF,;); \
|
|
if(rezult!=0) \
|
|
safethrow(ERR_IO,;);
|
|
|
|
Maybe file_writeChar(FileHandle file, char byte){
|
|
i32 rezult=fputc(byte, file);
|
|
ioWriteCheck();
|
|
return MaybeNull;
|
|
}
|
|
|
|
Maybe file_writeBuffer(FileHandle file, char* buffer, u64 length){
|
|
i32 rezult=0;
|
|
for(u64 i=0; i<length && !rezult; i++)
|
|
rezult=fputc(buffer[i], file);
|
|
ioWriteCheck();
|
|
return MaybeNull;
|
|
}
|
|
|
|
Maybe file_writeCptr(FileHandle file, char* cptr){
|
|
i32 rezult=fputs(cptr, file);
|
|
ioWriteCheck();
|
|
return MaybeNull;
|
|
}
|
|
|
|
|
|
Maybe file_readChar(FileHandle file){
|
|
i32 rezult=fgetc(file);
|
|
if(feof(file)) safethrow(ERR_IO_EOF,;);
|
|
if(ferror(file)) safethrow(ERR_IO,;);
|
|
return SUCCESS(UniUInt64(rezult));
|
|
}
|
|
|
|
Maybe file_readBuffer(FileHandle file, char* buffer, u64 length){
|
|
i32 rezult=0;
|
|
u64 i=0;
|
|
for(; i<length && rezult!=EOF; i++){
|
|
rezult=fgetc(file);
|
|
buffer[i]=(char)rezult;
|
|
}
|
|
if(ferror(file)) safethrow(ERR_IO,;);
|
|
return SUCCESS(UniUInt64(i));
|
|
}
|
|
|
|
Maybe file_readAll(FileHandle file, char** allBytes){
|
|
i32 rezult=0;
|
|
char buffer[256];
|
|
string bufStr={.ptr=buffer, .length=sizeof(buffer)};
|
|
StringBuilder _sb;
|
|
StringBuilder* sb=&_sb;
|
|
StringBuilder_construct(sb, NULL);
|
|
u64 i=0;
|
|
while(true){
|
|
rezult=fgetc(file);
|
|
if(rezult==EOF){
|
|
if(ferror(file))
|
|
safethrow(ERR_IO, StringBuilder_destruct(sb));
|
|
break;
|
|
}
|
|
buffer[i%sizeof(buffer)]=(char)rezult;
|
|
i++;
|
|
if(!(i%sizeof(buffer)))
|
|
StringBuilder_append_string(sb,bufStr);
|
|
}
|
|
bufStr.length=i%sizeof(buffer);
|
|
if(bufStr.length!=0)
|
|
StringBuilder_append_string(sb,bufStr);
|
|
string str=StringBuilder_build(sb);
|
|
*allBytes=str.ptr;
|
|
// i dont know how can it happen, but if it will have, it will be very dangerous
|
|
if(i!=str.length)
|
|
throw(ERR_UNEXPECTEDVAL);
|
|
return SUCCESS(UniUInt64(i));
|
|
}
|