| /** |
| * @file indent.cpp |
| * Does all the indenting stuff. |
| * |
| * $Id: indent.cpp 548 2006-10-21 02:31:55Z bengardner $ |
| */ |
| #include "uncrustify_types.h" |
| #include "chunk_list.h" |
| #include "prototypes.h" |
| #include <cstdio> |
| #include <cstdlib> |
| #include <cstring> |
| #include <cerrno> |
| #include <cctype> |
| |
| |
| /** |
| * General indenting approach: |
| * Indenting levels are put into a stack. |
| * |
| * The stack entries contain: |
| * - opening type |
| * - brace column |
| * - continuation column |
| * |
| * Items that start a new stack item: |
| * - preprocessor (new parse frame) |
| * - Brace Open (Virtual brace also) |
| * - Paren, Square, Angle open |
| * - Assignments |
| * - C++ '<<' operator (ie, cout << "blah") |
| * - case |
| * - class colon |
| * - return |
| * - types |
| * - any other continued statement |
| * |
| * Note that the column of items marked 'PCF_WAS_ALIGNED' is not changed. |
| * |
| * For an open brace: |
| * - indent increases by indent_columns |
| * - if part of if/else/do/while/switch/etc, an extra indent may be applied |
| * - if in a paren, then cont-col is set to column + 1, ie "({ some code })" |
| * |
| * Open paren/square/angle: |
| * cont-col is set to the column of the item after the open paren, unless |
| * followed by a newline, then it is set to (brace-col + indent_columns). |
| * Examples: |
| * a_really_long_funcion_name( |
| * param1, param2); |
| * a_really_long_funcion_name(param1, |
| * param2); |
| * |
| * Assignments: |
| * Assignments are continued aligned with the first item after the assignment, |
| * unless the assign is followed by a newline. |
| * Examples: |
| * some.variable = asdf + asdf + |
| * asdf; |
| * some.variable = |
| * asdf + asdf + asdf; |
| * |
| * C++ << operator: |
| * Handled the same as assignment. |
| * Examples: |
| * cout << "this is test number: " |
| * << test_number; |
| * |
| * case: |
| * Started with case or default. |
| * Terminated with close brace at level or another case or default. |
| * Special indenting according to various rules. |
| * - indent of case label |
| * - indent of case body |
| * - how to handle optional braces |
| * Examples: |
| * { |
| * case x: { |
| * a++; |
| * break; |
| * } |
| * case y: |
| * b--; |
| * break; |
| * default: |
| * c++; |
| * break; |
| * } |
| * |
| * Class colon: |
| * Indent continuation by indent_columns: |
| * class my_class : |
| * baseclass1, |
| * baseclass2 |
| * { |
| * |
| * Return: same as assignemts |
| * If the return statement is not fully paren'd, then the indent continues at |
| * the column of the item after the return. If it is paren'd, then the paren |
| * rules apply. |
| * return somevalue + |
| * othervalue; |
| * |
| * Type: pretty much the same as assignments |
| * Examples: |
| * int foo, |
| * bar, |
| * baz; |
| * |
| * Any other continued item: |
| * There shouldn't be anything not covered by the above cases, but any other |
| * continued item is indented by indent_columns: |
| * Example: |
| * somereallycrazylongname.with[lotsoflongstuff]. |
| * thatreallyannoysme.whenIhavetomaintain[thecode] = 3; |
| */ |
| |
| static void indent_comment(chunk_t *pc, int col); |
| |
| |
| void indent_to_column(chunk_t *pc, int column) |
| { |
| if (column < pc->column) |
| { |
| column = pc->column; |
| } |
| reindent_line(pc, column); |
| } |
| |
| /** |
| * Changes the initial indent for a line to the given column |
| * |
| * @param pc The chunk at the start of the line |
| * @param column The desired column |
| */ |
| void reindent_line(chunk_t *pc, int column) |
| { |
| int col_delta; |
| int min_col; |
| |
| LOG_FMT(LINDLINE, "%s: %d] col %d on %.*s [%s] => %d\n", |
| __func__, pc->orig_line, pc->column, pc->len, pc->str, |
| get_token_name(pc->type), column); |
| |
| if (column == pc->column) |
| { |
| return; |
| } |
| col_delta = column - pc->column; |
| pc->column = column; |
| min_col = pc->column; |
| |
| do |
| { |
| min_col += pc->len; |
| pc = chunk_get_next(pc); |
| if (pc != NULL) |
| { |
| if (chunk_is_comment(pc)) |
| { |
| pc->column = pc->orig_col; |
| if (pc->column < min_col) |
| { |
| pc->column = min_col + 1; |
| } |
| LOG_FMT(LINDLINE, "%s: set comment on line %d to col %d (orig %d)\n", |
| __func__, pc->orig_line, pc->column, pc->orig_col); |
| } |
| else |
| { |
| pc->column += col_delta; |
| if (pc->column < min_col) |
| { |
| pc->column = min_col; |
| } |
| } |
| } |
| } while ((pc != NULL) && (pc->nl_count == 0)); |
| } |
| |
| |
| /** |
| * Starts a new entry |
| * |
| * @param frm The parse frame |
| * @param pc The chunk causing the push |
| */ |
| static void indent_pse_push(struct parse_frame& frm, chunk_t *pc) |
| { |
| static int ref = 0; |
| |
| /* check the stack depth */ |
| if (frm.pse_tos < (int)ARRAY_SIZE(frm.pse)) |
| { |
| /* Bump up the index and initialize it */ |
| frm.pse_tos++; |
| memset(&frm.pse[frm.pse_tos], 0, sizeof(frm.pse[frm.pse_tos])); |
| |
| LOG_FMT(LINDPSE, "%4d] OPEN [%d,%s] level=%d\n", |
| pc->orig_line, frm.pse_tos, get_token_name(pc->type), pc->level); |
| |
| frm.pse[frm.pse_tos].type = pc->type; |
| frm.pse[frm.pse_tos].level = pc->level; |
| frm.pse[frm.pse_tos].open_line = pc->orig_line; |
| frm.pse[frm.pse_tos].ref = ++ref; |
| frm.pse[frm.pse_tos].in_preproc = (pc->flags & PCF_IN_PREPROC) != 0; |
| } |
| } |
| |
| |
| /** |
| * Removes the top entry |
| * |
| * @param frm The parse frame |
| * @param pc The chunk causing the push |
| */ |
| static void indent_pse_pop(struct parse_frame& frm, chunk_t *pc) |
| { |
| /* Bump up the index and initialize it */ |
| if (frm.pse_tos > 0) |
| { |
| if (pc != NULL) |
| { |
| LOG_FMT(LINDPSE, "%4d] CLOSE [%d,%s] on %s, started on line %d, level=%d/%d\n", |
| pc->orig_line, frm.pse_tos, |
| get_token_name(frm.pse[frm.pse_tos].type), |
| get_token_name(pc->type), |
| frm.pse[frm.pse_tos].open_line, |
| frm.pse[frm.pse_tos].level, |
| pc->level); |
| } |
| else |
| { |
| LOG_FMT(LINDPSE, " EOF] CLOSE [%d,%s], started on line %d\n", |
| frm.pse_tos, get_token_name(frm.pse[frm.pse_tos].type), |
| frm.pse[frm.pse_tos].open_line); |
| } |
| frm.pse_tos--; |
| } |
| } |
| |
| |
| static int token_indent(c_token_t type) |
| { |
| switch (type) |
| { |
| case CT_IF: |
| case CT_DO: |
| return(3); |
| |
| case CT_FOR: |
| case CT_ELSE: // wacky, but that's what is wanted |
| return(4); |
| |
| case CT_WHILE: |
| return(6); |
| |
| case CT_SWITCH: |
| return(7); |
| |
| case CT_ELSEIF: |
| return(8); |
| |
| default: |
| return(0); //cpd.settings[UO_indent_braces].n; |
| } |
| } |
| |
| |
| /** |
| * Change the top-level indentation only by changing the column member in |
| * the chunk structures. |
| * The level indicator must already be set. |
| */ |
| void indent_text(void) |
| { |
| chunk_t *pc; |
| chunk_t *next; |
| chunk_t *prev = NULL; |
| bool did_newline = true; |
| int idx; |
| int vardefcol = 0; |
| int indent_size = cpd.settings[UO_indent_columns].n; |
| int tmp; |
| struct parse_frame frm; |
| bool in_preproc = false, was_preproc = false; |
| int indent_column; |
| int cout_col = 0; // for aligning << stuff |
| int cout_level = 0; // for aligning << stuff |
| int parent_token_indent = 0; |
| |
| memset(&frm, 0, sizeof(frm)); |
| |
| /* dummy top-level entry */ |
| frm.pse[0].indent = 1; |
| frm.pse[0].indent_tmp = 1; |
| frm.pse[0].type = CT_EOF; |
| |
| pc = chunk_get_head(); |
| while (pc != NULL) |
| { |
| /* Handle proprocessor transitions */ |
| was_preproc = in_preproc; |
| in_preproc = (pc->flags & PCF_IN_PREPROC) != 0; |
| |
| if (cpd.settings[UO_indent_brace_parent].b) |
| { |
| parent_token_indent = token_indent(pc->parent_type); |
| } |
| |
| /* Clean up after a #define */ |
| if (!in_preproc) |
| { |
| while ((frm.pse_tos > 0) && frm.pse[frm.pse_tos].in_preproc) |
| { |
| indent_pse_pop(frm, pc); |
| } |
| } |
| else |
| { |
| pf_check(&frm, pc); |
| |
| if (!was_preproc) |
| { |
| /* Transition into a preproc by creating a dummy indent */ |
| frm.level++; |
| indent_pse_push(frm, pc); |
| |
| frm.pse[frm.pse_tos].indent = 1 + indent_size; |
| frm.pse[frm.pse_tos].indent_tmp = frm.pse[frm.pse_tos].indent; |
| } |
| } |
| |
| if ((cout_col > 0) && |
| (chunk_is_semicolon(pc) || |
| (pc->level < cout_level))) |
| { |
| cout_col = 0; |
| cout_level = 0; |
| } |
| |
| /** |
| * Handle non-brace closures |
| */ |
| |
| int old_pse_tos; |
| do |
| { |
| old_pse_tos = frm.pse_tos; |
| |
| /* End anything that drops a level |
| * REVISIT: not sure about the preproc check |
| */ |
| if (!chunk_is_newline(pc) && |
| !chunk_is_comment(pc) && |
| ((pc->flags & PCF_IN_PREPROC) == 0) && |
| (frm.pse[frm.pse_tos].level > pc->level)) |
| { |
| indent_pse_pop(frm, pc); |
| } |
| |
| if (frm.pse[frm.pse_tos].level == pc->level) |
| { |
| /* process virtual braces closes (no text output) */ |
| if ((pc->type == CT_VBRACE_CLOSE) && |
| (frm.pse[frm.pse_tos].type == CT_VBRACE_OPEN)) |
| { |
| indent_pse_pop(frm, pc); |
| frm.level--; |
| pc = chunk_get_next(pc); |
| } |
| |
| /* End any assign operations with a semicolon on the same level */ |
| if ((frm.pse[frm.pse_tos].type == CT_ASSIGN) && |
| (chunk_is_semicolon(pc) || |
| (pc->type == CT_COMMA) || |
| (pc->type == CT_BRACE_OPEN))) |
| { |
| indent_pse_pop(frm, pc); |
| } |
| |
| /* End any CPP class colon crap */ |
| if ((frm.pse[frm.pse_tos].type == CT_CLASS_COLON) && |
| ((pc->type == CT_BRACE_OPEN) || |
| chunk_is_semicolon(pc))) |
| { |
| indent_pse_pop(frm, pc); |
| } |
| |
| /* a case is ended with another case or a close brace */ |
| if ((frm.pse[frm.pse_tos].type == CT_CASE) && |
| ((pc->type == CT_BRACE_CLOSE) || |
| (pc->type == CT_CASE))) |
| { |
| indent_pse_pop(frm, pc); |
| } |
| |
| /* a return is ended with a semicolon */ |
| if ((frm.pse[frm.pse_tos].type == CT_RETURN) && |
| chunk_is_semicolon(pc)) |
| { |
| indent_pse_pop(frm, pc); |
| } |
| |
| /* Close out parens and squares */ |
| if ((frm.pse[frm.pse_tos].type == (pc->type - 1)) && |
| ((pc->type == CT_PAREN_CLOSE) || |
| (pc->type == CT_SPAREN_CLOSE) || |
| (pc->type == CT_FPAREN_CLOSE) || |
| (pc->type == CT_SQUARE_CLOSE) || |
| (pc->type == CT_ANGLE_CLOSE))) |
| { |
| indent_pse_pop(frm, pc); |
| frm.paren_count--; |
| } |
| } |
| } while (old_pse_tos > frm.pse_tos); |
| |
| /* Grab a copy of the current indent */ |
| indent_column = frm.pse[frm.pse_tos].indent_tmp; |
| |
| if (!chunk_is_newline(pc) && !chunk_is_comment(pc)) |
| { |
| LOG_FMT(LINDPC, " -=[ %.*s ]=- top=%d %s %d/%d\n", |
| pc->len, pc->str, |
| frm.pse_tos, |
| get_token_name(frm.pse[frm.pse_tos].type), |
| frm.pse[frm.pse_tos].indent_tmp, |
| frm.pse[frm.pse_tos].indent); |
| } |
| |
| /** |
| * Handle stuff that can affect the current indent: |
| * - brace close |
| * - vbrace open |
| * - brace open |
| * - case (immediate) |
| * - labels (immediate) |
| * - class colons (immediate) |
| * |
| * And some stuff that can't |
| * - open paren |
| * - open square |
| * - assignment |
| * - return |
| */ |
| |
| if (pc->type == CT_BRACE_CLOSE) |
| { |
| if (frm.pse[frm.pse_tos].type == CT_BRACE_OPEN) |
| { |
| indent_pse_pop(frm, pc); |
| frm.level--; |
| |
| /* Update the indent_column if needed */ |
| if (!cpd.settings[UO_indent_braces].b && |
| (parent_token_indent == 0)) |
| { |
| indent_column = frm.pse[frm.pse_tos].indent_tmp; |
| } |
| |
| if ((pc->parent_type == CT_IF) || |
| (pc->parent_type == CT_ELSE) || |
| (pc->parent_type == CT_ELSEIF) || |
| (pc->parent_type == CT_DO) || |
| (pc->parent_type == CT_WHILE) || |
| (pc->parent_type == CT_SWITCH) || |
| (pc->parent_type == CT_FOR)) |
| { |
| indent_column += cpd.settings[UO_indent_brace].n; |
| } |
| } |
| } |
| else if (pc->type == CT_VBRACE_OPEN) |
| { |
| frm.level++; |
| indent_pse_push(frm, pc); |
| |
| frm.pse[frm.pse_tos].indent = frm.pse[frm.pse_tos - 1].indent + indent_size; |
| frm.pse[frm.pse_tos].indent_tmp = frm.pse[frm.pse_tos].indent; |
| |
| /* Always indent on virtual braces */ |
| indent_column = frm.pse[frm.pse_tos].indent_tmp; |
| } |
| else if (pc->type == CT_BRACE_OPEN) |
| { |
| frm.level++; |
| indent_pse_push(frm, pc); |
| |
| if (frm.paren_count != 0) |
| { |
| /* We are inside ({ ... }) -- indent one tab from the paren */ |
| frm.pse[frm.pse_tos].indent = frm.pse[frm.pse_tos - 1].indent_tmp + indent_size; |
| } |
| else |
| { |
| /* Use the prev indent level + indent_size. */ |
| frm.pse[frm.pse_tos].indent = frm.pse[frm.pse_tos - 1].indent + indent_size; |
| |
| /* If this brace is part of a statement, bump it out by indent_brace */ |
| if ((pc->parent_type == CT_IF) || |
| (pc->parent_type == CT_ELSE) || |
| (pc->parent_type == CT_ELSEIF) || |
| (pc->parent_type == CT_DO) || |
| (pc->parent_type == CT_WHILE) || |
| (pc->parent_type == CT_SWITCH) || |
| (pc->parent_type == CT_FOR)) |
| { |
| if (parent_token_indent != 0) |
| { |
| frm.pse[frm.pse_tos].indent += parent_token_indent - indent_size; |
| } |
| else |
| { |
| frm.pse[frm.pse_tos].indent += cpd.settings[UO_indent_brace].n; |
| indent_column += cpd.settings[UO_indent_brace].n; |
| } |
| } |
| else if (pc->parent_type == CT_CASE) |
| { |
| /* The indent_case_brace setting affects the parent CT_CASE */ |
| frm.pse[frm.pse_tos].indent_tmp += cpd.settings[UO_indent_case_brace].n; |
| frm.pse[frm.pse_tos].indent += cpd.settings[UO_indent_case_brace].n; |
| } |
| else if ((pc->parent_type == CT_CLASS) && !cpd.settings[UO_indent_class].b) |
| { |
| frm.pse[frm.pse_tos].indent -= indent_size; |
| } |
| else if ((pc->parent_type == CT_NAMESPACE) && !cpd.settings[UO_indent_namespace].b) |
| { |
| frm.pse[frm.pse_tos].indent -= indent_size; |
| } |
| } |
| |
| if ((pc->flags & PCF_DONT_INDENT) != 0) |
| { |
| frm.pse[frm.pse_tos].indent = pc->column; |
| indent_column = pc->column; |
| } |
| else |
| { |
| /** |
| * If there isn't a newline between the open brace and the next |
| * item, just indent to wherever the next token is. |
| * This covers this sort of stuff: |
| * { a++; |
| * b--; }; |
| */ |
| next = chunk_get_next_ncnl(pc); |
| if (!chunk_is_newline_between(pc, next)) |
| { |
| frm.pse[frm.pse_tos].indent = next->column; |
| } |
| frm.pse[frm.pse_tos].indent_tmp = frm.pse[frm.pse_tos].indent; |
| frm.pse[frm.pse_tos].open_line = pc->orig_line; |
| |
| /* Update the indent_column if needed */ |
| if (cpd.settings[UO_indent_braces].n || |
| (parent_token_indent != 0)) |
| { |
| indent_column = frm.pse[frm.pse_tos].indent_tmp; |
| } |
| } |
| } |
| else if (pc->type == CT_CASE) |
| { |
| /* Start a case - indent UO_indent_switch_case from the switch level */ |
| tmp = frm.pse[frm.pse_tos].indent + cpd.settings[UO_indent_switch_case].n; |
| |
| indent_pse_push(frm, pc); |
| |
| frm.pse[frm.pse_tos].indent = tmp; |
| frm.pse[frm.pse_tos].indent_tmp = tmp - indent_size; |
| |
| /* Always set on case statements */ |
| indent_column = frm.pse[frm.pse_tos].indent_tmp; |
| } |
| else if (pc->type == CT_LABEL) |
| { |
| /* Labels get sent to the left or backed up */ |
| if (cpd.settings[UO_indent_label].n > 0) |
| { |
| indent_column = cpd.settings[UO_indent_label].n; |
| } |
| else |
| { |
| indent_column = frm.pse[frm.pse_tos].indent + |
| cpd.settings[UO_indent_label].n; |
| } |
| } |
| else if (pc->type == CT_CLASS_COLON) |
| { |
| /* just indent one level */ |
| indent_pse_push(frm, pc); |
| frm.pse[frm.pse_tos].indent = frm.pse[frm.pse_tos - 1].indent_tmp + indent_size; |
| frm.pse[frm.pse_tos].indent_tmp = frm.pse[frm.pse_tos].indent; |
| |
| indent_column = frm.pse[frm.pse_tos].indent_tmp; |
| |
| if (cpd.settings[UO_indent_class_colon].b) |
| { |
| prev = chunk_get_prev(pc); |
| if (chunk_is_newline(prev)) |
| { |
| frm.pse[frm.pse_tos].indent += 2; |
| /* don't change indent of current line */ |
| } |
| } |
| } |
| else if ((pc->type == CT_PAREN_OPEN) || |
| (pc->type == CT_SPAREN_OPEN) || |
| (pc->type == CT_FPAREN_OPEN) || |
| (pc->type == CT_SQUARE_OPEN) || |
| (pc->type == CT_ANGLE_OPEN)) |
| { |
| /* Open parens and squares - never update indent_column */ |
| indent_pse_push(frm, pc); |
| frm.pse[frm.pse_tos].indent = pc->column + pc->len; |
| |
| if (cpd.settings[UO_indent_func_call_param].b && |
| (pc->type == CT_FPAREN_OPEN) && |
| (pc->parent_type == CT_FUNC_CALL)) |
| { |
| frm.pse[frm.pse_tos].indent = frm.pse[frm.pse_tos - 1].indent + indent_size; |
| } |
| |
| if ((chunk_is_str(pc, "(", 1) && !cpd.settings[UO_indent_paren_nl].b) || |
| (chunk_is_str(pc, "[", 1) && !cpd.settings[UO_indent_square_nl].b)) |
| { |
| next = chunk_get_next_nc(pc); |
| if (chunk_is_newline(next)) |
| { |
| int sub = 1; |
| if (frm.pse[frm.pse_tos - 1].type == CT_ASSIGN) |
| { |
| sub = 2; |
| } |
| frm.pse[frm.pse_tos].indent = frm.pse[frm.pse_tos - sub].indent + indent_size; |
| } |
| } |
| frm.pse[frm.pse_tos].indent_tmp = frm.pse[frm.pse_tos].indent; |
| frm.paren_count++; |
| } |
| else if (pc->type == CT_ASSIGN) |
| { |
| /** |
| * if there is a newline after the '=', just indent one level, |
| * otherwise align on the '='. |
| * Never update indent_column. |
| */ |
| next = chunk_get_next(pc); |
| if (next != NULL) |
| { |
| indent_pse_push(frm, pc); |
| if (chunk_is_newline(next)) |
| { |
| frm.pse[frm.pse_tos].indent = frm.pse[frm.pse_tos - 1].indent_tmp + indent_size; |
| } |
| else |
| { |
| frm.pse[frm.pse_tos].indent = pc->column + pc->len + 1; |
| } |
| frm.pse[frm.pse_tos].indent_tmp = frm.pse[frm.pse_tos].indent; |
| } |
| } |
| else if (pc->type == CT_RETURN) |
| { |
| /* don't count returns inside a () or [] */ |
| if (pc->level == pc->brace_level) |
| { |
| indent_pse_push(frm, pc); |
| frm.pse[frm.pse_tos].indent = frm.pse[frm.pse_tos - 1].indent + pc->len + 1; |
| frm.pse[frm.pse_tos].indent_tmp = frm.pse[frm.pse_tos - 1].indent; |
| } |
| } |
| else if (chunk_is_str(pc, "<<", 2)) |
| { |
| if (cout_col == 0) |
| { |
| cout_col = pc->column; |
| cout_level = pc->level; |
| } |
| } |
| else |
| { |
| /* anything else? */ |
| } |
| |
| |
| /** |
| * Indent the line if needed |
| */ |
| if (did_newline && !chunk_is_newline(pc) && (pc->len != 0)) |
| { |
| /** |
| * Check for special continuations. |
| * Note that some of these could be done as a stack item like |
| * everything else |
| */ |
| |
| prev = chunk_get_prev_ncnl(pc); |
| if ((pc->type == CT_MEMBER) || |
| (pc->type == CT_DC_MEMBER) || |
| ((prev != NULL) && |
| ((prev->type == CT_MEMBER) || |
| (prev->type == CT_DC_MEMBER)))) |
| { |
| tmp = cpd.settings[UO_indent_member].n + indent_column; |
| LOG_FMT(LINDENT, "%s: %d] member => %d\n", |
| __func__, pc->orig_line, tmp); |
| reindent_line(pc, tmp); |
| } |
| else if (chunk_is_str(pc, "<<", 2) && (cout_col > 0)) |
| { |
| LOG_FMT(LINDENT, "%s: %d] cout_col => %d\n", |
| __func__, pc->orig_line, cout_col); |
| reindent_line(pc, cout_col); |
| } |
| else if ((vardefcol > 0) && |
| (pc->type == CT_WORD) && |
| ((pc->flags & PCF_VAR_DEF) != 0) && |
| (prev != NULL) && (prev->type == CT_COMMA)) |
| { |
| LOG_FMT(LINDENT, "%s: %d] Vardefcol => %d\n", |
| __func__, pc->orig_line, vardefcol); |
| reindent_line(pc, vardefcol); |
| } |
| else if ((pc->type == CT_STRING) && (prev->type == CT_STRING) && |
| cpd.settings[UO_indent_align_string].b) |
| { |
| LOG_FMT(LINDENT, "%s: %d] String => %d\n", |
| __func__, pc->orig_line, prev->column); |
| reindent_line(pc, prev->column); |
| } |
| else if (chunk_is_comment(pc)) |
| { |
| LOG_FMT(LINDENT, "%s: %d] comment => %d\n", |
| __func__, pc->orig_line, frm.pse[frm.pse_tos].indent_tmp); |
| indent_comment(pc, frm.pse[frm.pse_tos].indent_tmp); |
| } |
| else if (pc->type == CT_PREPROC) |
| { |
| /* Preprocs are always in column 1. See indent_preproc() */ |
| if (pc->column != 1) |
| { |
| reindent_line(pc, 1); |
| } |
| } |
| else |
| { |
| if (pc->column != indent_column) |
| { |
| LOG_FMT(LINDENT, "%s: %d] indent => %d [%.*s]\n", |
| __func__, pc->orig_line, indent_column, pc->len, pc->str); |
| reindent_line(pc, indent_column); |
| } |
| } |
| did_newline = false; |
| } |
| |
| /** |
| * Handle variable definition continuation indenting |
| */ |
| if ((pc->type == CT_WORD) && |
| ((pc->flags & PCF_IN_FCN_DEF) == 0) && |
| ((pc->flags & PCF_VAR_1ST_DEF) == PCF_VAR_1ST_DEF)) |
| { |
| vardefcol = pc->column; |
| } |
| if (chunk_is_semicolon(pc) || |
| ((pc->type == CT_BRACE_OPEN) && (pc->parent_type == CT_FUNCTION))) |
| { |
| vardefcol = 0; |
| } |
| |
| /* if we hit a newline, reset indent_tmp */ |
| if (chunk_is_newline(pc) || |
| (pc->type == CT_COMMENT_MULTI) || |
| (pc->type == CT_COMMENT_CPP)) |
| { |
| frm.pse[frm.pse_tos].indent_tmp = frm.pse[frm.pse_tos].indent; |
| |
| /** |
| * Handle the case of a multi-line #define w/o anything on the |
| * first line (indent_tmp will be 1 or 0) |
| */ |
| if ((pc->type == CT_NL_CONT) && |
| (frm.pse[frm.pse_tos].indent_tmp <= indent_size)) |
| { |
| frm.pse[frm.pse_tos].indent_tmp = indent_size + 1; |
| } |
| |
| /* Get ready to indent the next item */ |
| did_newline = true; |
| } |
| |
| if (!chunk_is_comment(pc) && !chunk_is_newline(pc)) |
| { |
| prev = pc; |
| } |
| pc = chunk_get_next(pc); |
| } |
| |
| /* Throw out any stuff inside a preprocessor - no need to warn */ |
| while ((frm.pse_tos > 0) && frm.pse[frm.pse_tos].in_preproc) |
| { |
| indent_pse_pop(frm, pc); |
| } |
| |
| for (idx = 1; idx <= frm.pse_tos; idx++) |
| { |
| LOG_FMT(LWARN, "%s:%d Unmatched %s\n", |
| cpd.filename, frm.pse[idx].open_line, |
| get_token_name(frm.pse[idx].type)); |
| cpd.error_count++; |
| } |
| } |
| |
| /** |
| * returns true if forward scan reveals only single newlines or comments |
| * stops when hits code |
| * false if next thing hit is a closing brace, also if 2 newlines in a row |
| */ |
| |
| |
| static bool single_line_comment_indent_rule_applies(chunk_t *start) |
| { |
| chunk_t *pc = start; |
| int nl_count = 0; |
| if (!chunk_is_single_line_comment(pc)) |
| { |
| return(false); |
| } |
| /* scan forward, if only single newlines and comments before next line of code, we want to apply */ |
| while ((pc = chunk_get_next(pc)) != NULL) |
| { |
| if (chunk_is_newline(pc)) |
| { |
| if (nl_count > 0 || pc->nl_count > 1) |
| { |
| return(false); |
| } |
| |
| nl_count++; |
| } |
| else |
| { |
| nl_count = 0; |
| if (!chunk_is_single_line_comment(pc)) |
| { |
| /* here we check for things to run into that we wouldn't want to indent the comment for */ |
| /* for example, non-single line comment, closing brace */ |
| if (chunk_is_comment(pc) || chunk_is_closing_brace(pc)) |
| { |
| return(false); |
| } |
| |
| return(true); |
| } |
| } |
| } |
| |
| return(false); |
| } |
| |
| /** |
| * REVISIT: This needs to be re-checked, maybe cleaned up |
| * |
| * Indents comments in a (hopefully) smart manner. |
| * |
| * There are two type of comments that get indented: |
| * - stand alone (ie, no tokens on the line before the comment) |
| * - trailing comments (last token on the line apart from a linefeed) |
| * + note that a stand-alone comment is a special case of a trailing |
| * |
| * The stand alone comments will get indented in one of three ways: |
| * - column 1: |
| * + There is an empty line before the comment AND the indent level is 0 |
| * + The comment was originally in column 1 |
| * |
| * - Same column as trailing comment on previous line (ie, aligned) |
| * + if originally within TBD (3) columns of the previous comment |
| * |
| * - syntax indent level |
| * + doesn't fit in the previous categories |
| * |
| * Options modify this behavior: |
| * - keep original column (don't move the comment, if possible) |
| * - keep relative column (move out the same amount as first item on line) |
| * - fix trailing comment in column TBD |
| * |
| * @param pc The comment, which is the first item on a line |
| * @param col The column if this is to be put at indent level |
| */ |
| static void indent_comment(chunk_t *pc, int col) |
| { |
| chunk_t *nl; |
| chunk_t *prev; |
| |
| LOG_FMT(LCMTIND, "%s: line %d, col %d, level %d: ", __func__, |
| pc->orig_line, pc->orig_col, pc->level); |
| |
| /* force column 1 comment to column 1 if not changing them */ |
| if ((pc->orig_col == 1) && !cpd.settings[UO_indent_col1_comment].b) |
| { |
| LOG_FMT(LCMTIND, "rule 1 - keep in col 1\n"); |
| pc->column = 1; |
| return; |
| } |
| |
| nl = chunk_get_prev(pc); |
| |
| /* outside of any expression or statement? */ |
| if (pc->level == 0) |
| { |
| if ((nl != NULL) && (nl->nl_count > 1)) |
| { |
| LOG_FMT(LCMTIND, "rule 2 - level 0, nl before\n"); |
| pc->column = 1; |
| return; |
| } |
| } |
| |
| prev = chunk_get_prev(nl); |
| if (chunk_is_comment(prev) && (nl->nl_count == 1)) |
| { |
| int coldiff = prev->orig_col - pc->orig_col; |
| |
| if ((coldiff <= 3) && (coldiff >= -3)) |
| { |
| pc->column = prev->column; |
| LOG_FMT(LCMTIND, "rule 3 - prev comment, coldiff = %d, now in %d\n", |
| coldiff, pc->column); |
| return; |
| } |
| } |
| /* check if special single line comment rule applies */ |
| if (cpd.settings[UO_indent_sing_line_comments].n > 0 && single_line_comment_indent_rule_applies(pc)) |
| { |
| pc->column = col + cpd.settings[UO_indent_sing_line_comments].n; |
| LOG_FMT(LCMTIND, "rule 4 - single line comment indent, now in %d\n", pc->column); |
| return; |
| } |
| LOG_FMT(LCMTIND, "rule 5 - fall-through, stay in %d\n", col); |
| |
| pc->column = col; |
| } |
| |
| |
| /** |
| * Put spaces on either side of the preproc (#) symbol. |
| * This is done by pointing pc->str into pp_str and adjusting the |
| * length. |
| */ |
| void indent_preproc(void) |
| { |
| chunk_t *pc; |
| chunk_t *next; |
| int pp_level; |
| int pp_level_sub = 0; |
| int tmp; |
| |
| /* Define a string of 16 spaces + # + 16 spaces */ |
| static const char *pp_str = " # "; |
| static const char *alt_str = " %: "; |
| |
| /* Scan to see if the whole file is covered by one #ifdef */ |
| int stage = 0; |
| |
| for (pc = chunk_get_head(); pc != NULL; pc = chunk_get_next(pc)) |
| { |
| if (chunk_is_comment(pc) || chunk_is_newline(pc)) |
| { |
| continue; |
| } |
| |
| if (stage == 0) |
| { |
| /* Check the first PP, make sure it is an #if type */ |
| if (pc->type != CT_PREPROC) |
| { |
| break; |
| } |
| next = chunk_get_next(pc); |
| if ((next == NULL) || (next->type != CT_PP_IF)) |
| { |
| break; |
| } |
| stage = 1; |
| } |
| else if (stage == 1) |
| { |
| /* Scan until a PP at level 0 is found - the close to the #if */ |
| if ((pc->type == CT_PREPROC) && |
| (pc->pp_level == 0)) |
| { |
| stage = 2; |
| } |
| continue; |
| } |
| else if (stage == 2) |
| { |
| /* We should only see the rest of the preprocessor */ |
| if ((pc->type == CT_PREPROC) || |
| ((pc->flags & PCF_IN_PREPROC) == 0)) |
| { |
| stage = 0; |
| break; |
| } |
| } |
| } |
| |
| if (stage == 2) |
| { |
| LOG_FMT(LINFO, "The whole file is covered by a #IF\n"); |
| pp_level_sub = 1; |
| } |
| |
| for (pc = chunk_get_head(); pc != NULL; pc = chunk_get_next(pc)) |
| { |
| if (pc->type != CT_PREPROC) |
| { |
| continue; |
| } |
| |
| if (pc->column != 1) |
| { |
| /* Don't handle preprocessors that aren't in column 1 */ |
| LOG_FMT(LINFO, "%s: Line %d doesn't start in column 1 (%d)\n", |
| __func__, pc->orig_line, pc->column); |
| continue; |
| } |
| |
| /* point into pp_str */ |
| if (pc->len == 2) |
| { |
| /* alternate token crap */ |
| pc->str = &alt_str[16]; |
| } |
| else |
| { |
| pc->str = &pp_str[16]; |
| } |
| |
| pp_level = pc->pp_level - pp_level_sub; |
| if (pp_level < 0) |
| { |
| pp_level = 0; |
| } |
| else if (pp_level > 16) |
| { |
| pp_level = 16; |
| } |
| |
| /* Note that the indent is removed by default */ |
| if ((cpd.settings[UO_pp_indent].a & AV_ADD) != 0) |
| { |
| /* Need to add some spaces */ |
| pc->str -= pp_level; |
| pc->len += pp_level; |
| } |
| else if (cpd.settings[UO_pp_indent].a == AV_IGNORE) |
| { |
| tmp = (pc->orig_col <= 16) ? pc->orig_col - 1 : 16; |
| pc->str -= tmp; |
| pc->len += tmp; |
| } |
| |
| /* Add spacing by adjusting the length */ |
| if ((cpd.settings[UO_pp_space].a & AV_ADD) != 0) |
| { |
| pc->len += pp_level; |
| } |
| |
| next = chunk_get_next(pc); |
| if (next != NULL) |
| { |
| reindent_line(next, pc->len + 1); |
| } |
| |
| LOG_FMT(LPPIS, "%s: Indent line %d to %d (len %d, next->col %d)\n", |
| __func__, pc->orig_line, pp_level, pc->len, next->column); |
| } |
| } |
