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

introduced memory debugging mode, finished comment wrapping rule

master
Allen Webster 2016-10-22 11:30:25 -04:00
parent 6f64d7c12e
commit 43d6c29e8b
11 changed files with 513 additions and 319 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
4coder_mem.h
View File

@ -146,6 +146,36 @@ general_sentinel_init(Bubble *bubble){
bubble->size = 0;
}
#define BUBBLE_MIN_SIZE 1024
static void
general_memory_attempt_split(General_Memory *general, Bubble *bubble, int32_t wanted_size){
int32_t remaining_size = bubble->size - wanted_size;
if (remaining_size >= BUBBLE_MIN_SIZE){
bubble->size = wanted_size;
Bubble *new_bubble = (Bubble*)((char*)(bubble + 1) + wanted_size);
new_bubble->flags = (uint32_t)MEM_BUBBLE_FLAG_INIT;
new_bubble->size = remaining_size - sizeof(Bubble);
insert_bubble(bubble, new_bubble);
insert_bubble2(&general->free_sentinel, new_bubble);
}
}
inline void
general_memory_do_merge(Bubble *left, Bubble *right){
left->size += sizeof(Bubble) + right->size;
remove_bubble(right);
remove_bubble2(right);
}
inline void
general_memory_attempt_merge(Bubble *left, Bubble *right){
if (!(left->flags & MEM_BUBBLE_USED) && !(right->flags & MEM_BUBBLE_USED)){
general_memory_do_merge(left, right);
}
}
// NOTE(allen): public procedures
static void
general_memory_open(General_Memory *general, void *memory, int32_t size){
general_sentinel_init(&general->sentinel);
@ -188,21 +218,6 @@ static int32_t
general_memory_check(General_Memory *general){}
#endif
#define BUBBLE_MIN_SIZE 1024
static void
general_memory_attempt_split(General_Memory *general, Bubble *bubble, int32_t wanted_size){
int32_t remaining_size = bubble->size - wanted_size;
if (remaining_size >= BUBBLE_MIN_SIZE){
bubble->size = wanted_size;
Bubble *new_bubble = (Bubble*)((char*)(bubble + 1) + wanted_size);
new_bubble->flags = (uint32_t)MEM_BUBBLE_FLAG_INIT;
new_bubble->size = remaining_size - sizeof(Bubble);
insert_bubble(bubble, new_bubble);
insert_bubble2(&general->free_sentinel, new_bubble);
}
}
static void*
general_memory_allocate(General_Memory *general, int32_t size){
void *result = 0;
@ -224,20 +239,6 @@ general_memory_allocate(General_Memory *general, int32_t size){
return(result);
}
inline void
general_memory_do_merge(Bubble *left, Bubble *right){
left->size += sizeof(Bubble) + right->size;
remove_bubble(right);
remove_bubble2(right);
}
inline void
general_memory_attempt_merge(Bubble *left, Bubble *right){
if (!(left->flags & MEM_BUBBLE_USED) && !(right->flags & MEM_BUBBLE_USED)){
general_memory_do_merge(left, right);
}
}
static void
general_memory_free(General_Memory *general, void *memory){
Bubble *bubble = ((Bubble*)memory) - 1;
@ -280,11 +281,5 @@ general_memory_reallocate_nocopy(General_Memory *general, void *old, int32_t siz
return(result);
}
#define reset_temp_memory end_temp_memory
#define gen_struct(g, T) (T*)general_memory_allocate(g, sizeof(T), 0)
#define gen_array(g, T, size) (T*)general_memory_allocate(g, sizeof(T)*(size))
#define gen_block(g, size) general_memory_open(g, size, 0)
#endif

1
4cpp_lexer_types.h
View File

@ -123,7 +123,6 @@ ENUM(uint32_t, Cpp_Token_Type){
CPP_TOKEN_ARROW = 62,
// NOTE(allen): Precedence 3, RtoL
/* DOC(This token is for parser use, it is not output by the lexer.) */
CPP_TOKEN_PREINC = 63,
/* DOC(This token is for parser use, it is not output by the lexer.) */

29
4ed.cpp
View File

@ -273,7 +273,7 @@ panel_make_empty(System_Functions *system, App_Vars *vars, Panel *panel){
View_And_ID new_view;
Assert(panel->view == 0);
new_view = live_set_alloc_view(&vars->live_set, panel, models);
new_view = live_set_alloc_view(system, &vars->live_set, panel, models);
view_set_file(new_view.view, models->scratch_buffer, models);
new_view.view->map = get_map(models, mapid_file);
@ -493,9 +493,7 @@ COMMAND_DECL(toggle_tokens){
}
internal void
case_change_range(System_Functions *system,
Mem_Options *mem, View *view, Editing_File *file,
u8 a, u8 z, u8 char_delta){
case_change_range(System_Functions *system, Mem_Options *mem, View *view, Editing_File *file, u8 a, u8 z, u8 char_delta){
#if BUFFER_EXPERIMENT_SCALPEL <= 0
Range range = make_range(view->edit_pos->cursor.pos, view->edit_pos->mark);
if (range.start < range.end){
@ -505,10 +503,11 @@ case_change_range(System_Functions *system,
step.edit.end = range.end;
step.edit.len = range.end - range.start;
if (file->state.still_lexing)
if (file->state.still_lexing){
system->cancel_job(BACKGROUND_THREADS, file->state.lex_job);
}
file_update_history_before_edit(mem, file, step, 0, hist_normal);
file_update_history_before_edit(system, mem, file, step, 0, hist_normal);
u8 *data = (u8*)file->state.buffer.data;
for (i32 i = range.start; i < range.end; ++i){
@ -1304,14 +1303,14 @@ app_vars_zero(){
}
internal App_Vars*
app_setup_memory(Application_Memory *memory){
app_setup_memory(System_Functions *system, Application_Memory *memory){
Partition _partition = make_part(memory->vars_memory, memory->vars_memory_size);
App_Vars *vars = push_struct(&_partition, App_Vars);
Assert(vars);
*vars = app_vars_zero();
vars->models.mem.part = _partition;
general_memory_open(&vars->models.mem.general, memory->target_memory, memory->target_memory_size);
general_memory_open(system, &vars->models.mem.general, memory->target_memory, memory->target_memory_size);
return(vars);
}
@ -1324,7 +1323,7 @@ app_settings_zero(){
App_Read_Command_Line_Sig(app_read_command_line){
i32 out_size = 0;
App_Vars *vars = app_setup_memory(memory);
App_Vars *vars = app_setup_memory(system, memory);
App_Settings *settings = &vars->models.settings;
*settings = app_settings_zero();
@ -1658,7 +1657,7 @@ App_Init_Sig(app_init){
}
// NOTE(allen): file setup
working_set_init(&models->working_set, partition, &vars->models.mem.general);
working_set_init(system, &models->working_set, partition, &vars->models.mem.general);
models->working_set.default_display_width = DEFAULT_DISPLAY_WIDTH;
// NOTE(allen): clipboard setup
@ -1669,7 +1668,7 @@ App_Init_Sig(app_init){
// TODO(allen): more robust allocation solution for the clipboard
if (clipboard.str){
String *dest = working_set_next_clipboard_string(&models->mem.general, &models->working_set, clipboard.size);
String *dest = working_set_next_clipboard_string(system, &models->mem.general, &models->working_set, clipboard.size);
copy_ss(dest, make_string((char*)clipboard.str, clipboard.size));
}
@ -1706,8 +1705,8 @@ App_Init_Sig(app_init){
};
for (i32 i = 0; i < ArrayCount(init_files); ++i){
Editing_File *file = working_set_alloc_always(&models->working_set, general);
buffer_bind_name(general, &models->working_set, file, init_files[i].name);
Editing_File *file = working_set_alloc_always(system, &models->working_set, general);
buffer_bind_name(system, general, &models->working_set, file, init_files[i].name);
switch (init_files[i].type){
case 0: init_normal_file(system, models, file, 0, 0); break;
@ -1804,9 +1803,7 @@ App_Step_Sig(app_step){
if (clipboard.str){
String *dest =
working_set_next_clipboard_string(&models->mem.general,
&models->working_set,
clipboard.size);
working_set_next_clipboard_string(system, &models->mem.general, &models->working_set, clipboard.size);
dest->size = eol_convert_in(dest->str, clipboard.str, clipboard.size);
}

45
4ed_api_implementation.cpp
View File

@ -251,7 +251,7 @@ DOC_SEE(Command_Line_Input_Flag)
}
}
else if (buffer.name){
file = working_set_alloc_always(working_set, general);
file = working_set_alloc_always(system, working_set, general);
if (file == 0){
append_ss(&feedback_str,
make_lit_string("ERROR: unable to allocate a new buffer\n"));
@ -261,7 +261,7 @@ DOC_SEE(Command_Line_Input_Flag)
}
String name = make_string_terminated(part, buffer.name, buffer.name_len);
buffer_bind_name(general, working_set, file, name);
buffer_bind_name(system, general, working_set, file, name);
init_read_only_file(system, models, file);
}
@ -372,7 +372,7 @@ DOC_SEE(The_4coder_Clipboard)
General_Memory *general = &models->mem.general;
Working_Set *working = &models->working_set;
String *dest = working_set_next_clipboard_string(general, working, len);
String *dest = working_set_next_clipboard_string(system, general, working, len);
copy_ss(dest, make_string(str, len));
system->post_clipboard(*dest);
}
@ -681,6 +681,7 @@ DOC_SEE(Buffer_Batch_Edit_Type)
Mem_Options *mem = &models->mem;
Partition *part = &mem->part;
Editing_File *file = imp_get_file(cmd, buffer);
System_Functions *system = cmd->system;
bool32 result = false;
@ -694,12 +695,9 @@ DOC_SEE(Buffer_Batch_Edit_Type)
int32_t inv_str_max = part->max - part->pos;
Edit_Spec spec =
file_compute_edit(mem, file,
edits, str, str_len,
inverse_edits, inv_str, inv_str_max,
edit_count, type);
file_compute_edit(system, mem, file, edits, str, str_len, inverse_edits, inv_str, inv_str_max, edit_count, type);
file_do_batch_edit(cmd->system, models, file, spec, hist_normal, type);
file_do_batch_edit(system, models, file, spec, hist_normal, type);
end_temp_memory(temp);
}
@ -780,8 +778,7 @@ DOC_SEE(Buffer_Setting_ID)
if (new_value != file->settings.display_width){
i16 font_id = file->settings.font_id;
Render_Font *font = get_font_info(models->font_set, font_id)->font;
file_set_display_width_and_fix_cursor(models, file, new_value,
(f32)font->height, font->advance_data);
file_set_display_width_and_fix_cursor(system, models, file, new_value, (f32)font->height, font->advance_data);
}
}break;
@ -855,9 +852,9 @@ DOC_SEE(Buffer_Setting_ID)
i16 font_id = file->settings.font_id;
Render_Font *font = get_font_info(models->font_set, font_id)->font;
file_allocate_character_starts_as_needed(&models->mem.general, file);
file_allocate_character_starts_as_needed(system, &models->mem.general, file);
buffer_measure_character_starts(&file->state.buffer, file->state.character_starts, 0, file->settings.virtual_white);
file_measure_wraps(models, file, (f32)font->height, font->advance_data);
file_measure_wraps(system, models, file, (f32)font->height, font->advance_data);
file_update_cursor_positions(models, file);
}
}break;
@ -1008,31 +1005,31 @@ End_Buffer_Creation(Application_Links *app, Buffer_Creation_Data *data){
char *buffer = push_array(part, char, size);
if (buffer == 0){
buffer = (char*)general_memory_allocate(general, size);
buffer = (char*)general_memory_allocate(system, general, size);
Assert(buffer != 0);
in_general_mem = 1;
}
if (system->load_file(handle, buffer, size)){
file = working_set_alloc_always(working_set, general);
file = working_set_alloc_always(system, working_set, general);
if (file){
buffer_bind_file(system, general, working_set, file, canon.name);
buffer_bind_name(general, working_set, file, fname);
buffer_bind_name(system, general, working_set, file, fname);
init_normal_file(system, models, file, buffer, size);
fill_buffer_summary(&result, file, cmd);
}
}
if (in_general_mem){
general_memory_free(general, buffer);
general_memory_free(system, general, buffer);
}
system->load_close(handle);
}
else if (!(flags & BufferCreate_NeverNew)){
file = working_set_alloc_always(working_set, general);
file = working_set_alloc_always(system, working_set, general);
if (file){
buffer_bind_name(general, working_set, file, fname);
buffer_bind_name(system, general, working_set, file, fname);
init_normal_file(system, models, file, 0, 0);
fill_buffer_summary(&result, file, cmd);
}
@ -1116,31 +1113,31 @@ DOC_SEE(Buffer_Create_Flag)
char *buffer = push_array(part, char, size);
if (buffer == 0){
buffer = (char*)general_memory_allocate(general, size);
buffer = (char*)general_memory_allocate(system, general, size);
Assert(buffer != 0);
in_general_mem = 1;
}
if (system->load_file(handle, buffer, size)){
file = working_set_alloc_always(working_set, general);
file = working_set_alloc_always(system, working_set, general);
if (file){
buffer_bind_file(system, general, working_set, file, canon.name);
buffer_bind_name(general, working_set, file, fname);
buffer_bind_name(system, general, working_set, file, fname);
init_normal_file(system, models, file, buffer, size);
fill_buffer_summary(&result, file, cmd);
}
}
if (in_general_mem){
general_memory_free(general, buffer);
general_memory_free(system, general, buffer);
}
system->load_close(handle);
}
else if (!(flags & BufferCreate_NeverNew)){
file = working_set_alloc_always(working_set, general);
file = working_set_alloc_always(system, working_set, general);
if (file){
buffer_bind_name(general, working_set, file, fname);
buffer_bind_name(system, general, working_set, file, fname);
init_normal_file(system, models, file, 0, 0);
fill_buffer_summary(&result, file, cmd);
}

1
4ed_app_target.cpp
View File

@ -25,6 +25,7 @@
#include "4ed_rendering.h"
#include "4ed.h"
#include "4ed_mem.h"
#define FCPP_FORBID_MALLOC
#include "4cpp_lexer.h"

39
4ed_file.cpp
View File

@ -459,7 +459,7 @@ working_set_alloc(Working_Set *working_set){
}
internal Editing_File*
working_set_alloc_always(Working_Set *working_set, General_Memory *general){
working_set_alloc_always(System_Functions *system, Working_Set *working_set, General_Memory *general){
Editing_File *result = 0;
Editing_File *new_chunk;
i32 full_new_count = working_set->file_max;
@ -468,9 +468,8 @@ working_set_alloc_always(Working_Set *working_set, General_Memory *general){
if (full_new_count > max_i16) new_count = max_i16;
else new_count = (i16)full_new_count;
if (working_set->file_count == working_set->file_max &&
working_set->array_count < working_set->array_max){
new_chunk = gen_array(general, Editing_File, new_count);
if (working_set->file_count == working_set->file_max &&working_set->array_count < working_set->array_max){
new_chunk = gen_array(system, general, Editing_File, new_count);
working_set_extend_memory(working_set, new_chunk, new_count);
}
result = working_set_alloc(working_set);
@ -529,7 +528,7 @@ working_set_get_active_file(Working_Set *working_set, i32 id){
}
internal void
working_set_init(Working_Set *working_set, Partition *partition, General_Memory *general){
working_set_init(System_Functions *system, Working_Set *working_set, Partition *partition, General_Memory *general){
i16 init_count = 16;
i16 array_init_count = 256;
@ -555,7 +554,7 @@ working_set_init(Working_Set *working_set, Partition *partition, General_Memory
i32 item_size = sizeof(File_Name_Entry);
i32 table_size = working_set->file_max;
i32 mem_size = table_required_mem_size(table_size, item_size);
void *mem = general_memory_allocate(general, mem_size);
void *mem = general_memory_allocate(system, general, mem_size);
memset(mem, 0, mem_size);
table_init_memory(&working_set->canon_table, mem, table_size, item_size);
}
@ -565,23 +564,23 @@ working_set_init(Working_Set *working_set, Partition *partition, General_Memory
i32 item_size = sizeof(File_Name_Entry);
i32 table_size = working_set->file_max;
i32 mem_size = table_required_mem_size(table_size, item_size);
void *mem = general_memory_allocate(general, mem_size);
void *mem = general_memory_allocate(system, general, mem_size);
memset(mem, 0, mem_size);
table_init_memory(&working_set->name_table, mem, table_size, item_size);
}
}
inline void
working_set__grow_if_needed(Table *table, General_Memory *general, void *arg, Hash_Function *hash_func, Compare_Function *comp_func){
working_set__grow_if_needed(System_Functions *system, Table *table, General_Memory *general, void *arg, Hash_Function *hash_func, Compare_Function *comp_func){
if (table_at_capacity(table)){
Table btable = {0};
i32 new_max = table->max * 2;
i32 mem_size = table_required_mem_size(new_max, table->item_size);
void *mem = general_memory_allocate(general, mem_size);
void *mem = general_memory_allocate(system, general, mem_size);
table_init_memory(&btable, mem, new_max, table->item_size);
table_clear(&btable);
table_rehash(table, &btable, 0, hash_func, comp_func);
general_memory_free(general, table->hash_array);
general_memory_free(system, general, table->hash_array);
*table = btable;
}
}
@ -600,10 +599,8 @@ working_set_contains_basic(Working_Set *working_set, Table *table, String name){
}
internal b32
working_set_add_basic(General_Memory *general, Working_Set *working_set, Table *table,
Editing_File *file, String name){
working_set__grow_if_needed(table, general,
0, tbl_string_hash, tbl_string_compare);
working_set_add_basic(System_Functions *system, General_Memory *general, Working_Set *working_set, Table *table, Editing_File *file, String name){
working_set__grow_if_needed(system, table, general, 0, tbl_string_hash, tbl_string_compare);
File_Name_Entry entry;
entry.name = name;
@ -625,9 +622,9 @@ working_set_canon_contains(Working_Set *working_set, String name){
}
internal b32
working_set_canon_add(General_Memory *general, Working_Set *working_set,
working_set_canon_add(System_Functions *system, General_Memory *general, Working_Set *working_set,
Editing_File *file, String name){
b32 result = working_set_add_basic(general, working_set, &working_set->canon_table, file, name);
b32 result = working_set_add_basic(system, general,working_set, &working_set->canon_table, file, name);
return(result);
}
@ -644,9 +641,9 @@ working_set_name_contains(Working_Set *working_set, String name){
}
internal b32
working_set_name_add(General_Memory *general, Working_Set *working_set,
working_set_name_add(System_Functions *system, General_Memory *general, Working_Set *working_set,
Editing_File *file, String name){
b32 result = working_set_add_basic(general, working_set, &working_set->name_table, file, name);
b32 result = working_set_add_basic(system, general, working_set, &working_set->name_table, file, name);
return(result);
}
@ -939,7 +936,7 @@ buffer_bind_file(System_Functions *system, General_Memory *general, Working_Set
copy_ss(&file->canon.name, canon_filename);
terminate_with_null(&file->canon.name);
system->add_listener(file->canon.name_);
b32 result = working_set_canon_add(general, working_set, file, file->canon.name);
b32 result = working_set_canon_add(system, general, working_set, file, file->canon.name);
Assert(result); AllowLocal(result);
}
@ -956,7 +953,7 @@ buffer_unbind_file(System_Functions *system, Working_Set *working_set, Editing_F
}
internal void
buffer_bind_name(General_Memory *general, Working_Set *working_set,
buffer_bind_name(System_Functions *system, General_Memory *general, Working_Set *working_set,
Editing_File *file, String filename){
Assert(file->name.live_name.size == 0 &&
file->name.source_path.size == 0 &&
@ -971,7 +968,7 @@ buffer_bind_name(General_Memory *general, Working_Set *working_set,
copy_ss(&file->name.source_path, new_name.source_path);
copy_ss(&file->name.extension, new_name.extension);
b32 result = working_set_name_add(general, working_set, file, file->name.live_name);
b32 result = working_set_name_add(system, general, working_set, file, file->name.live_name);
Assert(result); AllowLocal(result);
}

519
4ed_file_view.cpp
View File

File diff suppressed because it is too large Load Diff

107
4ed_mem.h Normal file
View File

@ -0,0 +1,107 @@
#ifndef FED_MEM_H
#define FED_MEM_H
#include "4coder_mem.h"
#define MEMORY_DEBUG
static void
general_memory_open(System_Functions *system, General_Memory *general, void *memory, int32_t size){
#if defined(MEMORY_DEBUG)
general_memory_open(general, memory, size);
#else
general_memory_open(general, memory, size);
#endif
}
#if defined(Assert) && !defined(MEMORY_DEBUG)
static int32_t
general_memory_check(System_Functions *system, General_Memory *general){
Bubble *sentinel = &general->sentinel;
for (Bubble *bubble = sentinel->next;
bubble != sentinel;
bubble = bubble->next){
Assert(bubble);
Bubble *next = bubble->next;
Assert(bubble == next->prev);
if (next != sentinel && bubble->prev != sentinel){
Assert(bubble->next > bubble);
Assert(bubble > bubble->prev);
char *end_ptr = (char*)(bubble + 1) + bubble->size;
char *next_ptr = (char*)next;
(void)(end_ptr);
(void)(next_ptr);
Assert(end_ptr == next_ptr);
}
}
return(1);
}
#else
static int32_t
general_memory_check(System_Functions *system, General_Memory *general){return(1);}
#endif
#define OS_PAGE_SIZE 4096
static void*
general_memory_allocate(System_Functions *system, General_Memory *general, int32_t size){
#if defined(MEMORY_DEBUG)
{
persist u32 round_val = OS_PAGE_SIZE-1;
size = (size + round_val) & (~round_val);
void *result = system->memory_allocate(0, size + OS_PAGE_SIZE);
system->memory_set_protection(0, (u8*)result + size, OS_PAGE_SIZE, 0);
return(result);
}
#else
return general_memory_allocate(general, memory, size);
#endif
}
static void
general_memory_free(System_Functions *system, General_Memory *general, void *memory){
#if defined(MEMORY_DEBUG)
{
system->memory_free(0, memory, 0);
}
#else
return general_memory_free(general, memory, size);
#endif
}
static void*
general_memory_reallocate(System_Functions *system, General_Memory *general, void *old, int32_t old_size, int32_t size){
#if defined(MEMORY_DEBUG)
{
void *result = general_memory_allocate(system, general, size);
memcpy(result, old, old_size);
general_memory_free(system, general, old);
return(result);
}
#else
return general_memory_reallocate(general, memory, size);
#endif
}
inline void*
general_memory_reallocate_nocopy(System_Functions *system, General_Memory *general, void *old, int32_t size){
#if defined(MEMORY_DEBUG)
{
general_memory_free(system, general, old);
return general_memory_allocate(system, general, size);
}
#else
return general_memory_reallocate_nocopy(general, memory, size);
#endif
}
#define reset_temp_memory end_temp_memory
#define gen_struct(s, g, T) (T*)general_memory_allocate(s, g, sizeof(T), 0)
#define gen_array(s, g, T, size) (T*)general_memory_allocate(s, g, sizeof(T)*(size))
#define gen_block(s, g, size) general_memory_open(s, g, size, 0)
#endif

4
TODO.txt
View File

@ -175,7 +175,7 @@
; [X] handle square brackets
; [X] smarter wrap rule
; [X] handle unclosed statements
; [+] wrapped line indication
; [X] wrapped line indication
; [] special indent rules in preprocessor body
; [] handle comments
; [] additional width for nesting?
@ -289,6 +289,8 @@
; [] 4edT thing
; [] console emulator
;
; [] 10 GB text file
;
; INTERNAL TODOS
; [X] switch building non-extensible version by statically linking to custom.cpp

4
buffer/4coder_buffer_abstract.cpp
View File

@ -126,6 +126,10 @@ buffer_measure_starts(Buffer_Measure_Starts *state, Buffer_Type *buffer){
state->count = (i32)(start_ptr - buffer->line_starts);
state->start = start;
if (!result){
buffer->line_count = state->count;
}
return(result);
}

18
win32_api_impl.cpp
View File

@ -12,7 +12,8 @@ as this is the only one that will be used for generating headers and docs.
#define API_EXPORT
API_EXPORT void*
Memory_Allocate(Application_Links *app, int32_t size)/*
Memory_Allocate(Application_Links *app, int32_t size)
/*
DOC_PARAM(size, The size in bytes of the block that should be returned.)
DOC(This calls to a low level OS allocator which means it is best used
for infrequent, large allocations. The size of the block must be remembered
@ -24,7 +25,8 @@ DOC_SEE(memory_free)
}
API_EXPORT bool32
Memory_Set_Protection(Application_Links *app, void *ptr, int32_t size, Memory_Protect_Flags flags)/*
Memory_Set_Protection(Application_Links *app, void *ptr, int32_t size, Memory_Protect_Flags flags)
/*
DOC_PARAM(ptr, The base of the block on which to set memory protection flags.)
DOC_PARAM(size, The size that was originally used to allocate this block.)
DOC_PARAM(flags, The new memory protection flags.)
@ -40,21 +42,17 @@ DOC_SEE(Memory_Protect_Flags)
flags = flags & 0x7;
switch (flags){
case 0:
protect = PAGE_NOACCESS; break;
case 0: protect = PAGE_NOACCESS; break;
case MemProtect_Read:
protect = PAGE_READONLY; break;
case MemProtect_Read: protect = PAGE_READONLY; break;
case MemProtect_Write:
case MemProtect_Read|MemProtect_Write:
protect = PAGE_READWRITE; break;
case MemProtect_Execute:
protect = PAGE_EXECUTE; break;
case MemProtect_Execute: protect = PAGE_EXECUTE; break;
case MemProtect_Execute|MemProtect_Read:
protect = PAGE_EXECUTE_READ; break;
case MemProtect_Execute|MemProtect_Read: protect = PAGE_EXECUTE_READ; break;
case MemProtect_Execute|MemProtect_Write:
case MemProtect_Execute|MemProtect_Write|MemProtect_Read: