/*
* the value of after determines:
* true: insert_vbrace_close_after(pc, frm)
* false: insert_vbrace_open_before(pc, frm)
*/
static chunk_t *insert_vbrace(chunk_t *pc, bool after,
struct parse_frame *frm)
{
LOG_FUNC_ENTRY();
chunk_t chunk;
chunk_t *rv;
chunk_t *ref;
chunk.orig_line = pc->orig_line;
chunk.parent_type = frm->pse[frm->pse_tos].type;
chunk.level = frm->level;
chunk.brace_level = frm->brace_level;
chunk.flags = pc->flags & PCF_COPY_FLAGS;
chunk.str = "";
if (after)
{
chunk.type = CT_VBRACE_CLOSE;
rv = chunk_add_after(&chunk, pc);
}
else
{
ref = chunk_get_prev(pc);
if ((ref->flags & PCF_IN_PREPROC) == 0)
{
chunk.flags &= ~PCF_IN_PREPROC;
}
while (chunk_is_newline(ref) || chunk_is_comment(ref))
{
ref->level++;
ref->brace_level++;
ref = chunk_get_prev(ref);
}
/* Don't back into a preprocessor */
if (((pc->flags & PCF_IN_PREPROC) == 0) &&
(ref->flags & PCF_IN_PREPROC))
{
if (ref->type == CT_PREPROC_BODY)
{
do
{
ref = chunk_get_prev(ref);
} while ((ref != NULL) && (ref->flags & PCF_IN_PREPROC));
}
else
{
ref = chunk_get_next(ref);
}
}
chunk.orig_line = ref->orig_line;
chunk.column = ref->column + ref->len() + 1;
chunk.type = CT_VBRACE_OPEN;
rv = chunk_add_after(&chunk, ref);
}
return(rv);
} // insert_vbrace
/**
* 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;
}
static void chunk_log(chunk_t *pc, const char *text)
{
if (pc && (cpd.unc_stage != US_TOKENIZE) && (cpd.unc_stage != US_CLEANUP))
{
chunk_t *prev = chunk_get_prev(pc);
chunk_t *next = chunk_get_next(pc);
LOG_FMT(LCHUNK, " -- %s: %lu:%lu '%s' [%s]",
text, pc->orig_line, pc->orig_col, pc->text(),
get_token_name(pc->type));
if (prev && next)
{
LOG_FMT(LCHUNK, " @ between %lu:%lu '%s' [%s] and %lu:%lu '%s' [%s]",
prev->orig_line, prev->orig_col, prev->text(),
get_token_name(prev->type),
next->orig_line, next->orig_col, next->text(),
get_token_name(next->type));
}
else if (next)
{
LOG_FMT(LCHUNK, " @ before %lu:%lu '%s' [%s]",
next->orig_line, next->orig_col, next->text(),
get_token_name(next->type));
}
else if (prev)
{
LOG_FMT(LCHUNK, " @ after %lu:%lu '%s' [%s]",
prev->orig_line, prev->orig_col, prev->text(),
get_token_name(prev->type));
}
LOG_FMT(LCHUNK, " stage=%d", cpd.unc_stage);
log_func_stack_inline(LCHUNK);
}
}
static void split_fcn_params_full(chunk_t *start)
{
LOG_FUNC_ENTRY();
LOG_FMT(LSPLIT, "%s(%d): %s\n", __func__, __LINE__, start->text());
// Find the opening function parenthesis
chunk_t *fpo = start;
LOG_FMT(LSPLIT, " %s(%d): Find the opening function parenthesis\n", __func__, __LINE__);
while ((fpo = chunk_get_prev(fpo)) != nullptr)
{
LOG_FMT(LSPLIT, "%s(%d): %s, orig_col is %zu, level is %zu\n",
__func__, __LINE__, fpo->text(), fpo->orig_col, fpo->level);
if (fpo->type == CT_FPAREN_OPEN && (fpo->level == start->level - 1))
{
break; // opening parenthesis found. Issue #1020
}
}
// Now break after every comma
chunk_t *pc = fpo;
while ((pc = chunk_get_next_ncnl(pc)) != nullptr)
{
if (pc->level <= fpo->level)
{
break;
}
if ((pc->level == (fpo->level + 1)) && pc->type == CT_COMMA)
{
split_before_chunk(chunk_get_next(pc));
}
}
}
/**
* Splits the parameters at every comma that is at the fparen level.
*
* @param start the offending token
*/
static void split_fcn_params_full(chunk_t *start)
{
LOG_FMT(LSPLIT, "%s", __func__);
chunk_t *fpo;
chunk_t *pc;
/* Find the opening fparen */
fpo = start;
while (((fpo = chunk_get_prev(fpo)) != NULL) &&
(fpo->type != CT_FPAREN_OPEN))
{
/* do nothing */
}
/* Now break after every comma */
pc = fpo;
while ((pc = chunk_get_next_ncnl(pc)) != NULL)
{
if (pc->level <= fpo->level)
{
break;
}
if ((pc->level == (fpo->level + 1)) && (pc->type == CT_COMMA))
{
split_before_chunk(chunk_get_next(pc));
}
}
}
static void chunk_log(chunk_t *pc, const char *text)
{
if ((pc != NULL) && (cpd.unc_stage != US_TOKENIZE) && (cpd.unc_stage != US_CLEANUP))
{
const log_sev_t log = LCHUNK;
chunk_t *prev = chunk_get_prev(pc);
chunk_t *next = chunk_get_next(pc);
chunk_log_msg(pc, log, text);
if (prev && next)
{
chunk_log_msg(prev, log, " @ between");
chunk_log_msg(next, log, " and");
}
else if (next)
{
chunk_log_msg(next, log, " @ before");
}
else if (prev)
{
chunk_log_msg(prev, log, " @ after");
}
LOG_FMT(log, " stage=%d", cpd.unc_stage);
log_func_stack_inline(log);
}
}
/**
* Aligns an OC message
*
* @param so the square open of the message
* @param span the span value
*/
static void align_oc_msg_colon(chunk_t *so)
{
int span = cpd.settings[UO_align_oc_msg_colon_span].n;
chunk_t *pc;
chunk_t *tmp;
AlignStack cas; /* for the colons */
AlignStack nas; /* for the parameter tag */
int level;
bool did_line;
int lcnt; /* line count with no colon for span */
bool has_colon;
nas.Reset();
nas.m_right_align = true;
cas.Start(span);
level = so->level;
pc = chunk_get_next_ncnl(so, CNAV_PREPROC);
did_line = false;
has_colon = false;
lcnt = 0;
while ((pc != NULL) && (pc->level > level))
{
if (pc->level > (level + 1))
{
/* do nothing */
}
else if (chunk_is_newline(pc))
{
if (!has_colon)
{
++lcnt;
}
did_line = false;
has_colon = !has_colon;
}
else if (!did_line && (lcnt - 1 < span) && (pc->type == CT_OC_COLON))
{
has_colon = true;
cas.Add(pc);
tmp = chunk_get_prev(pc);
if ((tmp != NULL) &&
((tmp->type == CT_OC_MSG_FUNC) ||
(tmp->type == CT_OC_MSG_NAME)))
{
nas.Add(tmp);
}
did_line = true;
}
pc = chunk_get_next(pc, CNAV_PREPROC);
}
nas.End();
cas.End();
}
/**
* 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;
}
}
/**
* Gets the prev non-NEWLINE chunk
*/
chunk_t *chunk_get_prev_nnl(chunk_t *cur, chunk_nav_t nav)
{
chunk_t *pc = cur;
do
{
pc = chunk_get_prev(pc, nav);
} while ((pc != NULL) && chunk_is_newline(pc));
return(pc);
}
/**
* Gets the prev non-vbrace chunk
*/
chunk_t *chunk_get_prev_nvb(chunk_t *cur, chunk_nav_t nav)
{
chunk_t *pc = cur;
do
{
pc = chunk_get_prev(pc, nav);
} while (chunk_is_vbrace(pc));
return(pc);
}
/**
* Gets the prev non-comment chunk
*/
chunk_t *chunk_get_prev_nc(chunk_t *cur, chunk_nav_t nav)
{
chunk_t *pc = cur;
do
{
pc = chunk_get_prev(pc, nav);
} while ((pc != NULL) && chunk_is_comment(pc));
return(pc);
}
/**
* Gets the prev non-blank chunk
*/
chunk_t *chunk_get_prev_nblank(chunk_t *cur, chunk_nav_t nav)
{
chunk_t *pc = cur;
do
{
pc = chunk_get_prev(pc, nav);
} while ((pc != NULL) && (chunk_is_comment(pc) || chunk_is_newline(pc) ||
chunk_is_blank(pc)));
return(pc);
}
/* @todo the following function shall be made similar to the search functions */
chunk_t *chunk_first_on_line(chunk_t *pc)
{
chunk_t *first = pc;
while (((pc = chunk_get_prev(pc)) != NULL) && !chunk_is_newline(pc))
{
first = pc;
}
return(first);
}
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;
}
}
static void add_file_footer()
{
chunk_t *pc = chunk_get_tail();
/* Back up if the file ends with a newline */
if ((pc != NULL) && chunk_is_newline(pc))
{
pc = chunk_get_prev(pc);
}
if ((pc != NULL) &&
(!chunk_is_comment(pc) || !chunk_is_newline(chunk_get_prev(pc))))
{
pc = chunk_get_tail();
if (!chunk_is_newline(pc))
{
LOG_FMT(LSYS, "Adding a newline at the end of the file\n");
newline_add_after(pc);
}
tokenize(cpd.file_ftr.data, NULL);
}
}
/**
* Remove the case brace, if allowable.
*/
static chunk_t *mod_case_brace_remove(chunk_t *br_open)
{
LOG_FUNC_ENTRY();
chunk_t *pc;
chunk_t *br_close;
chunk_t *next = chunk_get_next_ncnl(br_open, CNAV_PREPROC);
LOG_FMT(LMCB, "%s: line %lu", __func__, br_open->orig_line);
/* Find the matching brace close */
br_close = chunk_get_next_type(br_open, CT_BRACE_CLOSE, br_open->level, CNAV_PREPROC);
if (br_close == NULL)
{
LOG_FMT(LMCB, " - no close\n");
return(next);
}
/* Make sure 'break', 'return', 'goto', 'case' or '}' is after the close brace */
pc = chunk_get_next_ncnl(br_close, CNAV_PREPROC);
if ((pc == NULL) ||
((pc->type != CT_BREAK) &&
(pc->type != CT_RETURN) &&
(pc->type != CT_CASE) &&
(pc->type != CT_GOTO) &&
(pc->type != CT_BRACE_CLOSE)))
{
LOG_FMT(LMCB, " - after '%s'\n",
(pc == NULL) ? "<null>" : get_token_name(pc->type));
return(next);
}
/* scan to make sure there are no definitions at brace level between braces */
for (pc = br_open; pc != br_close; pc = chunk_get_next_ncnl(pc, CNAV_PREPROC))
{
if ((pc->level == (br_open->level + 1)) && (pc->flags & PCF_VAR_DEF))
{
LOG_FMT(LMCB, " - vardef on line %lu: '%s'\n", pc->orig_line, pc->text());
return(next);
}
}
LOG_FMT(LMCB, " - removing braces on lines %lu and %lu\n",
br_open->orig_line, br_close->orig_line);
for (pc = br_open; pc != br_close; pc = chunk_get_next_ncnl(pc, CNAV_PREPROC))
{
pc->brace_level--;
pc->level--;
}
next = chunk_get_prev(br_open, CNAV_PREPROC);
chunk_del(br_open);
chunk_del(br_close);
return(chunk_get_next(next, CNAV_PREPROC));
} // mod_case_brace_remove
/**
* Split right after the chunk
*/
static void split_before_chunk(chunk_t *pc)
{
LOG_FMT(LSPLIT, "%s: %s\n", __func__, pc->str.c_str());
if (!chunk_is_newline(pc) &&
!chunk_is_newline(chunk_get_prev(pc)))
{
newline_add_before(pc);
reindent_line(pc, pc->brace_level * cpd.settings[UO_indent_columns].n);
cpd.changes++;
}
}
/**
* 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();
}
/**
* Split right after the chunk
*/
static void split_before_chunk(chunk_t *pc)
{
LOG_FMT(LSPLIT, "%s: %s\n", __func__, pc->str.c_str());
if (!chunk_is_newline(pc) &&
!chunk_is_newline(chunk_get_prev(pc)))
{
newline_add_before(pc);
// reindent needs to include the indent_continue value and was off by one
reindent_line(pc, pc->brace_level * cpd.settings[UO_indent_columns].n +
abs(cpd.settings[UO_indent_continue].n) + 1);
cpd.changes++;
}
}
/**
* Gets the prev non-NEWLINE and non-comment chunk, non-preprocessor chunk
*/
chunk_t *chunk_get_prev_ncnlnp(chunk_t *cur, chunk_nav_t nav)
{
chunk_t *pc = cur;
if (chunk_is_preproc(cur))
{
do
{
pc = chunk_get_prev(pc, nav);
} while ((pc != NULL) && chunk_is_preproc(pc) &&
(chunk_is_comment(pc) || chunk_is_newline(pc)));
}
else
{
do
{
pc = chunk_get_prev(pc, nav);
} while ((pc != NULL) && (chunk_is_comment(pc) ||
chunk_is_newline(pc) ||
chunk_is_preproc(pc)));
}
return(pc);
}
/**
* Grabs the prev chunk of the given type at the level.
*
* @param cur Starting chunk
* @param type The type to look for
* @param level -1 (any level) or the level to match
* @return NULL or the match
*/
chunk_t *chunk_get_prev_type(chunk_t *cur, c_token_t type,
int level, chunk_nav_t nav)
{
chunk_t *pc = cur;
do
{
pc = chunk_get_prev(pc, nav);
if ((pc == NULL) ||
((pc->type == type) && ((pc->level == level) || (level < 0))))
{
break;
}
} while (pc != NULL);
return(pc);
}
chunk_t *chunk_get_prev_str(chunk_t *cur, const char *str, size_t len, int level,
chunk_nav_t nav)
{
chunk_t *pc = cur;
do
{
pc = chunk_get_prev(pc, nav);
if ((pc == NULL) ||
((pc->len() == len) && (memcmp(str, pc->text(), len) == 0) &&
((pc->level == level) || (level < 0))))
{
break;
}
} while (pc != NULL);
return(pc);
}
/**
* Adds an item to the align stack and adjust the nl_count and max_col.
* Adjust max_col as needed
*
* @param pc the item to add
* @param max_col pointer to the column variable
* @param extra_pad extra padding
*/
static void align_add(ChunkStack& cs, chunk_t *pc, int& max_col, int min_pad, bool squeeze)
{
chunk_t *prev;
int min_col;
prev = chunk_get_prev(pc);
if ((prev == NULL) || chunk_is_newline(prev))
{
min_col = squeeze ? 1 : pc->column;
LOG_FMT(LALADD, "%s: pc->col=%d max_col=%d min_pad=%d min_col=%d\n",
__func__, pc->column, max_col, min_pad, min_col);
}
else
{
if (prev->type == CT_COMMENT_MULTI)
{
min_col = prev->orig_col_end + min_pad;
}
else
{
min_col = prev->column + prev->len + min_pad;
}
if (!squeeze)
{
if (min_col < pc->column)
{
min_col = pc->column;
}
}
LOG_FMT(LALADD, "%s: pc->col=%d max_col=%d min_pad=%d min_col=%d multi:%s prev->col=%d prev->len=%d %s\n",
__func__, pc->column, max_col, min_pad, min_col, (prev->type == CT_COMMENT_MULTI) ? "Y" : "N",
(prev->type == CT_COMMENT_MULTI) ? prev->orig_col_end : prev->column, prev->len, get_token_name(prev->type));
}
if (cs.Empty())
{
max_col = 0;
}
cs.Push(pc);
if (min_col > max_col)
{
max_col = min_col;
}
}
/**
* Converts a single brace into a virtual brace
*/
static void convert_brace(chunk_t *br)
{
chunk_t *tmp;
if (br == NULL)
{
return;
}
else if (br->type == CT_BRACE_OPEN)
{
br->type = CT_VBRACE_OPEN;
br->len = 0;
br->str = "";
tmp = chunk_get_prev(br);
}
else if (br->type == CT_BRACE_CLOSE)
{
br->type = CT_VBRACE_CLOSE;
br->len = 0;
br->str = "";
tmp = chunk_get_next(br);
}
else
{
return;
}
if (chunk_is_newline(tmp))
{
if (tmp->nl_count > 1)
{
tmp->nl_count--;
}
else
{
if (chunk_safe_to_del_nl(tmp))
{
chunk_del(tmp);
}
}
}
}
static void convert_brace(chunk_t *br)
{
LOG_FUNC_ENTRY();
chunk_t *tmp;
if (!br || (br->flags & PCF_KEEP_BRACE))
{
return;
}
else if (br->type == CT_BRACE_OPEN)
{
set_chunk_type(br, CT_VBRACE_OPEN);
br->str.clear();
tmp = chunk_get_prev(br);
}
else if (br->type == CT_BRACE_CLOSE)
{
set_chunk_type(br, CT_VBRACE_CLOSE);
br->str.clear();
tmp = chunk_get_next(br);
}
else
{
return;
}
if (chunk_is_newline(tmp))
{
if (tmp->nl_count > 1)
{
tmp->nl_count--;
}
else
{
if (chunk_safe_to_del_nl(tmp))
{
chunk_del(tmp);
}
}
}
}
static CmtAlignType get_comment_align_type(chunk_t *cmt)
{
chunk_t *prev;
CmtAlignType cmt_type = CAT_REGULAR;
if (!cpd.settings[UO_align_right_cmt_mix].b &&
((prev = chunk_get_prev(cmt)) != NULL))
{
if ((prev->type == CT_PP_ENDIF) ||
(prev->type == CT_PP_ELSE) ||
(prev->type == CT_ELSE) ||
(prev->type == CT_BRACE_CLOSE))
{
/* REVISIT: someone may want this configurable */
if ((cmt->column - (prev->column + prev->len)) < 3)
{
cmt_type = (prev->type == CT_PP_ENDIF) ? CAT_ENDIF : CAT_BRACE;
}
}
}
return(cmt_type);
}
void align_add(ChunkStack &cs, chunk_t *pc, size_t &max_col)
{
LOG_FUNC_ENTRY();
size_t min_col;
chunk_t *prev = chunk_get_prev(pc);
if (prev == nullptr || chunk_is_newline(prev))
{
min_col = 1;
LOG_FMT(LALADD, "%s(%d): pc->orig_line=%zu, pc->col=%zu max_col=%zu min_col=%zu\n",
__func__, __LINE__, pc->orig_line, pc->column, max_col, min_col);
}
else
{
if (chunk_is_token(prev, CT_COMMENT_MULTI))
{
min_col = prev->orig_col_end + 1;
}
else
{
min_col = prev->column + prev->len() + 1;
}
LOG_FMT(LALADD, "%s(%d): pc->orig_line=%zu, pc->col=%zu max_col=%zu min_col=%zu multi:%s prev->col=%zu prev->len()=%zu %s\n",
__func__, __LINE__, pc->orig_line, pc->column, max_col, min_col, (chunk_is_token(prev, CT_COMMENT_MULTI)) ? "Y" : "N",
(chunk_is_token(prev, CT_COMMENT_MULTI)) ? prev->orig_col_end : (UINT32)prev->column, prev->len(), get_token_name(prev->type));
}
if (cs.Empty())
{
max_col = 0;
}
cs.Push_Back(pc);
if (min_col > max_col)
{
max_col = min_col;
}
} // align_add
/**
* Checks to see if pc is a better spot to split.
* This should only be called going BACKWARDS (ie prev)
* A lower level wins
*
* Splitting Preference:
* - semicolon
* - comma
* - boolean op
* - comparison
* - arithmetic op
* - assignment
*/
static void try_split_here(cw_entry& ent, chunk_t *pc)
{
chunk_t *prev;
int pc_pri = get_split_pri(pc->type);
if (pc_pri == 0)
{
return;
}
/* Can't split after a newline */
prev = chunk_get_prev(pc);
if ((prev == NULL) || chunk_is_newline(prev))
{
return;
}
/* Check levels first */
bool change = false;
if ((ent.pc == NULL) || (pc->level < ent.pc->level))
{
change = true;
}
else
{
if ((pc->level > ent.pc->level) &&
(pc_pri <= ent.pri))
{
change = true;
}
}
if (change)
{
ent.pc = pc;
ent.pri = pc_pri;
}
}
static void split_template(chunk_t *start)
{
LOG_FUNC_ENTRY();
LOG_FMT(LSPLIT, " %s(%d): start %s\n", __func__, __LINE__, start->text());
LOG_FMT(LSPLIT, " %s(%d): back up until the prev is a comma\n", __func__, __LINE__);
// back up until the prev is a comma
chunk_t *prev = start;
while ((prev = chunk_get_prev(prev)) != nullptr)
{
LOG_FMT(LSPLIT, " %s(%d): prev '%s'\n", __func__, __LINE__, prev->text());
if (chunk_is_newline(prev) || prev->type == CT_COMMA)
{
break;
}
}
if (prev != nullptr && !chunk_is_newline(prev))
{
LOG_FMT(LSPLIT, " %s(%d):", __func__, __LINE__);
LOG_FMT(LSPLIT, " -- ended on [%s] --\n", get_token_name(prev->type));
chunk_t *pc = chunk_get_next(prev);
newline_add_before(pc);
size_t min_col = 1;
if (cpd.settings[UO_indent_continue].n == 0)
{
min_col += cpd.settings[UO_indent_columns].u;
}
else
{
min_col += abs(cpd.settings[UO_indent_continue].n);
}
reindent_line(pc, min_col);
cpd.changes++;
}
} // split_templatefcn_params
/* @todo this function needs some cleanup */
void chunk_swap_lines(chunk_t *pc1, chunk_t *pc2)
{
pc1 = chunk_first_on_line(pc1);
pc2 = chunk_first_on_line(pc2);
if ((pc1 == NULL) || (pc2 == NULL) || (pc1 == pc2))
{
return;
}
/**
* Example start:
* ? - start1 - a1 - b1 - nl1 - ? - ref2 - start2 - a2 - b2 - nl2 - ?
* ^- pc1 ^- pc2
*/
chunk_t *ref2 = chunk_get_prev(pc2);
/* Move the line started at pc2 before pc1 */
while ((pc2 != NULL) && !chunk_is_newline(pc2))
{
chunk_t *tmp = chunk_get_next(pc2);
g_cl.Pop(pc2);
g_cl.AddBefore(pc2, pc1);
pc2 = tmp;
}
/**
* Should now be:
* ? - start2 - a2 - b2 - start1 - a1 - b1 - nl1 - ? - ref2 - nl2 - ?
* ^- pc1 ^- pc2
*/
/* Now move the line started at pc1 after ref2 */
while ((pc1 != NULL) && !chunk_is_newline(pc1))
{
chunk_t *tmp = chunk_get_next(pc1);
g_cl.Pop(pc1);
if (ref2 != NULL)
{
g_cl.AddAfter(pc1, ref2);
}
else
{
g_cl.AddHead(pc1);
}
ref2 = pc1;
pc1 = tmp;
}
/**
* Should now be:
* ? - start2 - a2 - b2 - nl1 - ? - ref2 - start1 - a1 - b1 - nl2 - ?
* ^- pc1 ^- pc2
*/
/* pc1 and pc2 should be the newlines for their lines.
* swap the chunks and the nl_count so that the spacing remains the same.
*/
if ((pc1 != NULL) && (pc2 != NULL))
{
size_t nl_count = pc1->nl_count;
pc1->nl_count = pc2->nl_count;
pc2->nl_count = nl_count;
chunk_swap(pc1, pc2);
}
} // chunk_swap_lines
