4coder/custom/4coder_auto_indent.cpp

435 lines
16 KiB
C++
Raw Normal View History

/*
4coder_auto_indent.cpp - Commands for automatic indentation.
*/
// TOP
internal Batch_Edit*
make_batch_from_indentations(Application_Links *app, Arena *arena, Buffer_ID buffer, Range_i64 lines, i64 *indentations, Indent_Flag flags, i32 tab_width){
i64 *shifted_indentations = indentations - lines.first;
2016-09-09 01:02:51 +00:00
Batch_Edit *batch_first = 0;
Batch_Edit *batch_last = 0;
2016-09-09 01:02:51 +00:00
for (i64 line_number = lines.first;
line_number <= lines.max;
++line_number){
i64 line_start_pos = get_line_start_pos(app, buffer, line_number);
Indent_Info indent_info = get_indent_info_line_start(app, buffer, line_start_pos, tab_width);
2016-09-09 01:02:51 +00:00
i64 correct_indentation = shifted_indentations[line_number];
if (indent_info.is_blank && HasFlag(flags, Indent_ClearLine)){
correct_indentation = 0;
}
if (correct_indentation == -1){
correct_indentation = indent_info.indent_pos;
}
2016-09-09 01:02:51 +00:00
if (correct_indentation != indent_info.indent_pos){
2019-06-01 23:58:28 +00:00
umem str_size = 0;
u8 *str = 0;
if (HasFlag(flags, Indent_UseTab)){
i64 tab_count = correct_indentation/tab_width;
i64 indent = tab_count*tab_width;
i64 space_count = correct_indentation - indent;
2019-06-01 23:58:28 +00:00
str_size = tab_count + space_count;
str = push_array(arena, u8, str_size);
2019-06-01 23:58:28 +00:00
block_fill_u8(str, tab_count, '\t');
block_fill_u8(str + tab_count, space_count, ' ');
2016-09-09 01:02:51 +00:00
}
else{
2019-06-01 23:58:28 +00:00
str_size = correct_indentation;
str = push_array(arena, u8, str_size);
2019-06-01 23:58:28 +00:00
block_fill_u8(str, str_size, ' ');
2016-09-09 01:02:51 +00:00
}
Batch_Edit *batch = push_array(arena, Batch_Edit, 1);
sll_queue_push(batch_first, batch_last, batch);
batch->edit.text = SCu8(str, str_size);
batch->edit.range = Ii64(line_start_pos, indent_info.first_char_pos);
2016-09-09 01:02:51 +00:00
}
2016-09-08 00:32:31 +00:00
}
return(batch_first);
2016-09-08 00:32:31 +00:00
}
internal void
set_line_indents(Application_Links *app, Arena *arena, Buffer_ID buffer, Range_i64 lines, i64 *indentations, Indent_Flag flags, i32 tab_width){
Batch_Edit *batch = make_batch_from_indentations(app, arena, buffer, lines, indentations, flags, tab_width);
if (batch != 0){
buffer_batch_edit(app, buffer, batch);
2016-09-09 01:02:51 +00:00
}
}
2019-09-04 05:31:35 +00:00
internal Token*
find_anchor_token(Application_Links *app, Buffer_ID buffer, Token_Array *tokens, i64 invalid_line){
Token *result = 0;
if (tokens != 0 && tokens->tokens != 0){
result = tokens->tokens;
i64 invalid_pos = get_line_start_pos(app, buffer, invalid_line);
i32 scope_counter = 0;
i32 paren_counter = 0;
Token *token = tokens->tokens;
for (;;token += 1){
if (token->pos + token->size > invalid_pos){
break;
}
if (!HasFlag(token->flags, TokenBaseFlag_PreprocessorBody)){
if (scope_counter == 0 && paren_counter == 0){
result = token;
}
switch (token->kind){
case TokenBaseKind_ScopeOpen:
{
scope_counter += 1;
}break;
case TokenBaseKind_ScopeClose:
{
paren_counter = 0;
if (scope_counter > 0){
scope_counter -= 1;
}
}break;
case TokenBaseKind_ParentheticalOpen:
{
paren_counter += 1;
}break;
case TokenBaseKind_ParentheticalClose:
{
if (paren_counter > 0){
paren_counter -= 1;
}
}break;
}
2016-09-08 00:32:31 +00:00
}
}
}
return(result);
2016-09-08 00:32:31 +00:00
}
internal Nest*
indent__new_nest(Arena *arena, Nest_Alloc *alloc){
Nest *new_nest = alloc->free_nest;
if (new_nest == 0){
new_nest = push_array(arena, Nest, 1);
2018-05-07 02:47:22 +00:00
}
else{
sll_stack_pop(alloc->free_nest);
}
return(new_nest);
}
internal void
indent__free_nest(Nest_Alloc *alloc, Nest *nest){
sll_stack_push(alloc->free_nest, nest);
2016-09-09 01:02:51 +00:00
}
2019-10-12 04:10:56 +00:00
internal b32
indent__unfinished_statement(Token *token, Nest *current_nest){
b32 result = false;
if (current_nest != 0 && current_nest->kind == TokenBaseKind_ScopeOpen){
result = true;
switch (token->sub_kind){
case TokenCppKind_BraceOp:
case TokenCppKind_BraceCl:
case TokenCppKind_Semicolon:
case TokenCppKind_Colon:
case TokenCppKind_Comma:
{
result = false;
}break;
}
if (HasFlag(token->flags, TokenBaseFlag_PreprocessorBody)){
result = false;
}
}
return(result);
}
internal i64*
get_indentation_array(Application_Links *app, Arena *arena, Buffer_ID buffer, Range_i64 lines, Indent_Flag flags, i32 tab_width, i32 indent_width){
i64 count = lines.max - lines.min + 1;
i64 *indentations = push_array(arena, i64, count);
i64 *shifted_indentations = indentations - lines.first;
block_fill_u64(indentations, sizeof(*indentations)*count, (u64)(-1));
2016-09-08 00:32:31 +00:00
Managed_Scope scope = buffer_get_managed_scope(app, buffer);
Token_Array *tokens = scope_attachment(app, scope, attachment_tokens, Token_Array);
i64 anchor_line = clamp_bot(1, lines.first - 1);
Token *anchor_token = find_anchor_token(app, buffer, tokens, anchor_line);
if (anchor_token != 0 &&
anchor_token >= tokens->tokens &&
anchor_token < tokens->tokens + tokens->count){
i64 line = get_line_number_from_pos(app, buffer, anchor_token->pos);
line = clamp_top(line, lines.first);
Token_Iterator_Array token_it = token_iterator(0, tokens, anchor_token);
2016-09-08 00:32:31 +00:00
Scratch_Block scratch(app);
Nest *nest = 0;
Nest_Alloc nest_alloc = {};
i64 line_last_indented = line - 1;
i64 last_indent = 0;
i64 actual_indent = 0;
2019-10-12 04:10:56 +00:00
b32 in_unfinished_statement = false;
for (;;){
Token *token = token_it_read(&token_it);
i64 line_where_token_starts = get_line_number_from_pos(app, buffer, token->pos);
i64 line_start_pos = get_line_start_pos(app, buffer, line_where_token_starts);
Indent_Info line_indent_info = get_indent_info_line_start(app, buffer, line_start_pos, tab_width);
i64 current_indent = 0;
if (nest != 0){
current_indent = nest->indent;
}
i64 this_indent = current_indent;
i64 following_indent = current_indent;
2019-10-20 02:01:06 +00:00
b32 shift_by_actual_indent = false;
b32 ignore_unfinished_statement = false;
if (HasFlag(token->flags, TokenBaseFlag_PreprocessorBody)){
this_indent = 0;
}
else{
switch (token->kind){
case TokenBaseKind_ScopeOpen:
{
Nest *new_nest = indent__new_nest(arena, &nest_alloc);
sll_stack_push(nest, new_nest);
nest->kind = TokenBaseKind_ScopeOpen;
nest->indent = current_indent + indent_width;
following_indent = nest->indent;
2019-10-20 02:01:06 +00:00
ignore_unfinished_statement = true;
}break;
case TokenBaseKind_ScopeClose:
{
for (;nest != 0 && nest->kind != TokenBaseKind_ScopeOpen;){
Nest *n = nest;
sll_stack_pop(nest);
indent__free_nest(&nest_alloc, n);
}
if (nest != 0 && nest->kind == TokenBaseKind_ScopeOpen){
Nest *n = nest;
sll_stack_pop(nest);
indent__free_nest(&nest_alloc, n);
2016-09-13 13:52:54 +00:00
}
this_indent = 0;
if (nest != 0){
this_indent = nest->indent;
}
following_indent = this_indent;
2019-10-20 02:01:06 +00:00
ignore_unfinished_statement = true;
}break;
case TokenBaseKind_ParentheticalOpen:
{
Nest *new_nest = indent__new_nest(arena, &nest_alloc);
sll_stack_push(nest, new_nest);
nest->kind = TokenBaseKind_ParentheticalOpen;
2019-10-20 02:01:06 +00:00
nest->indent = (token->pos - line_indent_info.first_char_pos) + 1;
following_indent = nest->indent;
2019-10-20 02:01:06 +00:00
shift_by_actual_indent = true;
}break;
case TokenBaseKind_ParentheticalClose:
{
if (nest != 0 && nest->kind == TokenBaseKind_ParentheticalOpen){
Nest *n = nest;
sll_stack_pop(nest);
indent__free_nest(&nest_alloc, n);
2016-09-13 13:52:54 +00:00
}
following_indent = 0;
if (nest != 0){
following_indent = nest->indent;
}
2019-10-20 02:01:06 +00:00
ignore_unfinished_statement = true;
}break;
2016-09-13 13:52:54 +00:00
}
}
2019-10-20 02:01:06 +00:00
if (in_unfinished_statement && !ignore_unfinished_statement){
2019-10-12 04:10:56 +00:00
this_indent += indent_width;
}
#define EMIT(N) \
Stmnt(if (lines.first <= line_it){shifted_indentations[line_it]=N;} \
if (line_it == lines.end){goto finished;} \
actual_indent = N; )
i64 line_it = line_last_indented;
for (;line_it < line_where_token_starts;){
line_it += 1;
if (line_it == line_where_token_starts){
EMIT(this_indent);
2016-09-13 13:52:54 +00:00
}
else{
EMIT(last_indent);
2016-09-08 00:32:31 +00:00
}
}
i64 line_where_token_starts_shift = this_indent - line_indent_info.indent_pos;
i64 line_where_token_ends = get_line_number_from_pos(app, buffer, token->pos + token->size);
for (;line_it < line_where_token_ends;){
line_it += 1;
i64 line_it_start_pos = get_line_start_pos(app, buffer, line_it);
Indent_Info line_it_indent_info = get_indent_info_line_start(app, buffer, line_it_start_pos, tab_width);
i64 new_indent = line_it_indent_info.indent_pos + line_where_token_starts_shift;
new_indent = clamp_bot(0, new_indent);
EMIT(new_indent);
}
#undef EMIT
2019-10-20 02:01:06 +00:00
if (shift_by_actual_indent){
nest->indent += actual_indent;
following_indent += actual_indent;
}
2019-10-12 04:10:56 +00:00
if (token->kind != TokenBaseKind_Comment){
in_unfinished_statement = indent__unfinished_statement(token, nest);
if (in_unfinished_statement){
following_indent += indent_width;
}
}
last_indent = following_indent;
line_last_indented = line_it;
if (!token_it_inc_non_whitespace(&token_it)){
break;
2016-09-08 00:32:31 +00:00
}
}
}
finished:;
return(indentations);
2016-09-10 15:22:25 +00:00
}
internal b32
auto_indent_buffer(Application_Links *app, Buffer_ID buffer, Range_i64 pos, Indent_Flag flags, i32 tab_width, i32 indent_width){
2019-10-22 07:15:49 +00:00
ProfileScope(app, "auto indent buffer");
2019-09-04 05:31:35 +00:00
Managed_Scope scope = buffer_get_managed_scope(app, buffer);
Token_Array *tokens = scope_attachment(app, scope, attachment_tokens, Token_Array);
2019-09-04 05:31:35 +00:00
b32 result = false;
if (tokens != 0 && tokens->tokens != 0){
result = true;
2016-09-08 00:32:31 +00:00
Scratch_Block scratch(app);
Range_i64 line_numbers = {};
if (HasFlag(flags, Indent_FullTokens)){
i32 safety_counter = 0;
for (;;){
Range_i64 expanded = enclose_tokens(app, buffer, pos);
expanded = enclose_whole_lines(app, buffer, expanded);
if (expanded == pos){
break;
}
pos = expanded;
safety_counter += 1;
if (safety_counter == 20){
pos = buffer_range(app, buffer);
break;
}
}
2016-09-10 15:22:25 +00:00
}
line_numbers = get_line_range_from_pos_range(app, buffer, pos);
2016-09-08 00:32:31 +00:00
i64 *indentations = get_indentation_array(app, scratch, buffer, line_numbers, flags, tab_width, indent_width);
set_line_indents(app, scratch, buffer, line_numbers, indentations, flags, tab_width);
2016-09-08 00:32:31 +00:00
}
return(result);
}
global_const i32 auto_indent_tab_width = 4;
function void
auto_indent_buffer(Application_Links *app, Buffer_ID buffer, Range_i64 pos, Indent_Flag flags){
i32 indent_width = global_config.indent_width;
AddFlag(flags, Indent_FullTokens);
if (global_config.indent_with_tabs){
AddFlag(flags, Indent_UseTab);
}
auto_indent_buffer(app, buffer, pos, flags, indent_width, auto_indent_tab_width);
}
function void
auto_indent_buffer(Application_Links *app, Buffer_ID buffer, Range_i64 pos){
auto_indent_buffer(app, buffer, pos, 0);
}
////////////////////////////////
CUSTOM_COMMAND_SIG(auto_indent_whole_file)
CUSTOM_DOC("Audo-indents the entire current buffer.")
{
View_ID view = get_active_view(app, Access_ReadWriteVisible);
Buffer_ID buffer = view_get_buffer(app, view, Access_ReadWriteVisible);
i64 buffer_size = buffer_get_size(app, buffer);
auto_indent_buffer(app, buffer, Ii64(0, buffer_size));
}
CUSTOM_COMMAND_SIG(auto_indent_line_at_cursor)
CUSTOM_DOC("Auto-indents the line on which the cursor sits.")
{
View_ID view = get_active_view(app, Access_ReadWriteVisible);
Buffer_ID buffer = view_get_buffer(app, view, Access_ReadWriteVisible);
i64 pos = view_get_cursor_pos(app, view);
auto_indent_buffer(app, buffer, Ii64(pos));
move_past_lead_whitespace(app, view, buffer);
}
CUSTOM_COMMAND_SIG(auto_indent_range)
CUSTOM_DOC("Auto-indents the range between the cursor and the mark.")
{
View_ID view = get_active_view(app, Access_ReadWriteVisible);
Buffer_ID buffer = view_get_buffer(app, view, Access_ReadWriteVisible);
Range_i64 range = get_view_range(app, view);
auto_indent_buffer(app, buffer, range);
move_past_lead_whitespace(app, view, buffer);
}
CUSTOM_COMMAND_SIG(write_text_and_auto_indent)
CUSTOM_DOC("Inserts text and auto-indents the line on which the cursor sits if any of the text contains 'layout punctuation' such as ;:{}()[]# and new lines.")
{
2019-10-14 22:57:47 +00:00
User_Input in = get_current_input(app);
String_Const_u8 insert = to_writable(&in);
if (insert.str != 0 && insert.size > 0){
b32 do_auto_indent = false;
for (umem i = 0; !do_auto_indent && i < insert.size; i += 1){
switch (insert.str[i]){
case ';': case ':':
case '{': case '}':
case '(': case ')':
case '[': case ']':
case '#':
case '\n': case '\t':
{
do_auto_indent = true;
}break;
}
}
if (do_auto_indent){
View_ID view = get_active_view(app, Access_ReadWriteVisible);
Buffer_ID buffer = view_get_buffer(app, view, Access_ReadWriteVisible);
Range_i64 pos = {};
pos.min = view_get_cursor_pos(app, view);
write_text_input(app);
pos.max= view_get_cursor_pos(app, view);
auto_indent_buffer(app, buffer, pos, 0);
move_past_lead_whitespace(app, view, buffer);
}
else{
write_text_input(app);
}
2017-12-02 22:17:06 +00:00
}
}
// BOTTOM