static void add_file_header() { if (!chunk_is_comment(chunk_get_head())) { /*TODO: detect the typical #ifndef FOO / #define FOO sequence */ tokenize(cpd.file_hdr.data, chunk_get_head()); } }
void do_parens(void) { LOG_FUNC_ENTRY(); if (cpd.settings[UO_mod_full_paren_if_bool].b) { chunk_t *pc = chunk_get_head(); while ((pc = chunk_get_next_ncnl(pc)) != nullptr) { if ( pc->type != CT_SPAREN_OPEN || ( pc->parent_type != CT_IF && pc->parent_type != CT_ELSEIF && pc->parent_type != CT_SWITCH)) { continue; } // Grab the close sparen chunk_t *pclose = chunk_get_next_type(pc, CT_SPAREN_CLOSE, pc->level, scope_e::PREPROC); if (pclose != nullptr) { check_bool_parens(pc, pclose, 0); pc = pclose; } } } }
/** * Turns certain virtual semicolons invisible. * - after a close brace with a parent of switch, case, else, if */ void pawn_scrub_vsemi(void) { if (!cpd.settings[UO_mod_pawn_semicolon].b) { return; } chunk_t *pc; chunk_t *prev; for (pc = chunk_get_head(); pc != NULL; pc = chunk_get_next(pc)) { if (pc->type != CT_VSEMICOLON) { continue; } prev = chunk_get_prev_ncnl(pc); if ((prev != NULL) && (prev->type == CT_BRACE_CLOSE)) { if ((prev->parent_type == CT_IF) || (prev->parent_type == CT_ELSE) || (prev->parent_type == CT_SWITCH) || (prev->parent_type == CT_CASE) || (prev->parent_type == CT_WHILE_OF_DO)) { pc->str.clear(); } } } }
static void mod_case_brace(void) { LOG_FUNC_ENTRY(); chunk_t *pc = chunk_get_head(); while (pc != NULL) { chunk_t *next = chunk_get_next_ncnl(pc, CNAV_PREPROC); if (next == NULL) { return; } if ((cpd.settings[UO_mod_case_brace].a == AV_REMOVE) && (pc->type == CT_BRACE_OPEN) && (pc->parent_type == CT_CASE)) { pc = mod_case_brace_remove(pc); } else if ((cpd.settings[UO_mod_case_brace].a & AV_ADD) && (pc->type == CT_CASE_COLON) && (next->type != CT_BRACE_OPEN) && (next->type != CT_BRACE_CLOSE) && (next->type != CT_CASE)) { pc = mod_case_brace_add(pc); } else { pc = chunk_get_next_ncnl(pc, CNAV_PREPROC); } } }
/** * Does a scan of level 0 BEFORE stuff in combine.cpp is called. * At this point, VSemis have been added only in VBraces. * Otherwise, all level info is correct, except for unbraced functions. * * We are looking for unbraced functions. */ void pawn_prescan(void) { /* Start at the beginning and step through the entire file, and clean up * any questionable stuff */ chunk_t *pc; bool did_nl = true; pc = chunk_get_head(); while (pc != NULL) { if (did_nl && (pc->type != CT_PREPROC) && !chunk_is_newline(pc) && (pc->level == 0)) { /* pc now points to the start of a line */ pc = pawn_process_line(pc); } /* note that continued lines are ignored */ if (pc != NULL) { did_nl = (pc->type == CT_NEWLINE); } pc = chunk_get_next_nc(pc); } }
void do_parens(void) { LOG_FUNC_ENTRY(); chunk_t *pc; chunk_t *pclose; if (cpd.settings[UO_mod_full_paren_if_bool].b) { pc = chunk_get_head(); while ((pc = chunk_get_next_ncnl(pc)) != NULL) { if ((pc->type != CT_SPAREN_OPEN) || ((pc->parent_type != CT_IF) && (pc->parent_type != CT_ELSEIF) && (pc->parent_type != CT_SWITCH))) { continue; } /* Grab the close sparen */ pclose = chunk_get_next_type(pc, CT_SPAREN_CLOSE, pc->level, CNAV_PREPROC); if (pclose != NULL) { check_bool_parens(pc, pclose, 0); pc = pclose; } } } }
void quick_align_again(void) { chunk_t *pc; chunk_t *tmp; AlignStack as; LOG_FMT(LALAGAIN, "%s:\n", __func__); for (pc = chunk_get_head(); pc != NULL; pc = chunk_get_next(pc)) { if ((pc->align.next != NULL) && (pc->flags & PCF_ALIGN_START)) { as.Start(100, 0); as.m_right_align = pc->align.right_align; as.m_star_style = (AlignStack::StarStyle)pc->align.star_style; as.m_amp_style = (AlignStack::StarStyle)pc->align.amp_style; as.m_gap = pc->align.gap; LOG_FMT(LALAGAIN, " [%.*s:%d]", pc->len, pc->str, pc->orig_line); as.Add(pc->align.start); pc->flags |= PCF_WAS_ALIGNED; for (tmp = pc->align.next; tmp != NULL; tmp = tmp->align.next) { tmp->flags |= PCF_WAS_ALIGNED; as.Add(tmp->align.start); LOG_FMT(LALAGAIN, " => [%.*s:%d]", tmp->len, tmp->str, tmp->orig_line); } LOG_FMT(LALAGAIN, "\n"); as.End(); } } }
void output_parsed(FILE *pfile) { chunk_t *pc; int cnt; output_options(pfile); output_defines(pfile); output_types(pfile); fprintf(pfile, "-=====-\n"); fprintf(pfile, "Line Tag Parent Columns Br/Lvl/pp Flg Nl Text"); for (pc = chunk_get_head(); pc != NULL; pc = chunk_get_next(pc)) { fprintf(pfile, "\n%3d> %13.13s[%13.13s][%2d/%2d/%2d][%d/%d/%d][%6x][%d-%d]", pc->orig_line, get_token_name(pc->type), get_token_name(pc->parent_type), pc->column, pc->orig_col, pc->orig_col_end, pc->brace_level, pc->level, pc->pp_level, pc->flags, pc->nl_count, pc->after_tab); if ((pc->type != CT_NEWLINE) && (pc->len != 0)) { for (cnt = 0; cnt < pc->column; cnt++) { fprintf(pfile, " "); } fprintf(pfile, "%.*s", pc->len, pc->str); } } fprintf(pfile, "\n-=====-\n"); fflush(pfile); }
void do_code_width(void) { LOG_FUNC_ENTRY(); LOG_FMT(LSPLIT, "%s(%d)\n", __func__, __LINE__); for (chunk_t *pc = chunk_get_head(); pc != nullptr; pc = chunk_get_next(pc)) { if ( !chunk_is_newline(pc) && !chunk_is_comment(pc) && pc->type != CT_SPACE && is_past_width(pc)) { if ( pc->type == CT_VBRACE_CLOSE // don't break if a vbrace close && chunk_is_last_on_line(*pc)) // is the last chunk on its line { continue; } bool split_OK = split_line(pc); if (split_OK) { LOG_FMT(LSPLIT, "%s(%d): on orig_line=%zu, orig_col=%zu, for %s\n", __func__, __LINE__, pc->orig_line, pc->orig_col, pc->text()); } else { LOG_FMT(LSPLIT, "%s(%d): Bailed on orig_line=%zu, orig_col=%zu, for %s\n", __func__, __LINE__, pc->orig_line, pc->orig_col, pc->text()); break; } } } }
static void uncrustify_end() { /* Free all the memory */ chunk_t *pc; while ((pc = chunk_get_head()) != NULL) { chunk_del(pc); } if (cpd.bom != NULL) { chunk_del(cpd.bom); cpd.bom = NULL; } /* Clean up some state variables */ cpd.unc_off = false; cpd.al_cnt = 0; cpd.did_newline = true; cpd.frame_count = 0; cpd.pp_level = 0; cpd.changes = 0; cpd.in_preproc = CT_NONE; cpd.consumed = false; memset(cpd.le_counts, 0, sizeof(cpd.le_counts)); cpd.preproc_ncnl_count = 0; }
/** * Removes superfluous semicolons: * - after brace close whose parent is IF, ELSE, SWITCH, WHILE, FOR, NAMESPACE * - after another semicolon where parent is not FOR * - (D) after brace close whose parent is ENUM/STRUCT/UNION * - after an open brace * - when not in a #DEFINE */ void remove_extra_semicolons(void) { chunk_t *pc; chunk_t *next; chunk_t *prev; pc = chunk_get_head(); while (pc != NULL) { next = chunk_get_next_ncnl(pc); if ((pc->type == CT_SEMICOLON) && !(pc->flags & PCF_IN_PREPROC) && ((prev = chunk_get_prev_ncnl(pc)) != NULL)) { LOG_FMT(LSCANSEMI, "Semi on %d:%d, prev = '%s' [%s/%s]\n", pc->orig_line, pc->orig_col, prev->str.c_str(), get_token_name(prev->type), get_token_name(prev->parent_type)); if ((prev->type == CT_BRACE_CLOSE) && ((prev->parent_type == CT_IF) || (prev->parent_type == CT_ELSEIF) || (prev->parent_type == CT_ELSE) || (prev->parent_type == CT_SWITCH) || (prev->parent_type == CT_WHILE) || (prev->parent_type == CT_USING_STMT) || (prev->parent_type == CT_FOR) || (prev->parent_type == CT_FUNC_DEF) || (prev->parent_type == CT_OC_MSG_DECL) || (prev->parent_type == CT_FUNC_CLASS) || (prev->parent_type == CT_NAMESPACE))) { remove_semicolon(pc); } else if ((prev->type == CT_BRACE_CLOSE) && (prev->parent_type == CT_NONE)) { check_unknown_brace_close(pc, prev); } else if ((prev->type == CT_SEMICOLON) && (prev->parent_type != CT_FOR)) { remove_semicolon(pc); } else if ((cpd.lang_flags & LANG_D) && ((prev->parent_type == CT_ENUM) || (prev->parent_type == CT_UNION) || (prev->parent_type == CT_STRUCT))) { remove_semicolon(pc); } else if (prev->type == CT_BRACE_OPEN) { remove_semicolon(pc); } } pc = next; } }
void examine_Data(const char *func_name, int theLine, int what) { chunk_t *pc; LOG_FMT(LGUY, "\n%s:", func_name); switch (what) { case 1: for (pc = chunk_get_head(); pc != NULL; pc = pc->next) { if ((pc->type == CT_SQUARE_CLOSE) || (pc->type == CT_TSQUARE)) { LOG_FMT(LGUY, "\n"); LOG_FMT(LGUY, "1:(%d),", theLine); LOG_FMT(LGUY, "%s, orig_col=%d, orig_col_end=%d\n", pc->text(), pc->orig_col, pc->orig_col_end); } } break; case 2: LOG_FMT(LGUY, "2:(%d)\n", theLine); for (pc = chunk_get_head(); pc != NULL; pc = pc->next) { if (pc->orig_line == 7) { if (pc->type == CT_NEWLINE) { LOG_FMT(LGUY, "(%d)<NL> col=%d\n\n", pc->orig_line, pc->orig_col); } else { LOG_FMT(LGUY, "(%d)%s %s, col=%d, column=%d\n", pc->orig_line, pc->text(), get_token_name(pc->type), pc->orig_col, pc->column); } } } break; case 3: LOG_FMT(LGUY, "3:(%d)\n", theLine); for (pc = chunk_get_head(); pc != NULL; pc = pc->next) { if (pc->type == CT_SEMICOLON) { if (pc->type == CT_NEWLINE) { LOG_FMT(LGUY, "(%d)<NL> col=%d\n\n", pc->orig_line, pc->orig_col); } else { LOG_FMT(LGUY, "(%d)%s %s, col=%d, column=%d\n", pc->orig_line, pc->text(), get_token_name(pc->type), pc->orig_col, pc->column); } } } break; } }
void foo(void) { List<byte> bob = new List<byte>(); /* Align assignments */ align_assign(chunk_get_head(), cpd.settings [UO_align_assign_span].n, cpd.settings [UO_align_assign_thresh].n); }
/** * Marches through the whole file and adds spaces around nested parens */ void space_text_balance_nested_parens(void) { chunk_t *first; chunk_t *next; chunk_t *cur; chunk_t *prev; first = chunk_get_head(); while (first != NULL) { next = chunk_get_next(first); if (next == NULL) { break; } if (chunk_is_str(first, "(", 1) && chunk_is_str(next, "(", 1)) { /* insert a space between the two opening parens */ space_add_after(first, 1); /* find the closing paren that matches the 'first' open paren and force * a space before it */ cur = next; prev = cur; while ((cur = chunk_get_next(cur)) != NULL) { if (cur->level == first->level) { space_add_after(prev, 1); break; } prev = cur; } } else if (chunk_is_str(first, ")", 1) && chunk_is_str(next, ")", 1)) { /* insert a space between the two closing parens */ space_add_after(first, 1); /* find the opening paren that matches the 'next' close paren and force * a space after it */ cur = first; while ((cur = chunk_get_prev(cur)) != NULL) { if (cur->level == next->level) { space_add_after(cur, 1); break; } } } first = next; } }
/** * Aligns OC messages */ static void align_oc_msg_colons() { chunk_t *pc; for (pc = chunk_get_head(); pc != NULL; pc = chunk_get_next(pc)) { if ((pc->type == CT_SQUARE_OPEN) && (pc->parent_type == CT_OC_MSG)) { align_oc_msg_colon(pc); } } }
static void mod_full_brace_if_chain(void) { LOG_FUNC_ENTRY(); for (chunk_t *pc = chunk_get_head(); pc != NULL; pc = chunk_get_next(pc)) { if (((pc->type == CT_BRACE_OPEN) || (pc->type == CT_VBRACE_OPEN)) && (pc->parent_type == CT_IF)) { process_if_chain(pc); } } }
void prot_the_line(int theLine) { chunk_t *pc; LOG_FMT(LGUY, "P:(%d) ", theLine); for (pc = chunk_get_head(); pc != NULL; pc = pc->next) { if (pc->type == CT_NEWLINE) { LOG_FMT(LGUY, "<NL>\n"); } else { LOG_FMT(LGUY, " %s", pc->text()); } } LOG_FMT(LGUY, "\n"); }
/** * Align '<<' (CT_ARITH?) */ static void align_left_shift(void) { chunk_t *pc; chunk_t *start = NULL; AlignStack as; as.Start(2); pc = chunk_get_head(); while (pc != NULL) { if (chunk_is_newline(pc)) { as.NewLines(pc->nl_count); } else if ((start != NULL) && (pc->level < start->level)) { /* A drop in level restarts the aligning */ as.Flush(); start = NULL; } else if ((start != NULL) && (pc->level > start->level)) { /* Ignore any deeper levels when aligning */ } else if (pc->type == CT_SEMICOLON) { /* A semicolon at the same level flushes */ as.Flush(); start = NULL; } else if (chunk_is_str(pc, "<<", 2)) { if (as.m_aligned.Empty()) { /* first one can be anywhere */ as.Add(pc); start = pc; } else if (chunk_is_newline(chunk_get_prev(pc))) { /* subsequent ones must be after a newline */ as.Add(pc); } } pc = chunk_get_next(pc); } as.End(); }
/** * Aligns all function prototypes in the file. */ static void align_func_proto(int span) { chunk_t *pc; bool look_bro = false; AlignStack as; AlignStack as_br; LOG_FMT(LALIGN, "%s\n", __func__); as.Start(span, 0); as.m_gap = cpd.settings[UO_align_func_proto_gap].n; as_br.Start(span, 0); as_br.m_gap = cpd.settings[UO_align_single_line_brace_gap].n; for (pc = chunk_get_head(); pc != NULL; pc = chunk_get_next(pc)) { if (chunk_is_newline(pc)) { look_bro = false; as.NewLines(pc->nl_count); as_br.NewLines(pc->nl_count); } else if ((pc->type == CT_FUNC_PROTO) || ((pc->type == CT_FUNC_DEF) && cpd.settings[UO_align_single_line_func].b)) { if ((pc->parent_type == CT_OPERATOR) && cpd.settings[UO_align_on_operator].b) { as.Add(chunk_get_prev_ncnl(pc)); } else { as.Add(pc); } look_bro = (pc->type == CT_FUNC_DEF) && cpd.settings[UO_align_single_line_brace].b; } else if (look_bro && (pc->type == CT_BRACE_OPEN) && (pc->flags & PCF_ONE_LINER)) { as_br.Add(pc); look_bro = false; } } as.End(); as_br.End(); }
/** * Aligns all backslash-newline combos in the file. * This should be done LAST. */ void align_backslash_newline(void) { chunk_t *pc; pc = chunk_get_head(); while (pc != NULL) { if (pc->type != CT_NL_CONT) { pc = chunk_get_next_type(pc, CT_NL_CONT, -1); continue; } pc = align_nl_cont(pc); } }
void align_struct_initializers(void) { LOG_FUNC_ENTRY(); chunk_t *pc = chunk_get_head(); while (pc != nullptr) { chunk_t *prev = chunk_get_prev_ncnl(pc); if ( chunk_is_token(prev, CT_ASSIGN) && ( chunk_is_token(pc, CT_BRACE_OPEN) || (language_is_set(LANG_D) && chunk_is_token(pc, CT_SQUARE_OPEN)))) { align_init_brace(pc); } pc = chunk_get_next_type(pc, CT_BRACE_OPEN, -1); } } // align_struct_initializers
/** * Step forward until a token goes beyond the limit and then call split_line() * to split the line at or before that point. */ void do_code_width(void) { chunk_t *pc; LOG_FMT(LSPLIT, "%s\n", __func__); for (pc = chunk_get_head(); pc != NULL; pc = chunk_get_next(pc)) { if (!chunk_is_newline(pc) && !chunk_is_comment(pc) && (pc->type != CT_SPACE) && is_past_width(pc)) { split_line(pc); } } }
/** * Aligns stuff inside a multi-line "= { ... }" sequence. */ void align_struct_initializers(void) { chunk_t *pc; chunk_t *prev; pc = chunk_get_head(); while (pc != NULL) { prev = chunk_get_prev_ncnl(pc); if ((prev != NULL) && (prev->type == CT_ASSIGN) && ((pc->type == CT_BRACE_OPEN) || ((cpd.lang_flags & LANG_D) && (pc->type == CT_SQUARE_OPEN)))) { align_init_brace(pc); } pc = chunk_get_next_type(pc, CT_BRACE_OPEN, -1); } }
/** * Aligns simple typedefs that are contained on a single line each. * This should be called after the typedef target is marked as a type. * * Won't align function typedefs. * * typedef int foo_t; * typedef char bar_t; * typedef const char cc_t; */ static void align_typedefs(int span) { chunk_t *pc; chunk_t *c_type = NULL; chunk_t *c_typedef = NULL; AlignStack as; as.Start(span); as.m_gap = cpd.settings[UO_align_typedef_gap].n; as.m_star_style = (AlignStack::StarStyle)cpd.settings[UO_align_typedef_star_style].n; as.m_amp_style = (AlignStack::StarStyle)cpd.settings[UO_align_typedef_amp_style].n; pc = chunk_get_head(); while (pc != NULL) { if (chunk_is_newline(pc)) { as.NewLines(pc->nl_count); c_typedef = NULL; } else if (c_typedef != NULL) { if (pc->flags & PCF_ANCHOR) { as.Add(pc); c_typedef = NULL; } } else { if (pc->type == CT_TYPEDEF) { LOG_FMT(LALTD, "%s: line %d, col %d\n", __func__, pc->orig_line, pc->orig_col); c_typedef = pc; c_type = NULL; } } pc = chunk_get_next(pc); } as.End(); }
static void align_func_params() { chunk_t *pc; pc = chunk_get_head(); while ((pc = chunk_get_next(pc)) != NULL) { if ((pc->type != CT_FPAREN_OPEN) || ((pc->parent_type != CT_FUNC_PROTO) && (pc->parent_type != CT_FUNC_DEF) && (pc->parent_type != CT_FUNC_CLASS) && (pc->parent_type != CT_TYPEDEF))) { continue; } /* We're on a open paren of a prototype */ pc = align_func_param(pc); } }
void pawn_add_virtual_semicolons(void) { LOG_FUNC_ENTRY(); chunk_t *prev; chunk_t *pc; /** Add Pawn virtual semicolons */ prev = NULL; if (cpd.lang_flags & LANG_PAWN) { pc = chunk_get_head(); while ((pc = chunk_get_next(pc)) != NULL) { if (!chunk_is_comment(pc) && !chunk_is_newline(pc) && (pc->type != CT_VBRACE_CLOSE) && (pc->type != CT_VBRACE_OPEN)) { prev = pc; } if ((prev == NULL) || ((pc->type != CT_NEWLINE) && (pc->type != CT_BRACE_CLOSE) && (pc->type != CT_VBRACE_CLOSE))) { continue; } /* we just hit a newline and we have a previous token */ if (((prev->flags & PCF_IN_PREPROC) == 0) && ((prev->flags & (PCF_IN_ENUM | PCF_IN_STRUCT)) == 0) && (prev->type != CT_VSEMICOLON) && (prev->type != CT_SEMICOLON) && !pawn_continued(prev, prev->brace_level)) { pawn_add_vsemi_after(prev); prev = NULL; } } } }
static void move_case_break(void) { LOG_FUNC_ENTRY(); chunk_t *prev = NULL; for (chunk_t *pc = chunk_get_head(); pc != NULL; pc = chunk_get_next_ncnl(pc)) { if ((pc->type == CT_BREAK) && (prev != NULL) && (prev->type == CT_BRACE_CLOSE) && (prev->parent_type == CT_CASE)) { if (chunk_is_newline(chunk_get_prev(pc)) && chunk_is_newline(chunk_get_prev(prev))) { chunk_swap_lines(prev, pc); } } prev = pc; } }
/** * Aligns all function prototypes in the file. */ static void align_oc_msg_spec(int span) { chunk_t *pc; AlignStack as; LOG_FMT(LALIGN, "%s\n", __func__); as.Start(span, 0); for (pc = chunk_get_head(); pc != NULL; pc = chunk_get_next(pc)) { if (chunk_is_newline(pc)) { as.NewLines(pc->nl_count); } else if (pc->type == CT_OC_MSG_SPEC) { as.Add(pc); } } as.End(); }
/** * Step forward until a token goes beyond the limit and then call split_line() * to split the line at or before that point. */ void do_code_width(void) { LOG_FUNC_ENTRY(); chunk_t *pc; LOG_FMT(LSPLIT, "%s\n", __func__); for (pc = chunk_get_head(); pc != NULL; pc = chunk_get_next(pc)) { if (!chunk_is_newline(pc) && !chunk_is_comment(pc) && (pc->type != CT_SPACE) && is_past_width(pc)) { if (!split_line(pc)) { LOG_FMT(LSPLIT, "%s: Bailed on %lu:%lu %s\n", __func__, pc->orig_line, pc->orig_col, pc->text()); break; } } } }
// protocol of the line void prot_the_line(int theLine, unsigned int actual_line) { LOG_FMT(LGUY, "Prot_the_line:(%d) \n", theLine); for (chunk_t *pc = chunk_get_head(); pc != NULL; pc = pc->next) { if (pc->orig_line == actual_line) { LOG_FMT(LGUY, "(%d) orig_line=%d, ", theLine, actual_line); if (pc->type == CT_VBRACE_OPEN) { LOG_FMT(LGUY, "<VBRACE_OPEN>\n"); } else if (pc->type == CT_NEWLINE) { LOG_FMT(LGUY, "<NL>(%zu)\n", pc->nl_count); } else if (pc->type == CT_VBRACE_CLOSE) { LOG_FMT(LGUY, "<CT_VBRACE_CLOSE>\n"); } else if (pc->type == CT_VBRACE_OPEN) { LOG_FMT(LGUY, "<CT_VBRACE_OPEN>\n"); } else if (pc->type == CT_SPACE) { LOG_FMT(LGUY, "<CT_SPACE>\n"); } else { LOG_FMT(LGUY, "text() %s, type %s, orig_col=%zu, column=%zu\n", pc->text(), get_token_name(pc->type), pc->orig_col, pc->column); } } } LOG_FMT(LGUY, "\n"); }