Copying file contents rather than memory mapping

src/build_settings.cpp

@@ -222,6 +222,8 @@ struct BuildContext {
 	bool threaded_checker;
 
 	bool show_debug_messages;
+	
+	bool copy_file_contents;
 
 	u32 cmd_doc_flags;
 	Array<String> extra_packages;
@@ -771,6 +773,8 @@ void init_build_context(TargetMetrics *cross_target) {
 	bc->ODIN_VENDOR  = str_lit("odin");
 	bc->ODIN_VERSION = ODIN_VERSION;
 	bc->ODIN_ROOT    = odin_root_dir();
+	
+	bc->copy_file_contents = true;
 
 	TargetMetrics *metrics = nullptr;
 

src/common.cpp

@@ -883,33 +883,33 @@ ReadDirectoryError read_directory(String path, Array<FileInfo> *fi) {
 
 
 
-struct MemoryMappedFile {
+struct LoadedFile {
 	void *handle;
 	
-	void *data;
-	i32   size;
+	void const *data;
+	i32         size;
 };
-enum MemoryMappedFileError {
-	MemoryMappedFile_None,
+enum LoadedFileError {
+	LoadedFile_None,
 	
-	MemoryMappedFile_Empty,
-	MemoryMappedFile_FileTooLarge,
-	MemoryMappedFile_Invalid,
-	MemoryMappedFile_NotExists,
-	MemoryMappedFile_Permission,
+	LoadedFile_Empty,
+	LoadedFile_FileTooLarge,
+	LoadedFile_Invalid,
+	LoadedFile_NotExists,
+	LoadedFile_Permission,
 	
-	MemoryMappedFile_COUNT,
+	LoadedFile_COUNT,
 };
 
-MemoryMappedFileError memory_map_file_32(char const *fullpath, MemoryMappedFile *memory_mapped_file, bool copy_file_contents) {
-	MemoryMappedFileError err = MemoryMappedFile_None;
+LoadedFileError load_file_32(char const *fullpath, LoadedFile *memory_mapped_file, bool copy_file_contents) {
+	LoadedFileError err = LoadedFile_None;
 	
 	if (!copy_file_contents) {
 	#if defined(GB_SYSTEM_WINDOWS)
 		isize w_len = 0;
 		wchar_t *w_str = gb__alloc_utf8_to_ucs2(temporary_allocator(), fullpath, &w_len);
 		if (w_str == nullptr) {
-			return MemoryMappedFile_Invalid;
+			return LoadedFile_Invalid;
 		}
 		i64 file_size = 0;
 		LARGE_INTEGER li_file_size = {};
@@ -930,12 +930,12 @@ MemoryMappedFileError memory_map_file_32(char const *fullpath, MemoryMappedFile
 		file_size = cast(i64)li_file_size.QuadPart;
 		if (file_size > I32_MAX) {
 			CloseHandle(handle);
-			return MemoryMappedFile_FileTooLarge;
+			return LoadedFile_FileTooLarge;
 		}
 		
 		if (file_size == 0) {
 			CloseHandle(handle);
-			err = MemoryMappedFile_Empty;
+			err = LoadedFile_Empty;
 			memory_mapped_file->handle = nullptr;
 			memory_mapped_file->data   = nullptr;
 			memory_mapped_file->size   = 0;
@@ -955,16 +955,16 @@ MemoryMappedFileError memory_map_file_32(char const *fullpath, MemoryMappedFile
 		{
 			DWORD handle_err = GetLastError();
 			CloseHandle(handle);
-			err = MemoryMappedFile_Invalid;
+			err = LoadedFile_Invalid;
 			switch (handle_err) {
 			case ERROR_FILE_NOT_FOUND: 
 			case ERROR_PATH_NOT_FOUND: 
 			case ERROR_INVALID_DRIVE:
-				err = MemoryMappedFile_NotExists; 
+				err = LoadedFile_NotExists; 
 				break;
 			case ERROR_ACCESS_DENIED: 
 			case ERROR_INVALID_ACCESS:
-				err = MemoryMappedFile_Permission;
+				err = LoadedFile_Permission;
 				break;
 			}
 			return err;
@@ -975,7 +975,7 @@ MemoryMappedFileError memory_map_file_32(char const *fullpath, MemoryMappedFile
 	gbFileContents fc = gb_file_read_contents(heap_allocator(), true, fullpath);
 
 	if (fc.size > I32_MAX) {
-		err = MemoryMappedFile_FileTooLarge;
+		err = LoadedFile_FileTooLarge;
 		gb_file_free_contents(&fc);
 	} else if (fc.data != nullptr) {
 		memory_mapped_file->handle = nullptr;
@@ -987,13 +987,13 @@ MemoryMappedFileError memory_map_file_32(char const *fullpath, MemoryMappedFile
 		defer (gb_file_close(&f));
 
 		switch (file_err) {
-		case gbFileError_Invalid:    err = MemoryMappedFile_Invalid;    break;
-		case gbFileError_NotExists:  err = MemoryMappedFile_NotExists;  break;
-		case gbFileError_Permission: err = MemoryMappedFile_Permission; break;
+		case gbFileError_Invalid:    err = LoadedFile_Invalid;    break;
+		case gbFileError_NotExists:  err = LoadedFile_NotExists;  break;
+		case gbFileError_Permission: err = LoadedFile_Permission; break;
 		}
 
-		if (err == MemoryMappedFile_None && gb_file_size(&f) == 0) {
-			err = MemoryMappedFile_Empty;
+		if (err == LoadedFile_None && gb_file_size(&f) == 0) {
+			err = LoadedFile_Empty;
 		}
 	}
 	return err;

src/parser.cpp

@@ -4615,8 +4615,7 @@ ParseFileError init_ast_file(AstFile *f, String fullpath, TokenPos *err_pos) {
 	zero_item(&f->tokenizer);
 	f->tokenizer.curr_file_id = f->id;
 
-	bool copy_file_contents = build_context.command_kind == Command_strip_semicolon;
-	TokenizerInitError err = init_tokenizer_from_fullpath(&f->tokenizer, f->fullpath, copy_file_contents);
+	TokenizerInitError err = init_tokenizer_from_fullpath(&f->tokenizer, f->fullpath, build_context.copy_file_contents);
 	if (err != TokenizerInit_None) {
 		switch (err) {
 		case TokenizerInit_Empty:

src/tokenizer.cpp

@@ -723,7 +723,7 @@ struct Tokenizer {
 
 	bool insert_semicolon;
 	
-	MemoryMappedFile memory_mapped_file;
+	LoadedFile loaded_file;
 };
 
 
@@ -790,7 +790,7 @@ void advance_to_next_rune(Tokenizer *t) {
 	}
 }
 
-void init_tokenizer_with_data(Tokenizer *t, String const &fullpath, void *data, isize size) {
+void init_tokenizer_with_data(Tokenizer *t, String const &fullpath, void const *data, isize size) {
 	t->fullpath = fullpath;
 	t->line_count = 1;
 
@@ -804,29 +804,29 @@ void init_tokenizer_with_data(Tokenizer *t, String const &fullpath, void *data,
 	}
 }
 
-TokenizerInitError memory_mapped_file_error_map_to_tokenizer[MemoryMappedFile_COUNT] = {
-	TokenizerInit_None,         /*MemoryMappedFile_None*/
-	TokenizerInit_Empty,        /*MemoryMappedFile_Empty*/
-	TokenizerInit_FileTooLarge, /*MemoryMappedFile_FileTooLarge*/
-	TokenizerInit_Invalid,      /*MemoryMappedFile_Invalid*/
-	TokenizerInit_NotExists,    /*MemoryMappedFile_NotExists*/
-	TokenizerInit_Permission,   /*MemoryMappedFile_Permission*/
+TokenizerInitError loaded_file_error_map_to_tokenizer[LoadedFile_COUNT] = {
+	TokenizerInit_None,         /*LoadedFile_None*/
+	TokenizerInit_Empty,        /*LoadedFile_Empty*/
+	TokenizerInit_FileTooLarge, /*LoadedFile_FileTooLarge*/
+	TokenizerInit_Invalid,      /*LoadedFile_Invalid*/
+	TokenizerInit_NotExists,    /*LoadedFile_NotExists*/
+	TokenizerInit_Permission,   /*LoadedFile_Permission*/
 };
 
 TokenizerInitError init_tokenizer_from_fullpath(Tokenizer *t, String const &fullpath, bool copy_file_contents) {
-	MemoryMappedFileError mmf_err = memory_map_file_32(
+	LoadedFileError file_err = load_file_32(
 		alloc_cstring(temporary_allocator(), fullpath), 
-		&t->memory_mapped_file,
+		&t->loaded_file,
 		copy_file_contents
 	);
 	
-	TokenizerInitError err = memory_mapped_file_error_map_to_tokenizer[mmf_err];
-	switch (mmf_err) {
-	case MemoryMappedFile_None:
-		init_tokenizer_with_data(t, fullpath, t->memory_mapped_file.data, cast(isize)t->memory_mapped_file.size);
+	TokenizerInitError err = loaded_file_error_map_to_tokenizer[file_err];
+	switch (file_err) {
+	case LoadedFile_None:
+		init_tokenizer_with_data(t, fullpath, t->loaded_file.data, cast(isize)t->loaded_file.size);
 		break;
-	case MemoryMappedFile_FileTooLarge:
-	case MemoryMappedFile_Empty:
+	case LoadedFile_FileTooLarge:
+	case LoadedFile_Empty:
 		t->fullpath = fullpath;
 		t->line_count = 1;
 		break;