mr4th-public
/
4coder
1
Fork 0
Code Issues Releases Activity
4coder/4coder_file.h

495 lines
14 KiB
C
Raw Blame History

/*
4coder_file.h - File enumeration and reading procedures for each platform.
*/
// TOP
#if !defined(FCODER_FILE_ENUMERATOR_CPP)
#define FCODER_FILE_ENUMERATOR_CPP
#include "4coder_base_types.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#if OS_WINDOWS
//// WINDOWS BEGIN ////
#define UNICODE
#include <Windows.h>
typedef TCHAR Filename_Character;
#define SLASH '\\'
//// WINDOWS END ////
#elif OS_LINUX || OS_MAC
//// UNIX BEGIN ////
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
typedef char Filename_Character;
#define SLASH '/'
//// UNIX END ////
#else
# error metdata generator not supported on this platform
#endif
struct Cross_Platform_File_Info{
Filename_Character *name;
int32_t len;
b32 is_folder;
};
struct Cross_Platform_File_List{
Cross_Platform_File_Info *info;
int32_t count;
int32_t path_length;
Filename_Character path_name[4096];
};
typedef b32 File_Filter(Filename_Character *name, int32_t len);
static Cross_Platform_File_List
get_file_list(Arena *arena, Filename_Character *dir, File_Filter *filter);
static Filename_Character*
encode(Arena *arena, char *str){
int32_t size = 0;
for (;str[size]!=0;++size);
Filename_Character *out = push_array(arena, Filename_Character, size + 1);
if (out == 0){
fprintf(stdout, "fatal error: ran out of memory encoding string to filename\n");
exit(1);
}
int32_t j = 0;
for (int32_t i = 0; i <= size; ++i){
if (str[i] != '"'){
out[j++] = str[i];
}
}
return(out);
}
static char*
unencode(Arena *arena, Filename_Character *str, int32_t len){
Temp_Memory temp = begin_temp(arena);
char *out = push_array(arena, char, len + 1);
if (out == 0){
fprintf(stdout, "fatal error: ran out of memory unencoding string to filename\n");
exit(1);
}
for (int32_t i = 0; i <= len; ++i){
if (str[i] <= 127){
out[i] = (char)str[i];
}
else{
out = 0;
end_temp(temp);
break;
}
}
return(out);
}
static b32
filter_all(Filename_Character *name, int32_t len){
return(true);
}
static b32
filter_is_code_file(Filename_Character *name, int32_t len){
b32 is_code = false;
if (len >= 5){
Filename_Character *ext = &name[len - 4];
if (ext[0] == '.' && ext[1] == 'c' && ext[2] == 'p' && ext[3] == 'p'){
is_code = true;
}
else if (ext[0] == '.' && ext[1] == 'h' && ext[2] == 'p' && ext[3] == 'p'){
is_code = true;
}
}
if (len >= 4){
Filename_Character *ext = &name[len - 3];
if (ext[0] == '.' && ext[1] == 'c' && ext[2] == 'c'){
is_code = true;
}
}
if (len >= 3){
Filename_Character *ext = &name[len - 2];
if (ext[0] == '.' && ext[1] == 'h'){
is_code = true;
}
else if (ext[0] == '.' && ext[1] == 'c'){
is_code = true;
}
}
return(is_code);
}
#if OS_WINDOWS
//// WINDOWS BEGIN ////
static Cross_Platform_File_List
get_file_list(Arena *arena, Filename_Character *pattern, File_Filter *filter){
if (arena == 0){
fprintf(stdout, "fatal error: NULL part passed to %s\n", __FUNCTION__);
exit(1);
}
if (pattern == 0){
fprintf(stdout, "fatal error: NULL pattern passed to %s\n", __FUNCTION__);
exit(1);
}
int32_t pattern_length = 0;
for (; pattern[pattern_length] != 0; ++pattern_length);
int32_t last_slash = pattern_length;
for (; last_slash >= 0 && pattern[last_slash] != SLASH; --last_slash);
if (last_slash < 0){
fprintf(stdout, "fatal error: invalid file pattern\n");
exit(1);
}
pattern[last_slash] = 0;
HANDLE dir_handle =
CreateFile(pattern,
FILE_LIST_DIRECTORY,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
0,
OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED,
0);
pattern[last_slash] = SLASH;
if (dir_handle == INVALID_HANDLE_VALUE){
fprintf(stdout, "fatal error: could not open directory handle\n");
exit(1);
}
Filename_Character path_name[4096];
DWORD path_length = GetFinalPathNameByHandle(dir_handle, path_name, sizeof(path_name), 0);
if (path_length > sizeof(path_name)){
fprintf(stdout, "fatal error: path name too long for local buffer\n");
exit(1);
}
CloseHandle(dir_handle);
path_length -= 4;
memmove(path_name, path_name + 4, path_length*sizeof(*path_name));
path_name[path_length] = 0;
// TODO(allen): // TODO(allen): // TODO(allen): // TODO(allen): // TODO(allen):
// TODO(allen): // TODO(allen): // TODO(allen): // TODO(allen): // TODO(allen):
// Get this working with the new search by pattern structure!!!
WIN32_FIND_DATA find_data = {};
HANDLE search = FindFirstFile(pattern, &find_data);
if (search == INVALID_HANDLE_VALUE){
fprintf(stdout, "fatal error: could not begin a file search\n");
exit(1);
}
int32_t character_count = 0;
int32_t file_count = 0;
BOOL more_files = true;
do{
Filename_Character *name = &find_data.cFileName[0];
int32_t size = 0;
for(;name[size];++size);
uint32_t attribs = find_data.dwFileAttributes;
b32 is_folder = ((attribs & FILE_ATTRIBUTE_DIRECTORY) != 0);
b32 is_hidden = ((attribs & FILE_ATTRIBUTE_HIDDEN) != 0);
if (!is_hidden){
if (name[0] != '.' && (is_folder || filter(name, size))){
++file_count;
character_count += size + 1;
}
}
more_files = FindNextFile(search, &find_data);
}while(more_files);
FindClose(search);
Cross_Platform_File_List list = {};
Temp_Memory part_reset = begin_temp(arena);
int32_t rounded_char_size = (character_count*sizeof(Filename_Character) + 7)&(~7);
int32_t memsize = rounded_char_size + file_count*sizeof(Cross_Platform_File_Info);
void *mem = push_array(arena, u8, memsize);
if (mem == 0){
fprintf(stdout, "fatal error: not enough memory on the partition for a file list.\n");
exit(1);
}
Filename_Character *char_ptr = (Filename_Character*)mem;
Cross_Platform_File_Info *info_ptr = (Cross_Platform_File_Info*)((uint8_t*)mem + rounded_char_size);
Filename_Character *char_ptr_end = (Filename_Character*)info_ptr;
Cross_Platform_File_Info *info_ptr_end = info_ptr + file_count;
Cross_Platform_File_Info *info_ptr_base = info_ptr;
search = FindFirstFile(pattern, &find_data);
if (search == INVALID_HANDLE_VALUE){
fprintf(stdout, "fatal error: could not restart a file search\n");
exit(1);
}
int32_t adjusted_file_count = 0;
more_files = true;
do{
Filename_Character *name = &find_data.cFileName[0];
int32_t size = 0;
for(;name[size]!=0;++size);
uint32_t attribs = find_data.dwFileAttributes;
b32 is_folder = ((attribs & FILE_ATTRIBUTE_DIRECTORY) != 0);
b32 is_hidden = ((attribs & FILE_ATTRIBUTE_HIDDEN) != 0);
if (!is_hidden){
if (name[0] != '.' && (is_folder || filter(name, size))){
if (info_ptr + 1 > info_ptr_end || char_ptr + size + 1 > char_ptr_end){
memset(&list, 0, sizeof(list));
end_temp(part_reset);
FindClose(search);
return(list);
}
info_ptr->name = char_ptr;
info_ptr->len = size;
info_ptr->is_folder = is_folder;
memmove(char_ptr, name, size*sizeof(*name));
char_ptr[size] = 0;
char_ptr += size + 1;
++info_ptr;
++adjusted_file_count;
}
}
more_files = FindNextFile(search, &find_data);
}while(more_files);
FindClose(search);
list.info = info_ptr_base;
list.count = adjusted_file_count;
list.path_length = path_length;
memcpy(list.path_name, path_name, list.path_length*sizeof(*path_name));
list.path_name[list.path_length] = 0;
return(list);
}
//// WINDOWS END ////
#elif OS_LINUX || OS_MAC
//// UNIX BEGIN ////
static b32
match_pattern(Filename_Character *name, Filename_Character *pattern){
b32 match = false;
if (sizeof(*name) == 1){
Absolutes absolutes = {};
String pattern_str = make_string_slowly(pattern);
get_absolutes(pattern_str, &absolutes, false, false);
match = wildcard_match_c(&absolutes, name, false);
}
else{
fprintf(stdout, "fatal error: wide characters not supported!\n");
exit(1);
}
return(match);
}
static Cross_Platform_File_List
get_file_list(Partition *part, Filename_Character *pattern, File_Filter *filter){
if (part == 0){
fprintf(stdout, "fatal error: NULL part passed to %s\n", __FUNCTION__);
exit(1);
}
if (pattern == 0){
fprintf(stdout, "fatal error: NULL dir passed to %s\n", __FUNCTION__);
exit(1);
}
int32_t pattern_length = 0;
for (; pattern[pattern_length] != 0; ++pattern_length);
int32_t last_slash = pattern_length;
for (; last_slash > 0 && pattern[last_slash] != SLASH; --last_slash);
if (last_slash < 0){
fprintf(stdout, "fatal error: invalid file pattern\n");
exit(1);
}
pattern[last_slash] = 0;
DIR *dir_handle = opendir(pattern);
if (dir_handle == 0){
fprintf(stdout, "fatal error: could not open directory handle\n");
if (sizeof(*pattern) == 2){
fprintf(stdout, "%ls\n", (wchar_t*)pattern);
}
else{
fprintf(stdout, "%s\n", (char*)pattern);
}
exit(1);
}
Filename_Character path_name[4096];
int32_t path_length = str_size(pattern);
if (path_length + 1 > sizeof(path_name)){
fprintf(stdout, "fatal error: path name too long for local buffer\n");
exit(1);
}
memcpy(path_name, pattern, path_length + 1);
char *file_pattern = pattern + last_slash + 1;
int32_t character_count = 0;
int32_t file_count = 0;
for (struct dirent *entry = readdir(dir_handle);
entry != 0;
entry = readdir(dir_handle)){
Filename_Character *name = entry->d_name;
if (!match_pattern(name, file_pattern)){
continue;
}
int32_t size = 0;
for(;name[size];++size);
b32 is_folder = false;
if (entry->d_type == DT_LNK){
struct stat st;
if (stat(entry->d_name, &st) != -1){
is_folder = S_ISDIR(st.st_mode);
}
}
else{
is_folder = (entry->d_type == DT_DIR);
}
if (name[0] != '.' && (is_folder || filter(name, size))){
++file_count;
character_count += size + 1;
}
}
Cross_Platform_File_List list = {};
Temp_Memory part_reset = begin_temp_memory(part);
int32_t rounded_char_size = (character_count*sizeof(Filename_Character) + 7)&(~7);
int32_t memsize = rounded_char_size + file_count*sizeof(Cross_Platform_File_Info);
void *mem = push_array(part, uint8_t, memsize);
if (mem == 0){
fprintf(stdout, "fatal error: not enough memory on the partition for a file list.\n");
exit(1);
}
Filename_Character *char_ptr = (Filename_Character*)mem;
Cross_Platform_File_Info *info_ptr = (Cross_Platform_File_Info*)((uint8_t*)mem + rounded_char_size);
Filename_Character *char_ptr_end = (Filename_Character*)info_ptr;
Cross_Platform_File_Info *info_ptr_end = info_ptr + file_count;
Cross_Platform_File_Info *info_ptr_base = info_ptr;
rewinddir(dir_handle);
int32_t adjusted_file_count = 0;
for (struct dirent *entry = readdir(dir_handle);
entry != 0;
entry = readdir(dir_handle)){
Filename_Character *name = entry->d_name;
if (!match_pattern(name, file_pattern)){
continue;
}
int32_t size = 0;
for(;name[size];++size);
b32 is_folder = false;
if (entry->d_type == DT_LNK){
struct stat st;
if (stat(entry->d_name, &st) != -1){
is_folder = S_ISDIR(st.st_mode);
}
}
else{
is_folder = (entry->d_type == DT_DIR);
}
if (name[0] != '.' && (is_folder || filter(name, size))){
if (info_ptr + 1 > info_ptr_end || char_ptr + size + 1 > char_ptr_end){
memset(&list, 0, sizeof(list));
end_temp_memory(part_reset);
closedir(dir_handle);
return(list);
}
info_ptr->name = char_ptr;
info_ptr->len = size;
info_ptr->is_folder = is_folder;
memmove(char_ptr, name, size*sizeof(*name));
char_ptr[size] = 0;
char_ptr += size + 1;
++info_ptr;
++adjusted_file_count;
}
}
closedir(dir_handle);
list.info = info_ptr_base;
list.count = adjusted_file_count;
list.path_length = path_length;
memcpy(list.path_name, path_name, list.path_length*sizeof(*path_name));
list.path_name[list.path_length] = 0;
return(list);
}
//// UNIX END ////
#else
# error metdata generator not supported on this platform
#endif
static String_Const_u8
file_dump(Arena *arena, char *name){
String_Const_u8 text = {};
FILE *file = fopen(name, "rb");
if (file != 0){
fseek(file, 0, SEEK_END);
text.size = ftell(file);
fseek(file, 0, SEEK_SET);
text.str = push_array(arena, u8, text.size + 1);
if (text.str == 0){
fprintf(stdout, "fatal error: not enough memory in partition for file dumping");
exit(1);
}
fread(text.str, 1, text.size, file);
text.str[text.size] = 0;
fclose(file);
}
return(text);
}
#endif
// BOTTOM
Reference in New Issue View Git Blame Copy Permalink