fixed bug with the parallel lexing routine not using the gap buffer
This commit is contained in:
Allen Webster
parent
6d2589d149
commit
1a987c6781
|
|
@ -1151,7 +1151,8 @@ cpp_get_relex_range(Cpp_Token_Array *array, int32_t start_pos, int32_t end_pos){
|
|||
}
|
||||
|
||||
FCPP_LINK Cpp_Relex_Data
|
||||
cpp_relex_init(Cpp_Token_Array *array, int32_t start_pos, int32_t end_pos, int32_t character_shift_amount, char *spare){
|
||||
cpp_relex_init(Cpp_Token_Array *array, int32_t start_pos, int32_t end_pos, int32_t character_shift_amount, char *spare)
|
||||
{
|
||||
Cpp_Relex_Data state = {0};
|
||||
|
||||
Cpp_Relex_Range range = cpp_get_relex_range(array, start_pos, end_pos);
|
||||
|
|
|
|||
|
|
@ -1122,8 +1122,8 @@ Job_Callback_Sig(job_full_lex){
|
|||
Editing_File *file = (Editing_File*)data[0];
|
||||
General_Memory *general = (General_Memory*)data[1];
|
||||
|
||||
char *text_data = file->state.buffer.data;
|
||||
i32 text_size = buffer_size(&file->state.buffer);
|
||||
Buffer_Type *buffer = &file->state.buffer;
|
||||
i32 text_size = buffer_size(buffer);
|
||||
|
||||
i32 buffer_size = (text_size + 3)&(~3);
|
||||
|
||||
|
|
@ -1142,12 +1142,32 @@ Job_Callback_Sig(job_full_lex){
|
|||
|
||||
Cpp_Lex_Data lex = cpp_lex_data_init(tb);
|
||||
|
||||
// TODO(allen): deduplicate this against relex
|
||||
char *chunks[3];
|
||||
i32 chunk_sizes[3];
|
||||
|
||||
chunks[0] = buffer->data;
|
||||
chunk_sizes[0] = buffer->size1;
|
||||
|
||||
chunks[1] = buffer->data + buffer->size1 + buffer->gap_size;
|
||||
chunk_sizes[1] = buffer->size2;
|
||||
|
||||
chunks[2] = 0;
|
||||
chunk_sizes[2] = 0;
|
||||
|
||||
i32 chunk_index = 0;
|
||||
|
||||
do{
|
||||
char *chunk = chunks[chunk_index];
|
||||
i32 chunk_size = chunk_sizes[chunk_index];
|
||||
|
||||
i32 result =
|
||||
cpp_lex_step(&lex, text_data, text_size, text_size, &tokens, 2048);
|
||||
cpp_lex_step(&lex, chunk, chunk_size, text_size, &tokens, 2048);
|
||||
|
||||
switch (result){
|
||||
case LexResult_NeedChunk: Assert(!"Invalid Path"); break;
|
||||
case LexResult_NeedChunk:
|
||||
++chunk_index;
|
||||
break;
|
||||
|
||||
case LexResult_NeedTokenMemory:
|
||||
if (system->check_cancel(thread)){
|
||||
|
|
@ -1290,10 +1310,10 @@ file_relex_parallel(System_Functions *system,
|
|||
chunks[2] = 0;
|
||||
chunk_sizes[2] = 0;
|
||||
|
||||
int32_t chunk_index = 0;
|
||||
i32 chunk_index = 0;
|
||||
|
||||
char *chunk = chunks[chunk_index];
|
||||
int32_t chunk_size = chunk_sizes[chunk_index];
|
||||
i32 chunk_size = chunk_sizes[chunk_index];
|
||||
|
||||
while (!cpp_relex_is_start_chunk(&state, chunk, chunk_size)){
|
||||
++chunk_index;
|
||||
|
|
|
|||
6
TODO.txt
6
TODO.txt
|
|
@ -152,9 +152,9 @@
|
|||
; [] option to not open *messages* every startup
|
||||
;
|
||||
; [] query buffer font info
|
||||
; [] break buffer name ties by adding parent directories instead of <#>
|
||||
; [] option to break buffer name ties by adding parent directories instead of <#>
|
||||
; [] undo groups
|
||||
; [] cursor/scroll grouping
|
||||
; [] cursor/scroll groups
|
||||
; [] allow for arbitrary wrap positions independent of view width
|
||||
; [] word level wrapping ~ temporary measure really want to have totally formatted code presentation
|
||||
; [] double binding warnings
|
||||
|
|
@ -171,8 +171,8 @@
|
|||
|
||||
; buffer behavior cleanup
|
||||
; [X] show all characters as \# if they can't be rendered
|
||||
; [] binary buffer mode
|
||||
; [] get the navigation working correctly around multi-glyph characters
|
||||
; [] binary buffer mode
|
||||
; [] support full length unicode file names
|
||||
|
||||
; meta programming system
|
||||
|
|
|
|||
|
|
@ -1,11 +1,11 @@
|
|||
/*
|
||||
/*
|
||||
* Mr. 4th Dimention - Allen Webster
|
||||
* Four Tech
|
||||
*
|
||||
* public domain -- no warranty is offered or implied; use this code at your own risk
|
||||
*
|
||||
* 24.10.2015
|
||||
*
|
||||
*
|
||||
* Buffer features based on the stringify loop,
|
||||
* and other abstract buffer features.
|
||||
*
|
||||
*/
|
||||
|
||||
// TOP
|
||||
|
|
@ -15,7 +15,7 @@
|
|||
#define Buffer_Backify_Type cat_4tech(Buffer_Type, _Backify_Loop)
|
||||
|
||||
inline_4tech void
|
||||
buffer_stringify(Buffer_Type *buffer, int start, int end, char *out){
|
||||
buffer_stringify(Buffer_Type *buffer, i32 start, i32 end, char *out){
|
||||
for (Buffer_Stringify_Type loop = buffer_stringify_loop(buffer, start, end);
|
||||
buffer_stringify_good(&loop);
|
||||
buffer_stringify_next(&loop)){
|
||||
|
|
@ -24,10 +24,10 @@ buffer_stringify(Buffer_Type *buffer, int start, int end, char *out){
|
|||
}
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
buffer_convert_out(Buffer_Type *buffer, char *dest, int max){
|
||||
internal_4tech i32
|
||||
buffer_convert_out(Buffer_Type *buffer, char *dest, i32 max){
|
||||
Buffer_Stringify_Type loop;
|
||||
int size, out_size, pos, result;
|
||||
i32 size, out_size, pos, result;
|
||||
|
||||
size = buffer_size(buffer);
|
||||
assert_4tech(size + buffer->line_count < max);
|
||||
|
|
@ -44,11 +44,11 @@ buffer_convert_out(Buffer_Type *buffer, char *dest, int max){
|
|||
return(pos);
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
buffer_count_newlines(Buffer_Type *buffer, int start, int end){
|
||||
internal_4tech i32
|
||||
buffer_count_newlines(Buffer_Type *buffer, i32 start, i32 end){
|
||||
Buffer_Stringify_Type loop;
|
||||
int i;
|
||||
int count;
|
||||
i32 i;
|
||||
i32 count;
|
||||
|
||||
assert_4tech(0 <= start);
|
||||
assert_4tech(start <= end);
|
||||
|
|
@ -69,25 +69,25 @@ buffer_count_newlines(Buffer_Type *buffer, int start, int end){
|
|||
|
||||
#ifndef NON_ABSTRACT_4TECH
|
||||
typedef struct Buffer_Measure_Starts{
|
||||
int i;
|
||||
int count;
|
||||
int start;
|
||||
float width;
|
||||
i32 i;
|
||||
i32 count;
|
||||
i32 start;
|
||||
f32 width;
|
||||
} Buffer_Measure_Starts;
|
||||
#endif
|
||||
|
||||
internal_4tech int
|
||||
buffer_measure_starts_widths_(Buffer_Measure_Starts *state, Buffer_Type *buffer, float *advance_data){
|
||||
internal_4tech i32
|
||||
buffer_measure_starts_widths_(Buffer_Measure_Starts *state, Buffer_Type *buffer, f32 *advance_data){
|
||||
Buffer_Stringify_Type loop;
|
||||
int *start_ptr, *start_end;
|
||||
float *width_ptr;
|
||||
debug_4tech(int widths_max);
|
||||
debug_4tech(int max);
|
||||
i32 *start_ptr, *start_end;
|
||||
f32 *width_ptr;
|
||||
debug_4tech(i32 widths_max);
|
||||
debug_4tech(i32 max);
|
||||
char *data;
|
||||
int size, end;
|
||||
float width;
|
||||
int start, i;
|
||||
int result;
|
||||
i32 size, end;
|
||||
f32 width;
|
||||
i32 start, i;
|
||||
i32 result;
|
||||
char ch;
|
||||
|
||||
size = buffer_size(buffer);
|
||||
|
|
@ -136,24 +136,24 @@ buffer_measure_starts_widths_(Buffer_Measure_Starts *state, Buffer_Type *buffer,
|
|||
|
||||
buffer_measure_starts_widths_end:
|
||||
state->i = i;
|
||||
state->count = (int)(start_ptr - buffer->line_starts);
|
||||
state->count = (i32)(start_ptr - buffer->line_starts);
|
||||
state->start = start;
|
||||
state->width = width;
|
||||
|
||||
return(result);
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
internal_4tech i32
|
||||
buffer_measure_starts_zero_widths_(Buffer_Measure_Starts *state, Buffer_Type *buffer){
|
||||
Buffer_Stringify_Type loop;
|
||||
int *start_ptr, *start_end;
|
||||
float *width_ptr;
|
||||
debug_4tech(int widths_max);
|
||||
debug_4tech(int max);
|
||||
i32 *start_ptr, *start_end;
|
||||
f32 *width_ptr;
|
||||
debug_4tech(i32 widths_max);
|
||||
debug_4tech(i32 max);
|
||||
char *data;
|
||||
int size, end;
|
||||
int start, i;
|
||||
int result;
|
||||
i32 size, end;
|
||||
i32 start, i;
|
||||
i32 result;
|
||||
char ch;
|
||||
|
||||
size = buffer_size(buffer);
|
||||
|
|
@ -197,15 +197,15 @@ buffer_measure_starts_zero_widths_(Buffer_Measure_Starts *state, Buffer_Type *bu
|
|||
|
||||
buffer_measure_starts_zero_widths_end:
|
||||
state->i = i;
|
||||
state->count = (int)(start_ptr - buffer->line_starts);
|
||||
state->count = (i32)(start_ptr - buffer->line_starts);
|
||||
state->start = start;
|
||||
|
||||
return(result);
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
buffer_measure_starts_widths(Buffer_Measure_Starts *state, Buffer_Type *buffer, float *advance_data){
|
||||
int result = 0;
|
||||
internal_4tech i32
|
||||
buffer_measure_starts_widths(Buffer_Measure_Starts *state, Buffer_Type *buffer, f32 *advance_data){
|
||||
i32 result = 0;
|
||||
|
||||
if (advance_data){
|
||||
result = buffer_measure_starts_widths_(state, buffer, advance_data);
|
||||
|
|
@ -218,13 +218,13 @@ buffer_measure_starts_widths(Buffer_Measure_Starts *state, Buffer_Type *buffer,
|
|||
}
|
||||
|
||||
internal_4tech void
|
||||
buffer_remeasure_starts(Buffer_Type *buffer, int line_start, int line_end, int line_shift, int text_shift){
|
||||
buffer_remeasure_starts(Buffer_Type *buffer, i32 line_start, i32 line_end, i32 line_shift, i32 text_shift){
|
||||
Buffer_Stringify_Type loop;
|
||||
int *starts = buffer->line_starts;
|
||||
int line_count = buffer->line_count;
|
||||
i32 *starts = buffer->line_starts;
|
||||
i32 line_count = buffer->line_count;
|
||||
char *data = 0;
|
||||
int size = 0, end = 0;
|
||||
int line_i = 0, char_i = 0, start = 0;
|
||||
i32 size = 0, end = 0;
|
||||
i32 line_i = 0, char_i = 0, start = 0;
|
||||
|
||||
assert_4tech(0 <= line_start);
|
||||
assert_4tech(line_start <= line_end);
|
||||
|
|
@ -243,7 +243,7 @@ buffer_remeasure_starts(Buffer_Type *buffer, int line_start, int line_end, int l
|
|||
|
||||
if (line_shift != 0){
|
||||
memmove_4tech(starts + line_end + line_shift, starts + line_end,
|
||||
sizeof(int)*(line_count - line_end));
|
||||
sizeof(i32)*(line_count - line_end));
|
||||
line_count += line_shift;
|
||||
}
|
||||
|
||||
|
|
@ -277,17 +277,17 @@ buffer_remeasure_starts(Buffer_Type *buffer, int line_start, int line_end, int l
|
|||
}
|
||||
|
||||
internal_4tech void
|
||||
buffer_remeasure_widths(Buffer_Type *buffer, float *advance_data,
|
||||
int line_start, int line_end, int line_shift){
|
||||
buffer_remeasure_widths(Buffer_Type *buffer, f32 *advance_data,
|
||||
i32 line_start, i32 line_end, i32 line_shift){
|
||||
Buffer_Stringify_Type loop;
|
||||
int *starts = buffer->line_starts;
|
||||
float *widths = buffer->line_widths;
|
||||
int line_count = buffer->line_count;
|
||||
int widths_count = buffer->widths_count;
|
||||
i32 *starts = buffer->line_starts;
|
||||
f32 *widths = buffer->line_widths;
|
||||
i32 line_count = buffer->line_count;
|
||||
i32 widths_count = buffer->widths_count;
|
||||
char *data = 0;
|
||||
int size = 0, end = 0;
|
||||
int i = 0, j = 0;
|
||||
float width = 0;
|
||||
i32 size = 0, end = 0;
|
||||
i32 i = 0, j = 0;
|
||||
f32 width = 0;
|
||||
char ch = 0;
|
||||
|
||||
assert_4tech(0 <= line_start);
|
||||
|
|
@ -297,7 +297,7 @@ buffer_remeasure_widths(Buffer_Type *buffer, float *advance_data,
|
|||
++line_end;
|
||||
if (line_shift != 0){
|
||||
memmove_4tech(widths + line_end + line_shift, widths + line_end,
|
||||
sizeof(float)*(widths_count - line_end));
|
||||
sizeof(f32)*(widths_count - line_end));
|
||||
}
|
||||
buffer->widths_count = line_count;
|
||||
|
||||
|
|
@ -345,11 +345,11 @@ buffer_measure_widths(Buffer_Type *buffer, void *advance_data){
|
|||
#endif
|
||||
|
||||
internal_4tech void
|
||||
buffer_measure_wrap_y(Buffer_Type *buffer, float *wraps,
|
||||
float font_height, float max_width){
|
||||
float *widths;
|
||||
float y_pos;
|
||||
int i, line_count;
|
||||
buffer_measure_wrap_y(Buffer_Type *buffer, f32 *wraps,
|
||||
f32 font_height, f32 max_width){
|
||||
f32 *widths;
|
||||
f32 y_pos;
|
||||
i32 i, line_count;
|
||||
|
||||
line_count = buffer->line_count;
|
||||
widths = buffer->line_widths;
|
||||
|
|
@ -362,11 +362,11 @@ buffer_measure_wrap_y(Buffer_Type *buffer, float *wraps,
|
|||
}
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
buffer_get_line_index_range(Buffer_Type *buffer, int pos, int l_bound, int u_bound){
|
||||
int *lines;
|
||||
int start, end;
|
||||
int i;
|
||||
internal_4tech i32
|
||||
buffer_get_line_index_range(Buffer_Type *buffer, i32 pos, i32 l_bound, i32 u_bound){
|
||||
i32 *lines;
|
||||
i32 start, end;
|
||||
i32 i;
|
||||
|
||||
assert_4tech(0 <= l_bound);
|
||||
assert_4tech(l_bound <= u_bound);
|
||||
|
|
@ -393,16 +393,16 @@ buffer_get_line_index_range(Buffer_Type *buffer, int pos, int l_bound, int u_bou
|
|||
return(start);
|
||||
}
|
||||
|
||||
inline_4tech int
|
||||
buffer_get_line_index(Buffer_Type *buffer, int pos){
|
||||
int result = buffer_get_line_index_range(buffer, pos, 0, buffer->line_count);
|
||||
inline_4tech i32
|
||||
buffer_get_line_index(Buffer_Type *buffer, i32 pos){
|
||||
i32 result = buffer_get_line_index_range(buffer, pos, 0, buffer->line_count);
|
||||
return(result);
|
||||
}
|
||||
|
||||
#ifndef NON_ABSTRACT_4TECH
|
||||
internal_4tech int
|
||||
buffer_get_line_index_from_wrapped_y(float *wraps, float y, float font_height, int l_bound, int u_bound){
|
||||
int start, end, i, result;
|
||||
internal_4tech i32
|
||||
buffer_get_line_index_from_wrapped_y(f32 *wraps, f32 y, f32 font_height, i32 l_bound, i32 u_bound){
|
||||
i32 start, end, i, result;
|
||||
start = l_bound;
|
||||
end = u_bound;
|
||||
for (;;){
|
||||
|
|
@ -428,13 +428,13 @@ typedef struct Seek_State{
|
|||
Full_Cursor prev_cursor;
|
||||
} Seek_State;
|
||||
|
||||
internal_4tech int
|
||||
cursor_seek_step(Seek_State *state, Buffer_Seek seek, int xy_seek, float max_width,
|
||||
float font_height, float *advances, int size, char ch){
|
||||
internal_4tech i32
|
||||
cursor_seek_step(Seek_State *state, Buffer_Seek seek, i32 xy_seek, f32 max_width,
|
||||
f32 font_height, f32 *advances, i32 size, char ch){
|
||||
Full_Cursor cursor, prev_cursor;
|
||||
float ch_width;
|
||||
int result;
|
||||
float x, px, y;
|
||||
f32 ch_width;
|
||||
i32 result;
|
||||
f32 x, px, y;
|
||||
|
||||
cursor = state->cursor;
|
||||
prev_cursor = state->prev_cursor;
|
||||
|
|
@ -453,8 +453,8 @@ cursor_seek_step(Seek_State *state, Buffer_Seek seek, int xy_seek, float max_wid
|
|||
|
||||
default:
|
||||
++cursor.character;
|
||||
if (ch == '\r') ch_width = *(float*)(advances + '\\') + *(float*)(advances + 'r');
|
||||
else ch_width = *(float*)(advances + ch);
|
||||
if (ch == '\r') ch_width = *(f32*)(advances + '\\') + *(f32*)(advances + 'r');
|
||||
else ch_width = *(f32*)(advances + ch);
|
||||
|
||||
if (cursor.wrapped_x + ch_width >= max_width){
|
||||
cursor.wrapped_y += font_height;
|
||||
|
|
@ -536,16 +536,16 @@ cursor_seek_step(Seek_State *state, Buffer_Seek seek, int xy_seek, float max_wid
|
|||
#endif
|
||||
|
||||
internal_4tech Full_Cursor
|
||||
buffer_cursor_seek(Buffer_Type *buffer, Buffer_Seek seek, float max_width,
|
||||
float font_height, float *advance_data, Full_Cursor cursor){
|
||||
buffer_cursor_seek(Buffer_Type *buffer, Buffer_Seek seek, f32 max_width,
|
||||
f32 font_height, f32 *advance_data, Full_Cursor cursor){
|
||||
Buffer_Stringify_Type loop;
|
||||
char *data;
|
||||
int size, end;
|
||||
int i;
|
||||
int result;
|
||||
i32 size, end;
|
||||
i32 i;
|
||||
i32 result;
|
||||
|
||||
Seek_State state;
|
||||
int xy_seek;
|
||||
i32 xy_seek;
|
||||
|
||||
state.cursor = cursor;
|
||||
|
||||
|
|
@ -596,7 +596,7 @@ buffer_cursor_seek(Buffer_Type *buffer, Buffer_Seek seek, float max_width,
|
|||
}
|
||||
|
||||
internal_4tech Partial_Cursor
|
||||
buffer_partial_from_pos(Buffer_Type *buffer, int pos){
|
||||
buffer_partial_from_pos(Buffer_Type *buffer, i32 pos){
|
||||
Partial_Cursor result = {0};
|
||||
|
||||
int32_t size = buffer_size(buffer);
|
||||
|
|
@ -607,7 +607,7 @@ buffer_partial_from_pos(Buffer_Type *buffer, int pos){
|
|||
pos = 0;
|
||||
}
|
||||
|
||||
int line_index = buffer_get_line_index_range(buffer, pos, 0, buffer->line_count);
|
||||
i32 line_index = buffer_get_line_index_range(buffer, pos, 0, buffer->line_count);
|
||||
result.pos = pos;
|
||||
result.line = line_index+1;
|
||||
result.character = pos - buffer->line_starts[line_index] + 1;
|
||||
|
|
@ -616,10 +616,10 @@ buffer_partial_from_pos(Buffer_Type *buffer, int pos){
|
|||
}
|
||||
|
||||
internal_4tech Full_Cursor
|
||||
buffer_cursor_from_pos(Buffer_Type *buffer, int pos, float *wraps,
|
||||
float max_width, float font_height, float *advance_data){
|
||||
buffer_cursor_from_pos(Buffer_Type *buffer, i32 pos, f32 *wraps,
|
||||
f32 max_width, f32 font_height, f32 *advance_data){
|
||||
Full_Cursor result;
|
||||
int line_index;
|
||||
i32 line_index;
|
||||
|
||||
int32_t size = buffer_size(buffer);
|
||||
if (pos > size){
|
||||
|
|
@ -638,18 +638,18 @@ buffer_cursor_from_pos(Buffer_Type *buffer, int pos, float *wraps,
|
|||
}
|
||||
|
||||
internal_4tech Partial_Cursor
|
||||
buffer_partial_from_line_character(Buffer_Type *buffer, int line, int character){
|
||||
buffer_partial_from_line_character(Buffer_Type *buffer, i32 line, i32 character){
|
||||
Partial_Cursor result = {0};
|
||||
|
||||
int line_index = line - 1;
|
||||
i32 line_index = line - 1;
|
||||
if (line_index >= buffer->line_count) line_index = buffer->line_count - 1;
|
||||
if (line_index < 0) line_index = 0;
|
||||
|
||||
int32_t size = buffer_size(buffer);
|
||||
int this_start = buffer->line_starts[line_index];
|
||||
int max_character = (size-this_start) + 1;
|
||||
i32 this_start = buffer->line_starts[line_index];
|
||||
i32 max_character = (size-this_start) + 1;
|
||||
if (line_index+1 < buffer->line_count){
|
||||
int next_start = buffer->line_starts[line_index+1];
|
||||
i32 next_start = buffer->line_starts[line_index+1];
|
||||
max_character = (next_start-this_start);
|
||||
}
|
||||
|
||||
|
|
@ -664,11 +664,11 @@ buffer_partial_from_line_character(Buffer_Type *buffer, int line, int character)
|
|||
}
|
||||
|
||||
internal_4tech Full_Cursor
|
||||
buffer_cursor_from_line_character(Buffer_Type *buffer, int line, int character, float *wraps,
|
||||
float max_width, float font_height, float *advance_data){
|
||||
buffer_cursor_from_line_character(Buffer_Type *buffer, i32 line, i32 character, f32 *wraps,
|
||||
f32 max_width, f32 font_height, f32 *advance_data){
|
||||
Full_Cursor result = {0};
|
||||
|
||||
int line_index = line - 1;
|
||||
i32 line_index = line - 1;
|
||||
if (line_index >= buffer->line_count) line_index = buffer->line_count - 1;
|
||||
if (line_index < 0) line_index = 0;
|
||||
|
||||
|
|
@ -680,12 +680,12 @@ buffer_cursor_from_line_character(Buffer_Type *buffer, int line, int character,
|
|||
}
|
||||
|
||||
internal_4tech Full_Cursor
|
||||
buffer_cursor_from_unwrapped_xy(Buffer_Type *buffer, float x, float y, int round_down, float *wraps,
|
||||
float max_width, float font_height, float *advance_data){
|
||||
buffer_cursor_from_unwrapped_xy(Buffer_Type *buffer, f32 x, f32 y, i32 round_down, f32 *wraps,
|
||||
f32 max_width, f32 font_height, f32 *advance_data){
|
||||
Full_Cursor result;
|
||||
int line_index;
|
||||
i32 line_index;
|
||||
|
||||
line_index = (int)(y / font_height);
|
||||
line_index = (i32)(y / font_height);
|
||||
if (line_index >= buffer->line_count) line_index = buffer->line_count - 1;
|
||||
if (line_index < 0) line_index = 0;
|
||||
|
||||
|
|
@ -697,10 +697,10 @@ buffer_cursor_from_unwrapped_xy(Buffer_Type *buffer, float x, float y, int round
|
|||
}
|
||||
|
||||
internal_4tech Full_Cursor
|
||||
buffer_cursor_from_wrapped_xy(Buffer_Type *buffer, float x, float y, int round_down, float *wraps,
|
||||
float max_width, float font_height, float *advance_data){
|
||||
buffer_cursor_from_wrapped_xy(Buffer_Type *buffer, f32 x, f32 y, i32 round_down, f32 *wraps,
|
||||
f32 max_width, f32 font_height, f32 *advance_data){
|
||||
Full_Cursor result;
|
||||
int line_index;
|
||||
i32 line_index;
|
||||
|
||||
line_index = buffer_get_line_index_from_wrapped_y(wraps, y, font_height, 0, buffer->line_count);
|
||||
result = make_cursor_hint(line_index, buffer->line_starts, wraps, font_height);
|
||||
|
|
@ -712,9 +712,9 @@ buffer_cursor_from_wrapped_xy(Buffer_Type *buffer, float x, float y, int round_d
|
|||
|
||||
internal_4tech void
|
||||
buffer_invert_edit_shift(Buffer_Type *buffer, Buffer_Edit edit, Buffer_Edit *inverse, char *strings,
|
||||
int *str_pos, int max, int shift_amount){
|
||||
int pos = *str_pos;
|
||||
int len = edit.end - edit.start;
|
||||
i32 *str_pos, i32 max, i32 shift_amount){
|
||||
i32 pos = *str_pos;
|
||||
i32 len = edit.end - edit.start;
|
||||
assert_4tech(pos >= 0);
|
||||
assert_4tech(pos + len <= max);
|
||||
*str_pos = pos + len;
|
||||
|
|
@ -728,25 +728,25 @@ buffer_invert_edit_shift(Buffer_Type *buffer, Buffer_Edit edit, Buffer_Edit *inv
|
|||
|
||||
inline_4tech void
|
||||
buffer_invert_edit(Buffer_Type *buffer, Buffer_Edit edit, Buffer_Edit *inverse, char *strings,
|
||||
int *str_pos, int max){
|
||||
i32 *str_pos, i32 max){
|
||||
buffer_invert_edit_shift(buffer, edit, inverse, strings, str_pos, max, 0);
|
||||
}
|
||||
|
||||
#ifndef NON_ABSTRACT_4TECH
|
||||
typedef struct Buffer_Invert_Batch{
|
||||
int i;
|
||||
int shift_amount;
|
||||
int len;
|
||||
i32 i;
|
||||
i32 shift_amount;
|
||||
i32 len;
|
||||
} Buffer_Invert_Batch;
|
||||
#endif
|
||||
|
||||
internal_4tech int
|
||||
buffer_invert_batch(Buffer_Invert_Batch *state, Buffer_Type *buffer, Buffer_Edit *edits, int count,
|
||||
Buffer_Edit *inverse, char *strings, int *str_pos, int max){
|
||||
internal_4tech i32
|
||||
buffer_invert_batch(Buffer_Invert_Batch *state, Buffer_Type *buffer, Buffer_Edit *edits, i32 count,
|
||||
Buffer_Edit *inverse, char *strings, i32 *str_pos, i32 max){
|
||||
Buffer_Edit *edit, *inv_edit;
|
||||
int shift_amount;
|
||||
int result;
|
||||
int i;
|
||||
i32 shift_amount;
|
||||
i32 result;
|
||||
i32 i;
|
||||
|
||||
result = 0;
|
||||
i = state->i;
|
||||
|
|
@ -777,8 +777,8 @@ struct Buffer_Render_Options{
|
|||
};
|
||||
|
||||
internal_4tech Full_Cursor
|
||||
buffer_get_start_cursor(Buffer_Type *buffer, float *wraps, float scroll_y,
|
||||
int wrapped, float width, float *advance_data, float font_height){
|
||||
buffer_get_start_cursor(Buffer_Type *buffer, f32 *wraps, f32 scroll_y,
|
||||
i32 wrapped, f32 width, f32 *advance_data, f32 font_height){
|
||||
Full_Cursor result;
|
||||
|
||||
if (wrapped){
|
||||
|
|
@ -796,19 +796,19 @@ buffer_get_start_cursor(Buffer_Type *buffer, float *wraps, float scroll_y,
|
|||
#define BRFlag_Special_Character (1 << 0)
|
||||
|
||||
typedef struct Buffer_Render_Item{
|
||||
int index;
|
||||
i32 index;
|
||||
unsigned short glyphid;
|
||||
unsigned short flags;
|
||||
float x0, y0;
|
||||
float x1, y1;
|
||||
f32 x0, y0;
|
||||
f32 x1, y1;
|
||||
} Buffer_Render_Item;
|
||||
|
||||
inline_4tech void
|
||||
write_render_item(Buffer_Render_Item *item,
|
||||
int index,
|
||||
i32 index,
|
||||
unsigned short glyphid,
|
||||
float x, float y,
|
||||
float w, float h){
|
||||
f32 x, f32 y,
|
||||
f32 w, f32 h){
|
||||
item->index = index;
|
||||
item->glyphid = glyphid;
|
||||
item->x0 = x;
|
||||
|
|
@ -817,36 +817,36 @@ write_render_item(Buffer_Render_Item *item,
|
|||
item->y1 = y + h;
|
||||
}
|
||||
|
||||
inline_4tech float
|
||||
inline_4tech f32
|
||||
write_render_item_inline(Buffer_Render_Item *item,
|
||||
int index,
|
||||
i32 index,
|
||||
unsigned short glyphid,
|
||||
float x, float y,
|
||||
float *advance_data, float h){
|
||||
float ch_width;
|
||||
f32 x, f32 y,
|
||||
f32 *advance_data, f32 h){
|
||||
f32 ch_width;
|
||||
ch_width = measure_character(advance_data, (char)glyphid);
|
||||
write_render_item(item, index, glyphid, x, y, ch_width, h);
|
||||
return(ch_width);
|
||||
}
|
||||
|
||||
internal_4tech void
|
||||
buffer_get_render_data(Buffer_Type *buffer, Buffer_Render_Item *items, int max, int *count,
|
||||
float port_x, float port_y,
|
||||
float scroll_x, float scroll_y, Full_Cursor start_cursor,
|
||||
int wrapped,
|
||||
float width, float height,
|
||||
float *advance_data, float font_height,
|
||||
buffer_get_render_data(Buffer_Type *buffer, Buffer_Render_Item *items, i32 max, i32 *count,
|
||||
f32 port_x, f32 port_y,
|
||||
f32 scroll_x, f32 scroll_y, Full_Cursor start_cursor,
|
||||
i32 wrapped,
|
||||
f32 width, f32 height,
|
||||
f32 *advance_data, f32 font_height,
|
||||
Buffer_Render_Options opts){
|
||||
|
||||
Buffer_Stringify_Type loop;
|
||||
Buffer_Render_Item *item;
|
||||
Buffer_Render_Item *item_end;
|
||||
char *data;
|
||||
int size, end;
|
||||
float shift_x, shift_y;
|
||||
float x, y;
|
||||
int i, item_i;
|
||||
float ch_width, ch_width_sub;
|
||||
i32 size, end;
|
||||
f32 shift_x, shift_y;
|
||||
f32 x, y;
|
||||
i32 i, item_i;
|
||||
f32 ch_width, ch_width_sub;
|
||||
uint8_t ch;
|
||||
|
||||
size = buffer_size(buffer);
|
||||
|
|
|
|||
|
|
@ -1,53 +1,49 @@
|
|||
/*
|
||||
/*
|
||||
* Mr. 4th Dimention - Allen Webster
|
||||
* Four Tech
|
||||
*
|
||||
* public domain -- no warranty is offered or implied; use this code at your own risk
|
||||
*
|
||||
* 23.10.2015
|
||||
*
|
||||
* Buffer data object
|
||||
* type - Gap Buffer
|
||||
*
|
||||
*
|
||||
* An implementation of a gap buffer.
|
||||
*
|
||||
*/
|
||||
|
||||
// TOP
|
||||
|
||||
typedef struct Gap_Buffer{
|
||||
char *data;
|
||||
int size1;
|
||||
int gap_size;
|
||||
int size2;
|
||||
int max;
|
||||
i32 size1;
|
||||
i32 gap_size;
|
||||
i32 size2;
|
||||
i32 max;
|
||||
|
||||
float *line_widths;
|
||||
int *line_starts;
|
||||
int line_count;
|
||||
int widths_count;
|
||||
int line_max;
|
||||
int widths_max;
|
||||
f32 *line_widths;
|
||||
i32 *line_starts;
|
||||
i32 line_count;
|
||||
i32 widths_count;
|
||||
i32 line_max;
|
||||
i32 widths_max;
|
||||
} Gap_Buffer;
|
||||
|
||||
inline_4tech int
|
||||
inline_4tech i32
|
||||
buffer_good(Gap_Buffer *buffer){
|
||||
int good = (buffer->data != 0);
|
||||
i32 good = (buffer->data != 0);
|
||||
return(good);
|
||||
}
|
||||
|
||||
inline_4tech int
|
||||
inline_4tech i32
|
||||
buffer_size(Gap_Buffer *buffer){
|
||||
int size = buffer->size1 + buffer->size2;
|
||||
i32 size = buffer->size1 + buffer->size2;
|
||||
return(size);
|
||||
}
|
||||
|
||||
typedef struct Gap_Buffer_Init{
|
||||
Gap_Buffer *buffer;
|
||||
char *data;
|
||||
int size;
|
||||
i32 size;
|
||||
} Gap_Buffer_Init;
|
||||
|
||||
internal_4tech Gap_Buffer_Init
|
||||
buffer_begin_init(Gap_Buffer *buffer, char *data, int size){
|
||||
buffer_begin_init(Gap_Buffer *buffer, char *data, i32 size){
|
||||
Gap_Buffer_Init init;
|
||||
init.buffer = buffer;
|
||||
init.data = data;
|
||||
|
|
@ -55,31 +51,31 @@ buffer_begin_init(Gap_Buffer *buffer, char *data, int size){
|
|||
return(init);
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
internal_4tech i32
|
||||
buffer_init_need_more(Gap_Buffer_Init *init){
|
||||
int result = 1;
|
||||
i32 result = 1;
|
||||
if (init->buffer->data) result = 0;
|
||||
return(result);
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
internal_4tech i32
|
||||
buffer_init_page_size(Gap_Buffer_Init *init){
|
||||
int result = init->size * 2;
|
||||
i32 result = init->size * 2;
|
||||
return(result);
|
||||
}
|
||||
|
||||
internal_4tech void
|
||||
buffer_init_provide_page(Gap_Buffer_Init *init, void *page, int page_size){
|
||||
buffer_init_provide_page(Gap_Buffer_Init *init, void *page, i32 page_size){
|
||||
Gap_Buffer *buffer = init->buffer;
|
||||
buffer->data = (char*)page;
|
||||
buffer->max = page_size;
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
buffer_end_init(Gap_Buffer_Init *init, void *scratch, int scratch_size){
|
||||
internal_4tech i32
|
||||
buffer_end_init(Gap_Buffer_Init *init, void *scratch, i32 scratch_size){
|
||||
Gap_Buffer *buffer = init->buffer;
|
||||
int osize1 = 0, size1 = 0, size2 = 0, size = init->size;
|
||||
int result = 0;
|
||||
i32 osize1 = 0, size1 = 0, size2 = 0, size = init->size;
|
||||
i32 result = 0;
|
||||
|
||||
if (buffer->data){
|
||||
if (buffer->max >= init->size){
|
||||
|
|
@ -108,14 +104,14 @@ buffer_end_init(Gap_Buffer_Init *init, void *scratch, int scratch_size){
|
|||
typedef struct Gap_Buffer_Stringify_Loop{
|
||||
Gap_Buffer *buffer;
|
||||
char *data, *base;
|
||||
int absolute_pos;
|
||||
int pos, end;
|
||||
int size;
|
||||
int separated;
|
||||
i32 absolute_pos;
|
||||
i32 pos, end;
|
||||
i32 size;
|
||||
i32 separated;
|
||||
} Gap_Buffer_Stringify_Loop;
|
||||
|
||||
internal_4tech Gap_Buffer_Stringify_Loop
|
||||
buffer_stringify_loop(Gap_Buffer *buffer, int start, int end){
|
||||
buffer_stringify_loop(Gap_Buffer *buffer, i32 start, i32 end){
|
||||
Gap_Buffer_Stringify_Loop result = {0};
|
||||
|
||||
if (0 <= start && start < end && end <= buffer->size1 + buffer->size2){
|
||||
|
|
@ -157,15 +153,15 @@ buffer_stringify_loop(Gap_Buffer *buffer, int start, int end){
|
|||
return(result);
|
||||
}
|
||||
|
||||
inline_4tech int
|
||||
inline_4tech i32
|
||||
buffer_stringify_good(Gap_Buffer_Stringify_Loop *loop){
|
||||
int result = (loop->buffer != 0);
|
||||
i32 result = (loop->buffer != 0);
|
||||
return(result);
|
||||
}
|
||||
|
||||
internal_4tech void
|
||||
buffer_stringify_next(Gap_Buffer_Stringify_Loop *loop){
|
||||
int size1 = 0, temp_end = 0;
|
||||
i32 size1 = 0, temp_end = 0;
|
||||
if (loop->separated){
|
||||
loop->separated = 0;
|
||||
size1 = loop->buffer->size1;
|
||||
|
|
@ -184,14 +180,14 @@ buffer_stringify_next(Gap_Buffer_Stringify_Loop *loop){
|
|||
typedef struct Gap_Buffer_Backify_Loop{
|
||||
Gap_Buffer *buffer;
|
||||
char *data, *base;
|
||||
int pos, end;
|
||||
int size;
|
||||
int absolute_pos;
|
||||
int separated;
|
||||
i32 pos, end;
|
||||
i32 size;
|
||||
i32 absolute_pos;
|
||||
i32 separated;
|
||||
} Gap_Buffer_Backify_Loop;
|
||||
|
||||
internal_4tech Gap_Buffer_Backify_Loop
|
||||
buffer_backify_loop(Gap_Buffer *buffer, int start, int end){
|
||||
buffer_backify_loop(Gap_Buffer *buffer, i32 start, i32 end){
|
||||
Gap_Buffer_Backify_Loop result = {0};
|
||||
|
||||
++start;
|
||||
|
|
@ -235,16 +231,16 @@ buffer_backify_loop(Gap_Buffer *buffer, int start, int end){
|
|||
return(result);
|
||||
}
|
||||
|
||||
inline_4tech int
|
||||
inline_4tech i32
|
||||
buffer_backify_good(Gap_Buffer_Backify_Loop *loop){
|
||||
int result = (loop->buffer != 0);
|
||||
i32 result = (loop->buffer != 0);
|
||||
return(result);
|
||||
}
|
||||
|
||||
internal_4tech void
|
||||
buffer_backify_next(Gap_Buffer_Backify_Loop *loop){
|
||||
Gap_Buffer *buffer = loop->buffer;
|
||||
int temp_end = 0;
|
||||
i32 temp_end = 0;
|
||||
|
||||
if (loop->separated){
|
||||
loop->separated = 0;
|
||||
|
|
@ -265,13 +261,13 @@ buffer_backify_next(Gap_Buffer_Backify_Loop *loop){
|
|||
loop->data = loop->base + loop->pos;
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
buffer_replace_range(Gap_Buffer *buffer, int start, int end, char *str, int len, int *shift_amount,
|
||||
void *scratch, int scratch_memory, int *request_amount){
|
||||
internal_4tech i32
|
||||
buffer_replace_range(Gap_Buffer *buffer, i32 start, i32 end, char *str, i32 len, i32 *shift_amount,
|
||||
void *scratch, i32 scratch_memory, i32 *request_amount){
|
||||
char *data = buffer->data;
|
||||
int size = buffer_size(buffer);
|
||||
int result = 0;
|
||||
int move_size = 0;
|
||||
i32 size = buffer_size(buffer);
|
||||
i32 result = 0;
|
||||
i32 move_size = 0;
|
||||
|
||||
assert_4tech(0 <= start);
|
||||
assert_4tech(start <= end);
|
||||
|
|
@ -309,14 +305,14 @@ buffer_replace_range(Gap_Buffer *buffer, int start, int end, char *str, int len,
|
|||
}
|
||||
|
||||
// NOTE(allen): This could should be optimized for Gap_Buffer
|
||||
internal_4tech int
|
||||
internal_4tech i32
|
||||
buffer_batch_edit_step(Buffer_Batch_State *state, Gap_Buffer *buffer, Buffer_Edit *sorted_edits,
|
||||
char *strings, int edit_count, void *scratch, int scratch_size, int *request_amount){
|
||||
char *strings, i32 edit_count, void *scratch, i32 scratch_size, i32 *request_amount){
|
||||
Buffer_Edit *edit = 0;
|
||||
int i = state->i;
|
||||
int shift_total = state->shift_total;
|
||||
int shift_amount = 0;
|
||||
int result = 0;
|
||||
i32 i = state->i;
|
||||
i32 shift_total = state->shift_total;
|
||||
i32 shift_amount = 0;
|
||||
i32 result = 0;
|
||||
|
||||
edit = sorted_edits + i;
|
||||
for (; i < edit_count; ++i, ++edit){
|
||||
|
|
@ -334,10 +330,10 @@ buffer_batch_edit_step(Buffer_Batch_State *state, Gap_Buffer *buffer, Buffer_Edi
|
|||
}
|
||||
|
||||
internal_4tech void*
|
||||
buffer_edit_provide_memory(Gap_Buffer *buffer, void *new_data, int new_max){
|
||||
buffer_edit_provide_memory(Gap_Buffer *buffer, void *new_data, i32 new_max){
|
||||
void *result = buffer->data;
|
||||
int size = buffer_size(buffer);
|
||||
int new_gap_size = new_max - size;
|
||||
i32 size = buffer_size(buffer);
|
||||
i32 new_gap_size = new_max - size;
|
||||
|
||||
assert_4tech(new_max >= size);
|
||||
|
||||
|
|
|
|||
|
|
@ -1,17 +1,16 @@
|
|||
/*
|
||||
/*
|
||||
* Mr. 4th Dimention - Allen Webster
|
||||
* Four Tech
|
||||
*
|
||||
* public domain -- no warranty is offered or implied; use this code at your own risk
|
||||
*
|
||||
* 23.10.2015
|
||||
*
|
||||
*
|
||||
* Items shared by gap buffer types
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
// TOP
|
||||
|
||||
// TODO(allen): eliminate the extra defs and the extra include.
|
||||
|
||||
#include "../4coder_seek_types.h"
|
||||
|
||||
#ifndef inline_4tech
|
||||
|
|
@ -27,7 +26,9 @@
|
|||
#endif
|
||||
|
||||
#ifndef memzero_4tech
|
||||
#define memzero_4tech(x) ((x) = {})
|
||||
#define memzero_4tech(x) do{ \
|
||||
char *p = (char*)&x; char *e = p + sizeof(x); \
|
||||
for (;p<e; ++p) {*p=0;} }while(0)
|
||||
#endif
|
||||
|
||||
#ifndef memcpy_4tech
|
||||
|
|
@ -60,9 +61,9 @@
|
|||
#endif
|
||||
|
||||
#ifndef round_up_4tech
|
||||
internal_4tech int
|
||||
lroundup_(int x, int granularity){
|
||||
int original_x;
|
||||
internal_4tech i32
|
||||
lroundup_(i32 x, i32 granularity){
|
||||
i32 original_x;
|
||||
original_x = x;
|
||||
x /= granularity;
|
||||
x *= granularity;
|
||||
|
|
@ -79,17 +80,17 @@ lroundup_(int x, int granularity){
|
|||
#define measure_character(a,c) ((a)[c])
|
||||
|
||||
typedef struct Buffer_Batch_State{
|
||||
int i;
|
||||
int shift_total;
|
||||
i32 i;
|
||||
i32 shift_total;
|
||||
} Buffer_Batch_State;
|
||||
|
||||
inline_4tech Full_Cursor
|
||||
make_cursor_hint(int line_index, int *starts, float *wrap_ys, float font_height){
|
||||
make_cursor_hint(i32 line_index, i32 *starts, f32 *wrap_ys, f32 font_height){
|
||||
Full_Cursor hint;
|
||||
hint.pos = starts[line_index];
|
||||
hint.line = line_index + 1;
|
||||
hint.character = 1;
|
||||
hint.unwrapped_y = (float)(line_index * font_height);
|
||||
hint.unwrapped_y = (f32)(line_index * font_height);
|
||||
hint.unwrapped_x = 0;
|
||||
hint.wrapped_y = wrap_ys[line_index];
|
||||
hint.wrapped_x = 0;
|
||||
|
|
@ -97,11 +98,11 @@ make_cursor_hint(int line_index, int *starts, float *wrap_ys, float font_height)
|
|||
}
|
||||
|
||||
typedef struct Cursor_With_Index{
|
||||
int pos, index;
|
||||
i32 pos, index;
|
||||
} Cursor_With_Index;
|
||||
|
||||
inline_4tech void
|
||||
write_cursor_with_index(Cursor_With_Index *positions, int *count, int pos){
|
||||
write_cursor_with_index(Cursor_With_Index *positions, i32 *count, i32 pos){
|
||||
positions[*count].index = *count;
|
||||
positions[*count].pos = pos;
|
||||
++*count;
|
||||
|
|
@ -110,9 +111,9 @@ write_cursor_with_index(Cursor_With_Index *positions, int *count, int pos){
|
|||
#define CursorSwap__(a,b) { Cursor_With_Index t = a; a = b; b = t; }
|
||||
|
||||
internal_4tech void
|
||||
buffer_quick_sort_cursors(Cursor_With_Index *positions, int start, int pivot){
|
||||
int i, mid;
|
||||
int pivot_pos;
|
||||
buffer_quick_sort_cursors(Cursor_With_Index *positions, i32 start, i32 pivot){
|
||||
i32 i, mid;
|
||||
i32 pivot_pos;
|
||||
|
||||
mid = start;
|
||||
pivot_pos = positions[pivot].pos;
|
||||
|
|
@ -129,9 +130,9 @@ buffer_quick_sort_cursors(Cursor_With_Index *positions, int start, int pivot){
|
|||
}
|
||||
|
||||
internal_4tech void
|
||||
buffer_quick_unsort_cursors(Cursor_With_Index *positions, int start, int pivot){
|
||||
int i, mid;
|
||||
int pivot_index;
|
||||
buffer_quick_unsort_cursors(Cursor_With_Index *positions, i32 start, i32 pivot){
|
||||
i32 i, mid;
|
||||
i32 pivot_index;
|
||||
|
||||
mid = start;
|
||||
pivot_index = positions[pivot].index;
|
||||
|
|
@ -150,50 +151,47 @@ buffer_quick_unsort_cursors(Cursor_With_Index *positions, int start, int pivot){
|
|||
#undef CursorSwap__
|
||||
|
||||
inline_4tech void
|
||||
buffer_sort_cursors(Cursor_With_Index *positions, int count){
|
||||
buffer_sort_cursors(Cursor_With_Index *positions, i32 count){
|
||||
assert_4tech(count > 0);
|
||||
buffer_quick_sort_cursors(positions, 0, count-1);
|
||||
}
|
||||
|
||||
inline_4tech void
|
||||
buffer_unsort_cursors(Cursor_With_Index *positions, int count){
|
||||
buffer_unsort_cursors(Cursor_With_Index *positions, i32 count){
|
||||
assert_4tech(count > 0);
|
||||
buffer_quick_unsort_cursors(positions, 0, count-1);
|
||||
}
|
||||
|
||||
internal_4tech void
|
||||
buffer_update_cursors(Cursor_With_Index *sorted_positions, int count, int start, int end, int len){
|
||||
int shift_amount = (len - (end - start));
|
||||
buffer_update_cursors(Cursor_With_Index *sorted_positions, i32 count, i32 start, i32 end, i32 len){
|
||||
i32 shift_amount = (len - (end - start));
|
||||
Cursor_With_Index *position = sorted_positions + count - 1;
|
||||
|
||||
for (; position >= sorted_positions && position->pos > end; --position) position->pos += shift_amount;
|
||||
for (; position >= sorted_positions && position->pos >= start; --position) position->pos = start;
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
buffer_batch_debug_sort_check(Buffer_Edit *sorted_edits, int edit_count){
|
||||
Buffer_Edit *edit;
|
||||
int i, result, start_point;
|
||||
internal_4tech i32
|
||||
buffer_batch_debug_sort_check(Buffer_Edit *sorted_edits, i32 edit_count){
|
||||
Buffer_Edit *edit = sorted_edits;
|
||||
i32 i = 0, start_point = 0;
|
||||
i32 result = 1;
|
||||
|
||||
result = 1;
|
||||
start_point = 0;
|
||||
|
||||
edit = sorted_edits;
|
||||
for (i = 0; i < edit_count; ++i, ++edit){
|
||||
if (start_point > edit->start){
|
||||
result = 0; break;
|
||||
}
|
||||
start_point = (edit->end < edit->start + 1)?edit->start + 1:edit->end;
|
||||
start_point = (edit->end < edit->start + 1)?(edit->start + 1):(edit->end);
|
||||
}
|
||||
|
||||
return(result);
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
buffer_batch_edit_max_shift(Buffer_Edit *sorted_edits, int edit_count){
|
||||
internal_4tech i32
|
||||
buffer_batch_edit_max_shift(Buffer_Edit *sorted_edits, i32 edit_count){
|
||||
Buffer_Edit *edit;
|
||||
int i, result;
|
||||
int shift_total, shift_max;
|
||||
i32 i, result;
|
||||
i32 shift_total, shift_max;
|
||||
|
||||
result = 0;
|
||||
shift_total = 0;
|
||||
|
|
@ -208,12 +206,12 @@ buffer_batch_edit_max_shift(Buffer_Edit *sorted_edits, int edit_count){
|
|||
return(shift_max);
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
buffer_batch_edit_update_cursors(Cursor_With_Index *sorted_positions, int count, Buffer_Edit *sorted_edits, int edit_count){
|
||||
internal_4tech i32
|
||||
buffer_batch_edit_update_cursors(Cursor_With_Index *sorted_positions, i32 count, Buffer_Edit *sorted_edits, i32 edit_count){
|
||||
Cursor_With_Index *position, *end_position;
|
||||
Buffer_Edit *edit, *end_edit;
|
||||
int start, end;
|
||||
int shift_amount;
|
||||
i32 start, end;
|
||||
i32 shift_amount;
|
||||
|
||||
position = sorted_positions;
|
||||
end_position = sorted_positions + count;
|
||||
|
|
@ -249,9 +247,9 @@ buffer_batch_edit_update_cursors(Cursor_With_Index *sorted_positions, int count,
|
|||
return(shift_amount);
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
eol_convert_in(char *dest, char *src, int size){
|
||||
int i, j, k;
|
||||
internal_4tech i32
|
||||
eol_convert_in(char *dest, char *src, i32 size){
|
||||
i32 i, j, k;
|
||||
|
||||
i = 0;
|
||||
k = 0;
|
||||
|
|
@ -277,9 +275,9 @@ eol_convert_in(char *dest, char *src, int size){
|
|||
return(j);
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
eol_in_place_convert_in(char *data, int size){
|
||||
int i, j, k;
|
||||
internal_4tech i32
|
||||
eol_in_place_convert_in(char *data, i32 size){
|
||||
i32 i, j, k;
|
||||
|
||||
i = 0;
|
||||
k = 0;
|
||||
|
|
@ -304,10 +302,10 @@ eol_in_place_convert_in(char *data, int size){
|
|||
return(j);
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
eol_convert_out(char *dest, int max, char *src, int size, int *size_out){
|
||||
int result;
|
||||
int i, j;
|
||||
internal_4tech i32
|
||||
eol_convert_out(char *dest, i32 max, char *src, i32 size, i32 *size_out){
|
||||
i32 result;
|
||||
i32 i, j;
|
||||
|
||||
// TODO(allen): iterative memory check?
|
||||
result = 1;
|
||||
|
|
@ -327,10 +325,10 @@ eol_convert_out(char *dest, int max, char *src, int size, int *size_out){
|
|||
return(result);
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
eol_in_place_convert_out(char *data, int size, int max, int *size_out){
|
||||
int result;
|
||||
int i;
|
||||
internal_4tech i32
|
||||
eol_in_place_convert_out(char *data, i32 size, i32 max, i32 *size_out){
|
||||
i32 result;
|
||||
i32 i;
|
||||
|
||||
// TODO(allen): iterative memory check?
|
||||
result = 1;
|
||||
|
|
@ -349,29 +347,29 @@ eol_in_place_convert_out(char *data, int size, int max, int *size_out){
|
|||
return(result);
|
||||
}
|
||||
|
||||
inline_4tech int
|
||||
inline_4tech i32
|
||||
is_whitespace(char c){
|
||||
int result;
|
||||
i32 result;
|
||||
result = (c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == '\f' || c == '\v');
|
||||
return(result);
|
||||
}
|
||||
|
||||
inline_4tech int
|
||||
inline_4tech i32
|
||||
is_alphanumeric_true(char c){
|
||||
return (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9');
|
||||
}
|
||||
|
||||
inline_4tech int
|
||||
inline_4tech i32
|
||||
is_alphanumeric(char c){
|
||||
return (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' || c == '_');
|
||||
}
|
||||
|
||||
inline_4tech int
|
||||
inline_4tech i32
|
||||
is_upper(char c){
|
||||
return (c >= 'A' && c <= 'Z');
|
||||
}
|
||||
|
||||
inline_4tech int
|
||||
inline_4tech i32
|
||||
is_lower(char c){
|
||||
return (c >= 'a' && c <= 'z');
|
||||
}
|
||||
|
|
@ -384,9 +382,9 @@ to_upper(char c){
|
|||
return(c);
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
is_match(char *a, char *b, int len){
|
||||
int result;
|
||||
internal_4tech i32
|
||||
is_match(char *a, char *b, i32 len){
|
||||
i32 result;
|
||||
|
||||
result = 1;
|
||||
for (;len > 0; --len, ++a, ++b)
|
||||
|
|
@ -395,9 +393,9 @@ is_match(char *a, char *b, int len){
|
|||
return(result);
|
||||
}
|
||||
|
||||
internal_4tech int
|
||||
is_match_insensitive(char *a, char *b, int len){
|
||||
int result;
|
||||
internal_4tech i32
|
||||
is_match_insensitive(char *a, char *b, i32 len){
|
||||
i32 result;
|
||||
|
||||
result = 1;
|
||||
for (;len > 0; --len, ++a, ++b)
|
||||
|
|
|
|||
Loading…
Reference in New Issue