/**
* Scans a line for stuff to align on.
*
* We trigger on BRACE_OPEN, FPAREN_OPEN, ASSIGN, and COMMA.
* We want to align the NEXT item.
*/
static chunk_t *scan_ib_line(chunk_t *start, bool first_pass)
{
chunk_t *pc;
chunk_t *next;
chunk_t *prev_match = NULL;
int token_width;
int idx = 0;
bool last_was_comment = false;
/* Skip past C99 "[xx] =" stuff */
if (start->type == CT_SQUARE_OPEN)
{
start->parent_type = CT_TSQUARE;
start = chunk_get_next_type(start, CT_ASSIGN, start->level);
start = chunk_get_next_ncnl(start);
cpd.al_c99_array = true;
}
pc = start;
if (pc != NULL)
{
LOG_FMT(LSIB, "%s: start=%s col %d/%d line %d\n", __func__,
get_token_name(pc->type), pc->column, pc->orig_col, pc->orig_line);
}
while ((pc != NULL) && !chunk_is_newline(pc) &&
(pc->level >= start->level))
{
//LOG_FMT(LSIB, "%s: '%.*s' col %d/%d line %d\n", __func__,
// pc->len, pc->str, pc->column, pc->orig_col, pc->orig_line);
next = chunk_get_next(pc);
if ((next == NULL) || chunk_is_comment(next))
{
/* do nothing */
}
else if ((pc->type == CT_ASSIGN) ||
(pc->type == CT_BRACE_OPEN) ||
(pc->type == CT_BRACE_CLOSE) ||
(pc->type == CT_COMMA))
{
token_width = space_col_align(pc, next);
/*TODO: need to handle missing structure defs? ie NULL vs { ... } ?? */
/* Is this a new entry? */
if (idx >= cpd.al_cnt)
{
LOG_FMT(LSIB, " - New [%d] %.2d/%d - %10.10s\n", idx,
pc->column, token_width, get_token_name(pc->type));
cpd.al[cpd.al_cnt].type = pc->type;
cpd.al[cpd.al_cnt].col = pc->column;
cpd.al[cpd.al_cnt].len = token_width;
cpd.al_cnt++;
idx++;
last_was_comment = false;
}
else
{
/* expect to match stuff */
if (cpd.al[idx].type == pc->type)
{
LOG_FMT(LSIB, " - Match [%d] %.2d/%d - %10.10s", idx,
pc->column, token_width, get_token_name(pc->type));
/* Shift out based on column */
if (prev_match == NULL)
{
if (pc->column > cpd.al[idx].col)
{
LOG_FMT(LSIB, " [ pc->col(%d) > col(%d) ] ",
pc->column, cpd.al[idx].col);
ib_shift_out(idx, pc->column - cpd.al[idx].col);
cpd.al[idx].col = pc->column;
}
}
else if (idx > 0)
{
int min_col_diff = pc->column - prev_match->column;
int cur_col_diff = cpd.al[idx].col - cpd.al[idx - 1].col;
if (cur_col_diff < min_col_diff)
{
LOG_FMT(LSIB, " [ min_col_diff(%d) > cur_col_diff(%d) ] ",
min_col_diff, cur_col_diff);
ib_shift_out(idx, min_col_diff - cur_col_diff);
}
}
LOG_FMT(LSIB, " - now col %d, len %d\n", cpd.al[idx].col, cpd.al[idx].len);
idx++;
}
}
prev_match = pc;
}
last_was_comment = chunk_is_comment(pc);
pc = chunk_get_next_nc(pc);
}
//if (last_was_comment && (cpd.al[cpd.al_cnt - 1].type == CT_COMMA))
//{
// cpd.al_cnt--;
//}
return(pc);
}
/**
* This function parses or tokenizes the whole buffer into a list.
* It has to do some tricks to parse preprocessors.
*
* If output_text() were called immediately after, two things would happen:
* - trailing whitespace are removed.
* - leading space & tabs are converted to the appropriate format.
*
* All the tokens are inserted before ref. If ref is NULL, they are inserted
* at the end of the list. Line numbers are relative to the start of the data.
*/
void tokenize(const deque<int>& data, chunk_t *ref)
{
tok_ctx ctx(data);
chunk_t chunk;
chunk_t *pc = NULL;
chunk_t *rprev = NULL;
struct parse_frame frm;
bool last_was_tab = false;
int prev_sp = 0;
memset(&frm, 0, sizeof(frm));
while (ctx.more())
{
chunk.reset();
if (!parse_next(ctx, chunk))
{
LOG_FMT(LERR, "%s:%d Bailed before the end?\n",
cpd.filename, ctx.c.row);
cpd.error_count++;
break;
}
/* Don't create an entry for whitespace */
if (chunk.type == CT_WHITESPACE)
{
last_was_tab = chunk.after_tab;
prev_sp = chunk.orig_prev_sp;
continue;
}
chunk.orig_prev_sp = prev_sp;
prev_sp = 0;
if (chunk.type == CT_NEWLINE)
{
last_was_tab = chunk.after_tab;
chunk.after_tab = false;
chunk.str.clear();
}
else if (chunk.type == CT_NL_CONT)
{
last_was_tab = chunk.after_tab;
chunk.after_tab = false;
chunk.str = "\\\n";
}
else
{
chunk.after_tab = last_was_tab;
last_was_tab = false;
}
/* Strip trailing whitespace (for CPP comments and PP blocks) */
while ((chunk.str.size() > 0) &&
((chunk.str[chunk.str.size() - 1] == ' ') ||
(chunk.str[chunk.str.size() - 1] == '\t')))
{
// If comment contains backslash '\' followed by whitespace chars, keep last one;
// this will prevent it from turning '\' into line continuation.
if ((chunk.str.size() > 1) && (chunk.str[chunk.str.size() - 2] == '\\'))
{
break;
}
chunk.str.pop_back();
}
/* Store off the end column */
chunk.orig_col_end = ctx.c.col;
/* Add the chunk to the list */
rprev = pc;
if (rprev != NULL)
{
pc->flags |= rprev->flags & PCF_COPY_FLAGS;
/* a newline can't be in a preprocessor */
if (pc->type == CT_NEWLINE)
{
pc->flags &= ~PCF_IN_PREPROC;
}
}
if (ref != NULL)
{
chunk.flags |= PCF_INSERTED;
}
else
{
chunk.flags &= ~PCF_INSERTED;
}
pc = chunk_add_before(&chunk, ref);
/* A newline marks the end of a preprocessor */
if (pc->type == CT_NEWLINE) // || (pc->type == CT_COMMENT_MULTI))
{
cpd.in_preproc = CT_NONE;
cpd.preproc_ncnl_count = 0;
}
/* Special handling for preprocessor stuff */
if (cpd.in_preproc != CT_NONE)
{
pc->flags |= PCF_IN_PREPROC;
/* Count words after the preprocessor */
if (!chunk_is_comment(pc) && !chunk_is_newline(pc))
{
cpd.preproc_ncnl_count++;
}
/* Figure out the type of preprocessor for #include parsing */
if (cpd.in_preproc == CT_PREPROC)
{
if ((pc->type < CT_PP_DEFINE) || (pc->type > CT_PP_OTHER))
{
set_chunk_type(pc, CT_PP_OTHER);
}
cpd.in_preproc = pc->type;
}
}
else
{
/* Check for a preprocessor start */
if ((pc->type == CT_POUND) &&
((rprev == NULL) || (rprev->type == CT_NEWLINE)))
{
set_chunk_type(pc, CT_PREPROC);
pc->flags |= PCF_IN_PREPROC;
cpd.in_preproc = CT_PREPROC;
}
}
}
/* Set the cpd.newline string for this file */
if ((cpd.settings[UO_newlines].le == LE_LF) ||
((cpd.settings[UO_newlines].le == LE_AUTO) &&
(cpd.le_counts[LE_LF] >= cpd.le_counts[LE_CRLF]) &&
(cpd.le_counts[LE_LF] >= cpd.le_counts[LE_CR])))
{
/* LF line ends */
cpd.newline = "\n";
LOG_FMT(LLINEENDS, "Using LF line endings\n");
}
else if ((cpd.settings[UO_newlines].le == LE_CRLF) ||
((cpd.settings[UO_newlines].le == LE_AUTO) &&
(cpd.le_counts[LE_CRLF] >= cpd.le_counts[LE_LF]) &&
(cpd.le_counts[LE_CRLF] >= cpd.le_counts[LE_CR])))
{
/* CRLF line ends */
cpd.newline = "\r\n";
LOG_FMT(LLINEENDS, "Using CRLF line endings\n");
}
else
{
/* CR line ends */
cpd.newline = "\r";
LOG_FMT(LLINEENDS, "Using CR line endings\n");
}
}
/**
* Checks the progression of complex statements.
* - checks for else after if
* - checks for if after else
* - checks for while after do
* - checks for open brace in BRACE2 and BRACE_DO stages, inserts open VBRACE
* - checks for open paren in PAREN1 and PAREN2 stages, complains
*
* @param frm The parse frame
* @param pc The current chunk
* @return true - done with this chunk, false - keep processing
*/
static bool check_complex_statements(struct parse_frame *frm, chunk_t *pc)
{
c_token_t parent;
chunk_t *vbrace;
/* Turn an optional paren into either a real paren or a brace */
if (frm->pse[frm->pse_tos].stage == BS_OP_PAREN1)
{
frm->pse[frm->pse_tos].stage = (pc->type != CT_PAREN_OPEN) ? BS_BRACE2 : BS_PAREN1;
}
/* Check for CT_ELSE after CT_IF */
while (frm->pse[frm->pse_tos].stage == BS_ELSE)
{
if (pc->type == CT_ELSE)
{
/* Replace CT_IF with CT_ELSE on the stack & we are done */
frm->pse[frm->pse_tos].type = CT_ELSE;
frm->pse[frm->pse_tos].stage = BS_ELSEIF;
print_stack(LBCSSWAP, "=Swap ", frm, pc);
return(true);
}
/* Remove the CT_IF and close the statement */
frm->pse_tos--;
print_stack(LBCSPOP, "-IF-CCS ", frm, pc);
if (close_statement(frm, pc))
{
return(true);
}
}
/* Check for CT_IF after CT_ELSE */
if (frm->pse[frm->pse_tos].stage == BS_ELSEIF)
{
if (pc->type == CT_IF)
{
if (!cpd.settings[UO_indent_else_if].b ||
!chunk_is_newline(chunk_get_prev_nc(pc)))
{
/* Replace CT_ELSE with CT_IF */
pc->type = CT_ELSEIF;
frm->pse[frm->pse_tos].type = CT_ELSEIF;
frm->pse[frm->pse_tos].stage = BS_PAREN1;
return(true);
}
}
/* Jump to the 'expecting brace' stage */
frm->pse[frm->pse_tos].stage = BS_BRACE2;
}
/* Check for CT_CATCH or CT_FINALLY after CT_TRY or CT_CATCH */
while (frm->pse[frm->pse_tos].stage == BS_CATCH)
{
if ((pc->type == CT_CATCH) || (pc->type == CT_FINALLY))
{
/* Replace CT_TRY with CT_CATCH on the stack & we are done */
frm->pse[frm->pse_tos].type = pc->type;
frm->pse[frm->pse_tos].stage = (pc->type == CT_CATCH) ? BS_OP_PAREN1 : BS_BRACE2;
print_stack(LBCSSWAP, "=Swap ", frm, pc);
return(true);
}
/* Remove the CT_TRY and close the statement */
frm->pse_tos--;
print_stack(LBCSPOP, "-TRY-CCS ", frm, pc);
if (close_statement(frm, pc))
{
return(true);
}
}
/* Check for CT_WHILE after the CT_DO */
if (frm->pse[frm->pse_tos].stage == BS_WHILE)
{
if (pc->type == CT_WHILE)
{
pc->type = CT_WHILE_OF_DO;
frm->pse[frm->pse_tos].type = CT_WHILE_OF_DO; //CT_WHILE;
frm->pse[frm->pse_tos].stage = BS_WOD_PAREN;
return(true);
}
LOG_FMT(LWARN, "%s:%d Error: Expected 'while', got '%s'\n",
cpd.filename, pc->orig_line, pc->str.c_str());
frm->pse_tos--;
print_stack(LBCSPOP, "-Error ", frm, pc);
cpd.error_count++;
}
/* Insert a CT_VBRACE_OPEN, if needed */
if ((pc->type != CT_BRACE_OPEN) &&
((frm->pse[frm->pse_tos].stage == BS_BRACE2) ||
(frm->pse[frm->pse_tos].stage == BS_BRACE_DO)))
{
parent = frm->pse[frm->pse_tos].type;
vbrace = insert_vbrace_open_before(pc, frm);
vbrace->parent_type = parent;
frm->level++;
frm->brace_level++;
push_fmr_pse(frm, vbrace, BS_NONE, "+VBrace ");
frm->pse[frm->pse_tos].parent = parent;
/* update the level of pc */
pc->level = frm->level;
pc->brace_level = frm->brace_level;
/* Mark as a start of a statement */
frm->stmt_count = 0;
frm->expr_count = 0;
pc->flags |= PCF_STMT_START | PCF_EXPR_START;
frm->stmt_count = 1;
frm->expr_count = 1;
LOG_FMT(LSTMT, "%d] 2.marked %s as stmt start\n", pc->orig_line, pc->str.c_str());
}
/* Verify open paren in complex statement */
if ((pc->type != CT_PAREN_OPEN) &&
((frm->pse[frm->pse_tos].stage == BS_PAREN1) ||
(frm->pse[frm->pse_tos].stage == BS_WOD_PAREN)))
{
LOG_FMT(LWARN, "%s:%d Error: Expected '(', got '%s' for '%s'\n",
cpd.filename, pc->orig_line, pc->str.c_str(),
get_token_name(frm->pse[frm->pse_tos].type));
/* Throw out the complex statement */
frm->pse_tos--;
print_stack(LBCSPOP, "-Error ", frm, pc);
cpd.error_count++;
}
return(false);
}
void tokenize_cleanup(void)
{
chunk_t *pc = chunk_get_head();
chunk_t *prev = NULL;
chunk_t *next;
chunk_t *tmp;
chunk_t *tmp2;
bool in_type_cast = false;
cpd.unc_stage = US_TOKENIZE_CLEANUP;
/* Since [] is expected to be TSQUARE for the 'operator', we need to make
* this change in the first pass.
*/
for (pc = chunk_get_head(); pc != NULL; pc = chunk_get_next_ncnl(pc))
{
if (pc->type == CT_SQUARE_OPEN)
{
next = chunk_get_next_ncnl(pc);
if (chunk_is_token(next, CT_SQUARE_CLOSE))
{
/* Change '[' + ']' into '[]' */
set_chunk_type(pc, CT_TSQUARE);
pc->str = "[]";
// bug # 664
// The original orig_col_end of CT_SQUARE_CLOSE is stored at orig_col_end of CT_TSQUARE.
// pc->orig_col_end += 1;
pc->orig_col_end = next->orig_col_end;
chunk_del(next);
}
}
if ((pc->type == CT_SEMICOLON) &&
(pc->flags & PCF_IN_PREPROC) &&
!chunk_get_next_ncnl(pc, CNAV_PREPROC))
{
LOG_FMT(LNOTE, "%s:%d Detected a macro that ends with a semicolon. Possible failures if used.\n",
cpd.filename, pc->orig_line);
}
}
/* We can handle everything else in the second pass */
pc = chunk_get_head();
next = chunk_get_next_ncnl(pc);
while ((pc != NULL) && (next != NULL))
{
if ((pc->type == CT_DOT) && (cpd.lang_flags & LANG_ALLC))
{
set_chunk_type(pc, CT_MEMBER);
}
if ((pc->type == CT_NULLCOND) && (cpd.lang_flags & LANG_CS))
{
set_chunk_type(pc, CT_MEMBER);
}
/* Determine the version stuff (D only) */
if (pc->type == CT_D_VERSION)
{
if (next->type == CT_PAREN_OPEN)
{
set_chunk_type(pc, CT_D_VERSION_IF);
}
else
{
if (next->type != CT_ASSIGN)
{
LOG_FMT(LERR, "%s:%d %s: version: Unexpected token %s\n",
cpd.filename, pc->orig_line, __func__, get_token_name(next->type));
cpd.error_count++;
}
set_chunk_type(pc, CT_WORD);
}
}
/* Determine the scope stuff (D only) */
if (pc->type == CT_D_SCOPE)
{
if (next->type == CT_PAREN_OPEN)
{
set_chunk_type(pc, CT_D_SCOPE_IF);
}
else
{
set_chunk_type(pc, CT_TYPE);
}
}
/**
* Change CT_BASE before CT_PAREN_OPEN to CT_WORD.
* public myclass() : base() {
* }
*/
if ((pc->type == CT_BASE) && (next->type == CT_PAREN_OPEN))
{
set_chunk_type(pc, CT_WORD);
}
if ((pc->type == CT_ENUM) && (next->type == CT_CLASS))
{
set_chunk_type(next, CT_ENUM_CLASS);
}
/**
* Change CT_WORD after CT_ENUM, CT_UNION, or CT_STRUCT to CT_TYPE
* Change CT_WORD before CT_WORD to CT_TYPE
*/
if (next->type == CT_WORD)
{
if ((pc->type == CT_ENUM) ||
(pc->type == CT_ENUM_CLASS) ||
(pc->type == CT_UNION) ||
(pc->type == CT_STRUCT))
{
set_chunk_type(next, CT_TYPE);
}
if (pc->type == CT_WORD)
{
set_chunk_type(pc, CT_TYPE);
}
}
/* change extern to qualifier if extern isn't followed by a string or
* an open paren
*/
if (pc->type == CT_EXTERN)
{
if (next->type == CT_STRING)
{
/* Probably 'extern "C"' */
}
else if (next->type == CT_PAREN_OPEN)
{
/* Probably 'extern (C)' */
}
else
{
/* Something else followed by a open brace */
tmp = chunk_get_next_ncnl(next);
if ((tmp == NULL) || (tmp->type != CT_BRACE_OPEN))
{
set_chunk_type(pc, CT_QUALIFIER);
}
}
}
/**
* Change CT_STAR to CT_PTR_TYPE if preceded by CT_TYPE,
* CT_QUALIFIER, or CT_PTR_TYPE.
*/
if ((next->type == CT_STAR) &&
((pc->type == CT_TYPE) ||
(pc->type == CT_QUALIFIER) ||
(pc->type == CT_PTR_TYPE)))
{
set_chunk_type(next, CT_PTR_TYPE);
}
if ((pc->type == CT_TYPE_CAST) &&
(next->type == CT_ANGLE_OPEN))
{
set_chunk_parent(next, CT_TYPE_CAST);
in_type_cast = true;
}
/**
* Change angle open/close to CT_COMPARE, if not a template thingy
*/
if ((pc->type == CT_ANGLE_OPEN) && (pc->parent_type != CT_TYPE_CAST))
{
/* pretty much all languages except C use <> for something other than
* comparisons. "#include<xxx>" is handled elsewhere.
*/
if (cpd.lang_flags & (LANG_CPP | LANG_CS | LANG_JAVA | LANG_VALA | LANG_OC))
{
// bug #663
check_template(pc);
}
else
{
/* convert CT_ANGLE_OPEN to CT_COMPARE */
set_chunk_type(pc, CT_COMPARE);
}
}
if ((pc->type == CT_ANGLE_CLOSE) && (pc->parent_type != CT_TEMPLATE))
{
if (in_type_cast)
{
in_type_cast = false;
set_chunk_parent(pc, CT_TYPE_CAST);
}
else
{
next = handle_double_angle_close(pc);
}
}
if (cpd.lang_flags & LANG_D)
{
/* Check for the D string concat symbol '~' */
if ((pc->type == CT_INV) &&
((prev->type == CT_STRING) ||
(prev->type == CT_WORD) ||
(next->type == CT_STRING)))
{
set_chunk_type(pc, CT_CONCAT);
}
/* Check for the D template symbol '!' (word + '!' + word or '(') */
if ((pc->type == CT_NOT) &&
(prev->type == CT_WORD) &&
((next->type == CT_PAREN_OPEN) ||
(next->type == CT_WORD) ||
(next->type == CT_TYPE)))
{
set_chunk_type(pc, CT_D_TEMPLATE);
}
/* handle "version(unittest) { }" vs "unittest { }" */
if (prev && (pc->type == CT_UNITTEST) && (prev->type == CT_PAREN_OPEN))
{
set_chunk_type(pc, CT_WORD);
}
/* handle 'static if' and merge the tokens */
if (prev && (pc->type == CT_IF) && chunk_is_str(prev, "static", 6))
{
/* delete PREV and merge with IF */
pc->str.insert(0, ' ');
pc->str.insert(0, prev->str);
pc->orig_col = prev->orig_col;
pc->orig_line = prev->orig_line;
chunk_t *to_be_deleted = prev;
prev = chunk_get_prev_ncnl(prev);
chunk_del(to_be_deleted);
}
}
if (cpd.lang_flags & LANG_CPP)
{
/* Change Word before '::' into a type */
if ((pc->type == CT_WORD) && (next->type == CT_DC_MEMBER))
{
set_chunk_type(pc, CT_TYPE);
}
}
/* Change get/set to CT_WORD if not followed by a brace open */
if ((pc->type == CT_GETSET) && (next->type != CT_BRACE_OPEN))
{
if ((next->type == CT_SEMICOLON) &&
((prev->type == CT_BRACE_CLOSE) ||
(prev->type == CT_BRACE_OPEN) ||
(prev->type == CT_SEMICOLON)))
{
set_chunk_type(pc, CT_GETSET_EMPTY);
set_chunk_parent(next, CT_GETSET);
}
else
{
set_chunk_type(pc, CT_WORD);
}
}
/* Interface is only a keyword in MS land if followed by 'class' or 'struct'
* likewise, 'class' may be a member name in Java.
*/
if ((pc->type == CT_CLASS) && !CharTable::IsKw1(next->str[0]))
{
set_chunk_type(pc, CT_WORD);
}
/* Change item after operator (>=, ==, etc) to a CT_OPERATOR_VAL
* Usually the next item is part of the operator.
* In a few cases the next few tokens are part of it:
* operator + - common case
* operator >> - need to combine '>' and '>'
* operator ()
* operator [] - already converted to TSQUARE
* operator new []
* operator delete []
* operator const char *
* operator const B&
* operator std::allocator<U>
*
* In all cases except the last, this will put the entire operator value
* in one chunk.
*/
if (pc->type == CT_OPERATOR)
{
tmp2 = chunk_get_next(next);
/* Handle special case of () operator -- [] already handled */
if (next->type == CT_PAREN_OPEN)
{
tmp = chunk_get_next(next);
if ((tmp != NULL) && (tmp->type == CT_PAREN_CLOSE))
{
next->str = "()";
set_chunk_type(next, CT_OPERATOR_VAL);
chunk_del(tmp);
next->orig_col_end += 1;
}
}
else if ((next->type == CT_ANGLE_CLOSE) &&
tmp2 && (tmp2->type == CT_ANGLE_CLOSE) &&
(tmp2->orig_col == next->orig_col_end))
{
next->str.append('>');
next->orig_col_end++;
set_chunk_type(next, CT_OPERATOR_VAL);
chunk_del(tmp2);
}
else if (next->flags & PCF_PUNCTUATOR)
{
set_chunk_type(next, CT_OPERATOR_VAL);
}
else
{
set_chunk_type(next, CT_TYPE);
/* Replace next with a collection of all tokens that are part of
* the type.
*/
tmp2 = next;
while ((tmp = chunk_get_next(tmp2)) != NULL)
{
if ((tmp->type != CT_WORD) &&
(tmp->type != CT_TYPE) &&
(tmp->type != CT_QUALIFIER) &&
(tmp->type != CT_STAR) &&
(tmp->type != CT_CARET) &&
(tmp->type != CT_AMP) &&
(tmp->type != CT_TSQUARE))
{
break;
}
/* Change tmp into a type so that space_needed() works right */
make_type(tmp);
int num_sp = space_needed(tmp2, tmp);
while (num_sp-- > 0)
{
next->str.append(" ");
}
next->str.append(tmp->str);
tmp2 = tmp;
}
while ((tmp2 = chunk_get_next(next)) != tmp)
{
chunk_del(tmp2);
}
set_chunk_type(next, CT_OPERATOR_VAL);
next->orig_col_end = next->orig_col + next->len();
}
set_chunk_parent(next, CT_OPERATOR);
LOG_FMT(LOPERATOR, "%s: %d:%d operator '%s'\n",
__func__, pc->orig_line, pc->orig_col, next->text());
}
/* Change private, public, protected into either a qualifier or label */
if (pc->type == CT_PRIVATE)
{
/* Handle Qt slots - maybe should just check for a CT_WORD? */
if (chunk_is_str(next, "slots", 5) || chunk_is_str(next, "Q_SLOTS", 7))
{
tmp = chunk_get_next(next);
if ((tmp != NULL) && (tmp->type == CT_COLON))
{
next = tmp;
}
}
if (next->type == CT_COLON)
{
set_chunk_type(next, CT_PRIVATE_COLON);
if ((tmp = chunk_get_next_ncnl(next)) != NULL)
{
chunk_flags_set(tmp, PCF_STMT_START | PCF_EXPR_START);
}
}
else
{
set_chunk_type(pc, (chunk_is_str(pc, "signals", 7) || chunk_is_str(pc, "Q_SIGNALS", 9)) ? CT_WORD : CT_QUALIFIER);
}
}
/* Look for <newline> 'EXEC' 'SQL' */
if ((chunk_is_str(pc, "EXEC", 4) && chunk_is_str(next, "SQL", 3)) ||
((*pc->str == '$') && (pc->type != CT_SQL_WORD)))
{
tmp = chunk_get_prev(pc);
if (chunk_is_newline(tmp))
{
if (*pc->str == '$')
{
set_chunk_type(pc, CT_SQL_EXEC);
if (pc->len() > 1)
{
/* SPLIT OFF '$' */
chunk_t nc;
nc = *pc;
pc->str.resize(1);
pc->orig_col_end = pc->orig_col + 1;
nc.type = CT_SQL_WORD;
nc.str.pop_front();
nc.orig_col++;
nc.column++;
chunk_add_after(&nc, pc);
next = chunk_get_next(pc);
}
}
tmp = chunk_get_next(next);
if (chunk_is_str_case(tmp, "BEGIN", 5))
{
set_chunk_type(pc, CT_SQL_BEGIN);
}
else if (chunk_is_str_case(tmp, "END", 3))
{
set_chunk_type(pc, CT_SQL_END);
}
else
{
set_chunk_type(pc, CT_SQL_EXEC);
}
/* Change words into CT_SQL_WORD until CT_SEMICOLON */
while (tmp != NULL)
{
if (tmp->type == CT_SEMICOLON)
{
break;
}
if ((tmp->len() > 0) && (unc_isalpha(*tmp->str) || (*tmp->str == '$')))
{
set_chunk_type(tmp, CT_SQL_WORD);
}
tmp = chunk_get_next_ncnl(tmp);
}
}
}
/* handle MS abomination 'for each' */
if ((pc->type == CT_FOR) && chunk_is_str(next, "each", 4) &&
(next == chunk_get_next(pc)))
{
/* merge the two with a space between */
pc->str.append(' ');
pc->str += next->str;
pc->orig_col_end = next->orig_col_end;
chunk_del(next);
next = chunk_get_next_ncnl(pc);
/* label the 'in' */
if (next && (next->type == CT_PAREN_OPEN))
{
tmp = chunk_get_next_ncnl(next);
while (tmp && (tmp->type != CT_PAREN_CLOSE))
{
if (chunk_is_str(tmp, "in", 2))
{
set_chunk_type(tmp, CT_IN);
break;
}
tmp = chunk_get_next_ncnl(tmp);
}
}
}
/* ObjectiveC allows keywords to be used as identifiers in some situations
* This is a dirty hack to allow some of the more common situations.
*/
if (cpd.lang_flags & LANG_OC)
{
if (((pc->type == CT_IF) ||
(pc->type == CT_FOR) ||
(pc->type == CT_WHILE)) &&
!chunk_is_token(next, CT_PAREN_OPEN))
{
set_chunk_type(pc, CT_WORD);
}
if ((pc->type == CT_DO) &&
(chunk_is_token(prev, CT_MINUS) ||
chunk_is_token(next, CT_SQUARE_CLOSE)))
{
set_chunk_type(pc, CT_WORD);
}
}
/* Another hack to clean up more keyword abuse */
if ((pc->type == CT_CLASS) &&
(chunk_is_token(prev, CT_DOT) ||
chunk_is_token(next, CT_DOT)))
{
set_chunk_type(pc, CT_WORD);
}
/* Detect Objective C class name */
if ((pc->type == CT_OC_IMPL) ||
(pc->type == CT_OC_INTF) ||
(pc->type == CT_OC_PROTOCOL))
{
if (next->type != CT_PAREN_OPEN)
{
set_chunk_type(next, CT_OC_CLASS);
}
set_chunk_parent(next, pc->type);
tmp = chunk_get_next_ncnl(next);
if (tmp != NULL)
{
chunk_flags_set(tmp, PCF_STMT_START | PCF_EXPR_START);
}
tmp = chunk_get_next_type(pc, CT_OC_END, pc->level);
if (tmp != NULL)
{
set_chunk_parent(tmp, pc->type);
}
}
if (pc->type == CT_OC_INTF)
{
tmp = chunk_get_next_ncnl(pc, CNAV_PREPROC);
while ((tmp != NULL) && (tmp->type != CT_OC_END))
{
if (get_token_pattern_class(tmp->type) != PATCLS_NONE)
{
LOG_FMT(LOBJCWORD, "@interface %d:%d change '%s' (%s) to CT_WORD\n",
pc->orig_line, pc->orig_col, tmp->text(),
get_token_name(tmp->type));
set_chunk_type(tmp, CT_WORD);
}
tmp = chunk_get_next_ncnl(tmp, CNAV_PREPROC);
}
}
/* Detect Objective-C categories and class extensions */
/* @interface ClassName (CategoryName) */
/* @implementation ClassName (CategoryName) */
/* @interface ClassName () */
/* @implementation ClassName () */
if (((pc->parent_type == CT_OC_IMPL) ||
(pc->parent_type == CT_OC_INTF) ||
(pc->type == CT_OC_CLASS)) &&
(next->type == CT_PAREN_OPEN))
{
set_chunk_parent(next, pc->parent_type);
tmp = chunk_get_next(next);
if ((tmp != NULL) && (tmp->next != NULL))
{
if (tmp->type == CT_PAREN_CLOSE)
{
//set_chunk_type(tmp, CT_OC_CLASS_EXT);
set_chunk_parent(tmp, pc->parent_type);
}
else
{
set_chunk_type(tmp, CT_OC_CATEGORY);
set_chunk_parent(tmp, pc->parent_type);
}
}
tmp = chunk_get_next_type(pc, CT_PAREN_CLOSE, pc->level);
if (tmp != NULL)
{
set_chunk_parent(tmp, pc->parent_type);
}
}
/* Detect Objective C @property
* @property NSString *stringProperty;
* @property(nonatomic, retain) NSMutableDictionary *shareWith;
*/
if (pc->type == CT_OC_PROPERTY)
{
if (next->type != CT_PAREN_OPEN)
{
chunk_flags_set(next, PCF_STMT_START | PCF_EXPR_START);
}
else
{
set_chunk_parent(next, pc->type);
tmp = chunk_get_next_type(pc, CT_PAREN_CLOSE, pc->level);
if (tmp != NULL)
{
set_chunk_parent(tmp, pc->type);
tmp = chunk_get_next_ncnl(tmp);
if (tmp != NULL)
{
chunk_flags_set(tmp, PCF_STMT_START | PCF_EXPR_START);
tmp = chunk_get_next_type(tmp, CT_SEMICOLON, pc->level);
if (tmp != NULL)
{
set_chunk_parent(tmp, pc->type);
}
}
}
}
}
/* Detect Objective C @selector
* @selector(msgNameWithNoArg)
* @selector(msgNameWith1Arg:)
* @selector(msgNameWith2Args:arg2Name:)
*/
if ((pc->type == CT_OC_SEL) && (next->type == CT_PAREN_OPEN))
{
set_chunk_parent(next, pc->type);
tmp = chunk_get_next(next);
if (tmp != NULL)
{
set_chunk_type(tmp, CT_OC_SEL_NAME);
set_chunk_parent(tmp, pc->type);
while ((tmp = chunk_get_next_ncnl(tmp)) != NULL)
{
if (tmp->type == CT_PAREN_CLOSE)
{
set_chunk_parent(tmp, CT_OC_SEL);
break;
}
set_chunk_type(tmp, CT_OC_SEL_NAME);
set_chunk_parent(tmp, pc->type);
}
}
}
/* Handle special preprocessor junk */
if (pc->type == CT_PREPROC)
{
set_chunk_parent(pc, next->type);
}
/* Detect "pragma region" and "pragma endregion" */
if ((pc->type == CT_PP_PRAGMA) && (next->type == CT_PREPROC_BODY))
{
if ((memcmp(next->str, "region", 6) == 0) ||
(memcmp(next->str, "endregion", 9) == 0))
{
set_chunk_type(pc, (*next->str == 'r') ? CT_PP_REGION : CT_PP_ENDREGION);
set_chunk_parent(prev, pc->type);
}
}
/* Check for C# nullable types '?' is in next */
if ((cpd.lang_flags & LANG_CS) &&
(next->type == CT_QUESTION) &&
(next->orig_col == (pc->orig_col + pc->len())))
{
tmp = chunk_get_next_ncnl(next);
if (tmp != NULL)
{
bool doit = ((tmp->type == CT_PAREN_CLOSE) ||
(tmp->type == CT_ANGLE_CLOSE));
if (tmp->type == CT_WORD)
{
tmp2 = chunk_get_next_ncnl(tmp);
if ((tmp2 != NULL) &&
((tmp2->type == CT_SEMICOLON) ||
(tmp2->type == CT_ASSIGN) ||
(tmp2->type == CT_COMMA) ||
(tmp2->type == CT_BRACE_OPEN)))
{
doit = true;
}
}
if (doit)
{
pc->str += next->str;
pc->orig_col_end = next->orig_col_end;
chunk_del(next);
next = tmp;
}
}
}
/* Change 'default(' into a sizeof-like statement */
if ((cpd.lang_flags & LANG_CS) &&
(pc->type == CT_DEFAULT) &&
(next->type == CT_PAREN_OPEN))
{
set_chunk_type(pc, CT_SIZEOF);
}
if ((pc->type == CT_UNSAFE) && (next->type != CT_BRACE_OPEN))
{
set_chunk_type(pc, CT_QUALIFIER);
}
if (((pc->type == CT_USING) ||
((pc->type == CT_TRY) && (cpd.lang_flags & LANG_JAVA))) &&
(next->type == CT_PAREN_OPEN))
{
set_chunk_type(pc, CT_USING_STMT);
}
/* Add minimal support for C++0x rvalue references */
if ((pc->type == CT_BOOL) && chunk_is_str(pc, "&&", 2))
{
if (prev->type == CT_TYPE)
{
set_chunk_type(pc, CT_BYREF);
}
}
/* HACK: treat try followed by a colon as a qualifier to handle this:
* A::A(int) try : B() { } catch (...) { }
*/
if ((pc->type == CT_TRY) && chunk_is_str(pc, "try", 3) &&
(next != NULL) && (next->type == CT_COLON))
{
set_chunk_type(pc, CT_QUALIFIER);
}
/* If Java's 'synchronized' is in a method declaration, it should be
* a qualifier. */
if ((cpd.lang_flags & LANG_JAVA) &&
(pc->type == CT_SYNCHRONIZED) &&
(next->type != CT_PAREN_OPEN))
{
set_chunk_type(pc, CT_QUALIFIER);
}
// guy 2015-11-05
// change CT_DC_MEMBER + CT_FOR into CT_DC_MEMBER + CT_FUNC_CALL
if ((pc->type == CT_FOR) &&
(pc->prev->type == CT_DC_MEMBER))
{
set_chunk_type(pc, CT_FUNC_CALL);
}
/* TODO: determine other stuff here */
prev = pc;
pc = next;
next = chunk_get_next_ncnl(pc);
}
} // tokenize_cleanup
/**
* Scan backwards to find the most appropriate spot to split the line
* and insert a newline.
*
* See if this needs special function handling.
* Scan backwards and find the best token for the split.
*
* @param start The first chunk that exceeded the limit
*/
static bool split_line(chunk_t *start)
{
LOG_FUNC_ENTRY();
LOG_FMT(LSPLIT, "%s: line %lu, col %d token: '%s' [%s] (IN_FUNC=%d) ",
__func__, start->orig_line, start->column, start->text(),
get_token_name(start->type),
(start->flags & (PCF_IN_FCN_DEF | PCF_IN_FCN_CALL)) != 0);
/**
* break at maximum line length if ls_code_width is true
*/
if (start->flags & PCF_ONE_LINER)
{
LOG_FMT(LSPLIT, " ** ONCE LINER SPLIT **\n");
undo_one_liner(start);
newlines_cleanup_braces(false);
return(false);
}
if (cpd.settings[UO_ls_code_width].b)
{
}
/* Check to see if we are in a for statement */
else if (start->flags & PCF_IN_FOR)
{
LOG_FMT(LSPLIT, " ** FOR SPLIT **\n");
split_for_stmt(start);
if (!is_past_width(start))
{
return(true);
}
LOG_FMT(LSPLIT, "%s: for split didn't work\n", __func__);
}
/* If this is in a function call or prototype, split on commas or right
* after the open paren
*/
else if ((start->flags & PCF_IN_FCN_DEF) ||
((start->level == (start->brace_level + 1)) &&
(start->flags & PCF_IN_FCN_CALL)))
{
LOG_FMT(LSPLIT, " ** FUNC SPLIT **\n");
if (cpd.settings[UO_ls_func_split_full].b)
{
split_fcn_params_full(start);
if (!is_past_width(start))
{
return(true);
}
}
split_fcn_params(start);
return(true);
}
/**
* Try to find the best spot to split the line
*/
cw_entry ent;
memset(&ent, 0, sizeof(ent));
chunk_t *pc = start;
chunk_t *prev;
while (((pc = chunk_get_prev(pc)) != NULL) && !chunk_is_newline(pc))
{
LOG_FMT(LSPLIT, "%s: at %s, col=%lu\n", __func__, pc->text(), pc->orig_col);
if (pc->type != CT_SPACE)
{
try_split_here(ent, pc);
/* break at maximum line length */
if ((ent.pc != NULL) && (cpd.settings[UO_ls_code_width].b))
{
break;
}
}
}
if (ent.pc == NULL)
{
LOG_FMT(LSPLIT, "\n%s: TRY_SPLIT yielded NO SOLUTION for line %lu at %s [%s]\n",
__func__, start->orig_line, start->text(), get_token_name(start->type));
}
else
{
LOG_FMT(LSPLIT, "\n%s: TRY_SPLIT yielded '%s' [%s] on line %lu\n",
__func__, ent.pc->text(), get_token_name(ent.pc->type), ent.pc->orig_line);
LOG_FMT(LSPLIT, "%s: ent at %s, col=%lu\n",
__func__, ent.pc->text(), ent.pc->orig_col);
}
/* Break before the token instead of after it according to the pos_xxx rules */
if (ent.pc == NULL)
{
pc = NULL;
}
else
{
if (((chunk_is_token(ent.pc, CT_ARITH) || chunk_is_token(ent.pc, CT_CARET)) &&
(cpd.settings[UO_pos_arith].tp & TP_LEAD)) ||
(chunk_is_token(ent.pc, CT_ASSIGN) &&
(cpd.settings[UO_pos_assign].tp & TP_LEAD)) ||
(chunk_is_token(ent.pc, CT_COMPARE) &&
(cpd.settings[UO_pos_compare].tp & TP_LEAD)) ||
((chunk_is_token(ent.pc, CT_COND_COLON) ||
chunk_is_token(ent.pc, CT_QUESTION)) &&
(cpd.settings[UO_pos_conditional].tp & TP_LEAD)) ||
(chunk_is_token(ent.pc, CT_BOOL) &&
(cpd.settings[UO_pos_bool].tp & TP_LEAD)))
{
pc = ent.pc;
}
else
{
pc = chunk_get_next(ent.pc);
}
LOG_FMT(LSPLIT, "%s: at %s, col=%lu\n", __func__, pc->text(), pc->orig_col);
}
if (pc == NULL)
{
pc = start;
/* Don't break before a close, comma, or colon */
if ((start->type == CT_PAREN_CLOSE) ||
(start->type == CT_PAREN_OPEN) ||
(start->type == CT_FPAREN_CLOSE) ||
(start->type == CT_FPAREN_OPEN) ||
(start->type == CT_SPAREN_CLOSE) ||
(start->type == CT_SPAREN_OPEN) ||
(start->type == CT_ANGLE_CLOSE) ||
(start->type == CT_BRACE_CLOSE) ||
(start->type == CT_COMMA) ||
(start->type == CT_SEMICOLON) ||
(start->type == CT_VSEMICOLON) ||
(start->len() == 0))
{
LOG_FMT(LSPLIT, " ** NO GO **\n");
/*TODO: Add in logic to handle 'hard' limits by backing up a token */
return(true);
}
}
/* add a newline before pc */
prev = chunk_get_prev(pc);
if ((prev != NULL) && !chunk_is_newline(pc) && !chunk_is_newline(prev))
{
//int plen = (pc->len() < 5) ? pc->len() : 5;
//int slen = (start->len() < 5) ? start->len() : 5;
//LOG_FMT(LSPLIT, " '%.*s' [%s], started on token '%.*s' [%s]\n",
// plen, pc->text(), get_token_name(pc->type),
// slen, start->text(), get_token_name(start->type));
LOG_FMT(LSPLIT, " %s [%s], started on token '%s' [%s]\n",
pc->text(), get_token_name(pc->type),
start->text(), get_token_name(start->type));
split_before_chunk(pc);
}
return(true);
} // split_line
/**
* This renders the chunk list to a file.
*/
void output_text(FILE *pfile)
{
chunk_t *pc;
chunk_t *prev;
int cnt;
int lvlcol;
bool allow_tabs;
cpd.fout = pfile;
for (pc = chunk_get_head(); pc != NULL; pc = chunk_get_next(pc))
{
if (pc->type == CT_NEWLINE)
{
for (cnt = 0; cnt < pc->nl_count; cnt++)
{
add_char('\n');
}
cpd.did_newline = 1;
cpd.column = 1;
LOG_FMT(LOUTIND, " xx\n");
}
else if (pc->type == CT_COMMENT_MULTI)
{
output_comment_multi(pc);
}
else if (pc->type == CT_COMMENT_CPP)
{
pc = output_comment_cpp(pc);
}
else if (pc->len == 0)
{
/* don't do anything for non-visible stuff */
LOG_FMT(LOUTIND, " <%d> -", pc->column);
}
else
{
/* indent to the 'level' first */
if (cpd.did_newline)
{
if (cpd.settings[UO_indent_with_tabs].n == 1)
{
lvlcol = 1 + (pc->brace_level * cpd.settings[UO_indent_columns].n);
if ((pc->column >= lvlcol) && (lvlcol > 1))
{
output_to_column(lvlcol, true);
}
}
allow_tabs = (cpd.settings[UO_indent_with_tabs].n == 2) ||
(chunk_is_comment(pc) &&
(cpd.settings[UO_indent_with_tabs].n != 0));
LOG_FMT(LOUTIND, " %d> col %d/%d - ", pc->orig_line, pc->column, cpd.column);
}
else
{
/* not the first item on a line */
if (cpd.settings[UO_align_keep_tabs].b)
{
allow_tabs = pc->after_tab;
}
else
{
prev = chunk_get_prev(pc);
allow_tabs = (cpd.settings[UO_align_with_tabs].b &&
((pc->flags & PCF_WAS_ALIGNED) != 0) &&
(((pc->column - 1) % cpd.settings[UO_output_tab_size].n) == 0) &&
((prev->column + prev->len + 1) != pc->column));
}
LOG_FMT(LOUTIND, " %d -", pc->column);
}
output_to_column(pc->column, allow_tabs);
add_text_len(pc->str, pc->len);
cpd.did_newline = chunk_is_newline(pc);
}
}
}
static bool split_line(chunk_t *start)
{
LOG_FUNC_ENTRY();
LOG_FMT(LSPLIT, "%s(%d): start->text() '%s', orig_line is %zu, orig_col is %zu, type is %s\n",
__func__, __LINE__, start->text(), start->orig_line, start->orig_col, get_token_name(start->type));
LOG_FMT(LSPLIT, " start->flags ");
log_pcf_flags(LSPLIT, start->flags);
LOG_FMT(LSPLIT, " start->parent_type %s, (PCF_IN_FCN_DEF is %s), (PCF_IN_FCN_CALL is %s)\n",
get_token_name(start->parent_type),
((start->flags & (PCF_IN_FCN_DEF)) != 0) ? "TRUE" : "FALSE",
((start->flags & (PCF_IN_FCN_CALL)) != 0) ? "TRUE" : "FALSE");
// break at maximum line length if ls_code_width is true
if (start->flags & PCF_ONE_LINER)
{
LOG_FMT(LSPLIT, "%s(%d): ** ONCE LINER SPLIT **\n", __func__, __LINE__);
undo_one_liner(start);
newlines_cleanup_braces(false);
// Issue #1352
cpd.changes++;
return(false);
}
LOG_FMT(LSPLIT, "%s(%d):\n", __func__, __LINE__);
if (cpd.settings[UO_ls_code_width].b)
{
}
// Check to see if we are in a for statement
else if (start->flags & PCF_IN_FOR)
{
LOG_FMT(LSPLIT, " ** FOR SPLIT **\n");
split_for_stmt(start);
if (!is_past_width(start))
{
return(true);
}
LOG_FMT(LSPLIT, "%s(%d): for split didn't work\n", __func__, __LINE__);
}
/*
* If this is in a function call or prototype, split on commas or right
* after the open parenthesis
*/
else if ( (start->flags & PCF_IN_FCN_DEF)
|| start->parent_type == CT_FUNC_PROTO // Issue #1169
|| ( (start->level == (start->brace_level + 1))
&& (start->flags & PCF_IN_FCN_CALL)))
{
LOG_FMT(LSPLIT, " ** FUNC SPLIT **\n");
if (cpd.settings[UO_ls_func_split_full].b)
{
split_fcn_params_full(start);
if (!is_past_width(start))
{
return(true);
}
}
split_fcn_params(start);
return(true);
}
/*
* If this is in a template, split on commas, Issue #1170
*/
else if (start->flags & PCF_IN_TEMPLATE)
{
LOG_FMT(LSPLIT, " ** TEMPLATE SPLIT **\n");
split_template(start);
return(true);
}
LOG_FMT(LSPLIT, "%s(%d):\n", __func__, __LINE__);
// Try to find the best spot to split the line
cw_entry ent;
memset(&ent, 0, sizeof(ent));
chunk_t *pc = start;
chunk_t *prev;
while (((pc = chunk_get_prev(pc)) != nullptr) && !chunk_is_newline(pc))
{
LOG_FMT(LSPLIT, "%s(%d): at %s, orig_line=%zu, orig_col=%zu\n",
__func__, __LINE__, pc->text(), pc->orig_line, pc->orig_col);
if (pc->type != CT_SPACE)
{
try_split_here(ent, pc);
// break at maximum line length
if (ent.pc != nullptr && (cpd.settings[UO_ls_code_width].b))
{
break;
}
}
}
if (ent.pc == nullptr)
{
LOG_FMT(LSPLIT, "\n%s(%d): TRY_SPLIT yielded NO SOLUTION for orig_line %zu at '%s' [%s]\n",
__func__, __LINE__, start->orig_line, start->text(), get_token_name(start->type));
}
else
{
LOG_FMT(LSPLIT, "\n%s(%d): TRY_SPLIT yielded '%s' [%s] on orig_line %zu\n",
__func__, __LINE__, ent.pc->text(), get_token_name(ent.pc->type), ent.pc->orig_line);
LOG_FMT(LSPLIT, "%s(%d): ent at '%s', orig_col is %zu\n",
__func__, __LINE__, ent.pc->text(), ent.pc->orig_col);
}
// Break before the token instead of after it according to the pos_xxx rules
if (ent.pc == nullptr)
{
pc = nullptr;
}
else
{
if ( ( ( chunk_is_token(ent.pc, CT_ARITH)
|| chunk_is_token(ent.pc, CT_CARET))
&& (cpd.settings[UO_pos_arith].tp & TP_LEAD))
|| ( chunk_is_token(ent.pc, CT_ASSIGN)
&& (cpd.settings[UO_pos_assign].tp & TP_LEAD))
|| ( chunk_is_token(ent.pc, CT_COMPARE)
&& (cpd.settings[UO_pos_compare].tp & TP_LEAD))
|| ( ( chunk_is_token(ent.pc, CT_COND_COLON)
|| chunk_is_token(ent.pc, CT_QUESTION))
&& (cpd.settings[UO_pos_conditional].tp & TP_LEAD))
|| ( chunk_is_token(ent.pc, CT_BOOL)
&& (cpd.settings[UO_pos_bool].tp & TP_LEAD)))
{
pc = ent.pc;
}
else
{
pc = chunk_get_next(ent.pc);
}
LOG_FMT(LSPLIT, "%s(%d): at '%s', orig_col is %zu\n",
__func__, __LINE__, pc->text(), pc->orig_col);
}
if (pc == nullptr)
{
pc = start;
// Don't break before a close, comma, or colon
if ( start->type == CT_PAREN_CLOSE
|| start->type == CT_PAREN_OPEN
|| start->type == CT_FPAREN_CLOSE
|| start->type == CT_FPAREN_OPEN
|| start->type == CT_SPAREN_CLOSE
|| start->type == CT_SPAREN_OPEN
|| start->type == CT_ANGLE_CLOSE
|| start->type == CT_BRACE_CLOSE
|| start->type == CT_COMMA
|| start->type == CT_SEMICOLON
|| start->type == CT_VSEMICOLON
|| start->len() == 0)
{
LOG_FMT(LSPLIT, " ** NO GO **\n");
// TODO: Add in logic to handle 'hard' limits by backing up a token
return(true);
}
}
// add a newline before pc
prev = chunk_get_prev(pc);
if ( prev != nullptr
&& !chunk_is_newline(pc)
&& !chunk_is_newline(prev))
{
//int plen = (pc->len() < 5) ? pc->len() : 5;
//int slen = (start->len() < 5) ? start->len() : 5;
//LOG_FMT(LSPLIT, " '%.*s' [%s], started on token '%.*s' [%s]\n",
// plen, pc->text(), get_token_name(pc->type),
// slen, start->text(), get_token_name(start->type));
LOG_FMT(LSPLIT, "%s(%d): text() '%s', type [%s], started on token '%s', type [%s]\n",
__func__, __LINE__, pc->text(), get_token_name(pc->type),
start->text(), get_token_name(start->type));
split_before_chunk(pc);
}
return(true);
} // split_line
/**
* Scan everything at the current level until the close brace and find the
* variable def align column. Also aligns bit-colons, but that assumes that
* bit-types are the same! But that should always be the case...
*/
static chunk_t *align_var_def_brace(chunk_t *start, int span, int *p_nl_count)
{
chunk_t *pc;
chunk_t *next;
chunk_t *prev;
UINT64 align_mask = PCF_IN_FCN_DEF | PCF_VAR_1ST;
int myspan = span;
int mythresh = 0;
int mygap = 0;
AlignStack as; /* var/proto/def */
AlignStack as_bc; /* bit-colon */
AlignStack as_at; /* attribute */
AlignStack as_br; /* one-liner brace open */
bool fp_active = cpd.settings[UO_align_mix_var_proto].b;
bool fp_look_bro = false;
if (start == NULL)
{
return(NULL);
}
/* Override the span, if this is a struct/union */
if ((start->parent_type == CT_STRUCT) ||
(start->parent_type == CT_UNION))
{
myspan = cpd.settings[UO_align_var_struct_span].n;
mythresh = cpd.settings[UO_align_var_struct_thresh].n;
mygap = cpd.settings[UO_align_var_struct_gap].n;
}
else
{
mythresh = cpd.settings[UO_align_var_def_thresh].n;
mygap = cpd.settings[UO_align_var_def_gap].n;
}
/* can't be any variable definitions in a "= {" block */
prev = chunk_get_prev_ncnl(start);
if ((prev != NULL) && (prev->type == CT_ASSIGN))
{
LOG_FMT(LAVDB, "%s: start=%.*s [%s] on line %d (abort due to assign)\n", __func__,
start->len, start->str, get_token_name(start->type), start->orig_line);
pc = chunk_get_next_type(start, CT_BRACE_CLOSE, start->level);
return(chunk_get_next_ncnl(pc));
}
LOG_FMT(LAVDB, "%s: start=%.*s [%s] on line %d\n", __func__,
start->len, start->str, get_token_name(start->type), start->orig_line);
if (!cpd.settings[UO_align_var_def_inline].b)
{
align_mask |= PCF_VAR_INLINE;
}
/* Set up the var/proto/def aligner */
as.Start(myspan, mythresh);
as.m_gap = mygap;
as.m_star_style = (AlignStack::StarStyle)cpd.settings[UO_align_var_def_star_style].n;
as.m_amp_style = (AlignStack::StarStyle)cpd.settings[UO_align_var_def_amp_style].n;
/* Set up the bit colon aligner */
as_bc.Start(myspan, 0);
as_bc.m_gap = cpd.settings[UO_align_var_def_colon_gap].n;
as_at.Start(myspan, 0);
/* Set up the brace open aligner */
as_br.Start(myspan, mythresh);
as_br.m_gap = cpd.settings[UO_align_single_line_brace_gap].n;
bool did_this_line = false;
pc = chunk_get_next(start);
while ((pc != NULL) && ((pc->level >= start->level) || (pc->level == 0)))
{
if (chunk_is_comment(pc))
{
if (pc->nl_count > 0)
{
as.NewLines(pc->nl_count);
as_bc.NewLines(pc->nl_count);
as_at.NewLines(pc->nl_count);
as_br.NewLines(pc->nl_count);
}
pc = chunk_get_next(pc);
continue;
}
if (fp_active)
{
if ((pc->type == CT_FUNC_PROTO) ||
((pc->type == CT_FUNC_DEF) &&
cpd.settings[UO_align_single_line_func].b))
{
LOG_FMT(LAVDB, " add=[%.*s] line=%d col=%d level=%d\n",
pc->len, pc->str, pc->orig_line, pc->orig_col, pc->level);
as.Add(pc);
fp_look_bro = (pc->type == CT_FUNC_DEF) &&
cpd.settings[UO_align_single_line_brace].b;
}
else if (fp_look_bro &&
(pc->type == CT_BRACE_OPEN) &&
(pc->flags & PCF_ONE_LINER))
{
as_br.Add(pc);
fp_look_bro = false;
}
}
/* process nested braces */
if (pc->type == CT_BRACE_OPEN)
{
int sub_nl_count = 0;
pc = align_var_def_brace(pc, span, &sub_nl_count);
if (sub_nl_count > 0)
{
fp_look_bro = false;
did_this_line = false;
as.NewLines(sub_nl_count);
as_bc.NewLines(sub_nl_count);
as_at.NewLines(sub_nl_count);
as_br.NewLines(sub_nl_count);
if (p_nl_count != NULL)
{
*p_nl_count += sub_nl_count;
}
}
continue;
}
/* Done with this brace set? */
if (pc->type == CT_BRACE_CLOSE)
{
pc = chunk_get_next(pc);
break;
}
if (chunk_is_newline(pc))
{
fp_look_bro = false;
did_this_line = false;
as.NewLines(pc->nl_count);
as_bc.NewLines(pc->nl_count);
as_at.NewLines(pc->nl_count);
as_br.NewLines(pc->nl_count);
if (p_nl_count != NULL)
{
*p_nl_count += pc->nl_count;
}
}
/* don't align stuff inside parens/squares/angles */
if (pc->level > pc->brace_level)
{
pc = chunk_get_next(pc);
continue;
}
/* If this is a variable def, update the max_col */
if ((pc->type != CT_FUNC_CLASS) &&
((pc->flags & align_mask) == PCF_VAR_1ST) &&
((pc->level == (start->level + 1)) ||
(pc->level == 0)))
{
if (!did_this_line)
{
LOG_FMT(LAVDB, " add=[%.*s] line=%d col=%d level=%d\n",
pc->len, pc->str, pc->orig_line, pc->orig_col, pc->level);
as.Add(pc);
if (cpd.settings[UO_align_var_def_colon].b)
{
next = chunk_get_next_nc(pc);
if (next->type == CT_BIT_COLON)
{
as_bc.Add(next);
}
}
if (cpd.settings[UO_align_var_def_attribute].b)
{
next = pc;
while ((next = chunk_get_next_nc(next)) != NULL)
{
if (next->type == CT_ATTRIBUTE)
{
as_at.Add(next);
break;
}
if ((next->type == CT_SEMICOLON) || chunk_is_newline(next))
{
break;
}
}
}
}
did_this_line = true;
}
else if (pc->type == CT_BIT_COLON)
{
if (!did_this_line)
{
as_bc.Add(pc);
did_this_line = true;
}
}
pc = chunk_get_next(pc);
}
as.End();
as_bc.End();
as_at.End();
as_br.End();
return(pc);
}
/**
* Figures out where to split a function def/proto/call
*
* For fcn protos and defs. Also fcn calls where level == brace_level:
* - find the open fparen
* + if it doesn't have a newline right after it
* * see if all parameters will fit individually after the paren
* * if not, throw a newline after the open paren & return
* - scan backwards to the open fparen or comma
* + if there isn't a newline after that item, add one & return
* + otherwise, add a newline before the start token
*
* @param start the offending token
* @return the token that should have a newline
* inserted before it
*/
static void split_fcn_params(chunk_t *start)
{
LOG_FMT(LSPLIT, " %s: ", __func__);
chunk_t *next;
chunk_t *prev;
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 */
}
pc = chunk_get_next(fpo);
if (!chunk_is_newline(pc))
{
int min_col = pc->column;
int max_width = 0;
int cur_width = 0;
int last_col = -1;
LOG_FMT(LSPLIT, " mincol=%d, max_width=%d ",
min_col,
cpd.settings[UO_code_width].n - min_col);
while (pc != NULL)
{
if (chunk_is_newline(pc))
{
last_col = -1;
}
else
{
if (last_col < 0)
{
last_col = pc->column;
}
cur_width += (pc->column - last_col) + pc->len();
last_col = pc->column + pc->len();
if ((pc->type == CT_COMMA) ||
(pc->type == CT_FPAREN_CLOSE))
{
cur_width--;
LOG_FMT(LSPLIT, " width=%d ", cur_width);
if (cur_width > max_width)
{
max_width = cur_width;
if ((max_width + min_col) > cpd.settings[UO_code_width].n)
{
break;
}
}
cur_width = 0;
last_col = -1;
if (pc->type == CT_FPAREN_CLOSE)
{
break;
}
}
}
pc = chunk_get_next(pc);
}
// don't split function w/o parameters
next = chunk_get_next(fpo);
if (((max_width + min_col) > cpd.settings[UO_code_width].n) &&
next->type != CT_FPAREN_CLOSE)
{
LOG_FMT(LSPLIT, " - A param won't fit, nl after open paren.");
split_before_chunk(chunk_get_next(fpo));
return;
}
}
/* back up until the prev is a comma */
prev = pc;
while ((prev = chunk_get_prev(prev)) != NULL)
{
if (chunk_is_newline(prev) ||
(prev->type == CT_COMMA))
{
break;
}
if (prev->type == CT_FPAREN_OPEN)
{
/* Don't split "()" */
pc = chunk_get_next(prev);
if (pc->type != c_token_t(prev->type + 1))
{
break;
}
}
}
if (prev != NULL)
{
LOG_FMT(LSPLIT, " -- ended on [%s] -- ", get_token_name(prev->type));
}
if (prev != NULL)
{
split_before_chunk(chunk_get_next(prev));
}
}
/**
* Aligns all assignment operators on the same level as first, starting with
* first.
*
* For variable definitions, only consider the '=' for the first variable.
* Otherwise, only look at the first '=' on the line.
*/
chunk_t *align_assign(chunk_t *first, int span, int thresh)
{
int my_level;
chunk_t *pc;
int tmp;
int var_def_cnt = 0;
int equ_count = 0;
if (first == NULL)
{
return(NULL);
}
my_level = first->level;
if (span <= 0)
{
return(chunk_get_next(first));
}
LOG_FMT(LALASS, "%s[%d]: checking %.*s on line %d - span=%d thresh=%d\n",
__func__, my_level, first->len, first->str, first->orig_line,
span, thresh);
AlignStack as; // regular assigns
AlignStack vdas; // variable def assigns
as.Start(span, thresh);
as.m_right_align = true;
vdas.Start(span, thresh);
vdas.m_right_align = true;
pc = first;
while ((pc != NULL) && ((pc->level >= my_level) || (pc->level == 0)))
{
/* Don't check inside PAREN or SQUARE groups */
if ((pc->type == CT_SPAREN_OPEN) ||
(pc->type == CT_FPAREN_OPEN) ||
(pc->type == CT_SQUARE_OPEN) ||
(pc->type == CT_PAREN_OPEN))
{
tmp = pc->orig_line;
pc = chunk_skip_to_match(pc);
if (pc != NULL)
{
as.NewLines(pc->orig_line - tmp);
vdas.NewLines(pc->orig_line - tmp);
}
continue;
}
/* Recurse if a brace set is found */
if ((pc->type == CT_BRACE_OPEN) ||
(pc->type == CT_VBRACE_OPEN))
{
int myspan;
int mythresh;
tmp = pc->orig_line;
if (pc->parent_type == CT_ENUM)
{
myspan = cpd.settings[UO_align_enum_equ_span].n;
mythresh = cpd.settings[UO_align_enum_equ_thresh].n;
}
else
{
myspan = cpd.settings[UO_align_assign_span].n;
mythresh = cpd.settings[UO_align_assign_thresh].n;
}
pc = align_assign(chunk_get_next_ncnl(pc), myspan, mythresh);
if (pc != NULL)
{
/* do a rough count of the number of lines just spanned */
as.NewLines(pc->orig_line - tmp);
vdas.NewLines(pc->orig_line - tmp);
}
continue;
}
if (chunk_is_newline(pc))
{
as.NewLines(pc->nl_count);
vdas.NewLines(pc->nl_count);
var_def_cnt = 0;
equ_count = 0;
}
else if ((pc->flags & PCF_VAR_DEF) != 0)
{
var_def_cnt++;
}
else if (var_def_cnt > 1)
{
/* we hit the second variable def - don't look for assigns */
}
else if ((equ_count == 0) && (pc->type == CT_ASSIGN))
{
//fprintf(stderr, "%s: ** %s level=%d line=%d col=%d prev=%d count=%d\n",
// __func__, pc->str, pc->level, pc->orig_line, pc->orig_col, prev_equ_type,
// equ_count);
equ_count++;
if (var_def_cnt != 0)
{
vdas.Add(pc);
}
else
{
as.Add(pc);
}
}
pc = chunk_get_next(pc);
}
as.End();
vdas.End();
if (pc != NULL)
{
LOG_FMT(LALASS, "%s: done on %.*s on line %d\n",
__func__, pc->len, pc->str, pc->orig_line);
}
else
{
LOG_FMT(LALASS, "%s: done on NULL\n", __func__);
}
return(pc);
}
static void align_same_func_call_params()
{
chunk_t *pc;
chunk_t *align_root = NULL;
chunk_t *align_cur = NULL;
int align_len = 0;
chunk_t *chunks[16];
AlignStack as[16];
AlignStack fcn_as;
int max_idx = -1;
int cur_as;
int idx;
const char *add_str = NULL;
fcn_as.Start(3);
for (pc = chunk_get_head(); pc != NULL; pc = chunk_get_next(pc))
{
if (pc->type != CT_FUNC_CALL)
{
if (chunk_is_newline(pc))
{
for (idx = 0; idx <= max_idx; idx++)
{
as[idx].NewLines(pc->nl_count);
}
fcn_as.NewLines(pc->nl_count);
}
continue;
}
/* Only align function calls that are right after a newline */
if (!chunk_is_newline(chunk_get_prev(pc)))
{
continue;
}
fcn_as.Add(pc);
add_str = NULL;
if (align_root != NULL)
{
if ((pc->len == align_root->len) &&
(memcmp(pc->str, align_root->str, pc->len) == 0))
{
align_cur->align.next = pc;
align_cur = pc;
align_len++;
add_str = " Add";
}
else
{
LOG_FMT(LASFCP, " ++ Ended with %d fcns\n", align_len);
/* Flush it all! */
fcn_as.Flush();
for (idx = 0; idx <= max_idx; idx++)
{
as[idx].Flush();
}
align_root = NULL;
}
}
if (align_root == NULL)
{
align_root = pc;
align_cur = pc;
align_len = 1;
add_str = "Start";
}
if (add_str != NULL)
{
LOG_FMT(LASFCP, "%s '%.*s' on line %d -",
add_str, pc->len, pc->str, pc->orig_line);
cur_as = align_params(pc, chunks, ARRAY_SIZE(chunks));
LOG_FMT(LASFCP, " %d items:", cur_as);
for (idx = 0; idx < cur_as; idx++)
{
LOG_FMT(LASFCP, " [%.*s]", chunks[idx]->len, chunks[idx]->str);
if (idx > max_idx)
{
as[idx].Start(3);
if (!cpd.settings[UO_align_number_left].b)
{
if ((chunks[idx]->type == CT_NUMBER_FP) ||
(chunks[idx]->type == CT_NUMBER) ||
(chunks[idx]->type == CT_POS) ||
(chunks[idx]->type == CT_NEG))
{
as[idx].m_right_align = true;
}
}
max_idx = idx;
}
as[idx].Add(chunks[idx]);
}
LOG_FMT(LASFCP, "\n");
}
}
fcn_as.End();
for (idx = 0; idx <= max_idx; idx++)
{
as[idx].End();
}
}
/**
* Scans the whole file for #defines. Aligns all within X lines of each other
*/
void align_preprocessor(void)
{
chunk_t *pc;
AlignStack as; // value macros
AlignStack asf; // function macros
AlignStack *cur_as = &as;
as.Start(cpd.settings[UO_align_pp_define_span].n);
as.m_gap = cpd.settings[UO_align_pp_define_gap].n;
asf.Start(cpd.settings[UO_align_pp_define_span].n);
asf.m_gap = cpd.settings[UO_align_pp_define_gap].n;
pc = chunk_get_head();
while (pc != NULL)
{
/* Note: not counting back-slash newline combos */
if (pc->type == CT_NEWLINE)
{
as.NewLines(pc->nl_count);
asf.NewLines(pc->nl_count);
}
/* If we aren't on a 'define', then skip to the next non-comment */
if (pc->type != CT_PP_DEFINE)
{
pc = chunk_get_next_nc(pc);
continue;
}
/* step past the 'define' */
pc = chunk_get_next_nc(pc);
if (pc == NULL)
{
break;
}
LOG_FMT(LALPP, "%s: define (%.*s) on line %d col %d\n",
__func__, pc->len, pc->str, pc->orig_line, pc->orig_col);
cur_as = &as;
if (pc->type == CT_MACRO_FUNC)
{
cur_as = &asf;
/* Skip to the close paren */
pc = chunk_get_next_nc(pc); // point to open (
pc = chunk_get_next_type(pc, CT_FPAREN_CLOSE, pc->level);
LOG_FMT(LALPP, "%s: jumped to (%.*s) on line %d col %d\n",
__func__, pc->len, pc->str, pc->orig_line, pc->orig_col);
}
/* step to the value past the close paren or the macro name */
pc = chunk_get_next(pc);
if (pc == NULL)
{
break;
}
/* don't align anything if the first line ends with a newline before
* a value is given */
if (!chunk_is_newline(pc))
{
LOG_FMT(LALPP, "%s: align on '%.*s', line %d col %d\n",
__func__, pc->len, pc->str, pc->orig_line, pc->orig_col);
cur_as->Add(pc);
}
}
as.End();
asf.End();
}
/**
* Aligns OC declarations on the colon
* -(void) doSomething: (NSString*) param1
* with: (NSString*) param2
*/
static void align_oc_decl_colon(void)
{
chunk_t *pc = chunk_get_head();
chunk_t *tmp;
chunk_t *tmp2;
AlignStack cas; /* for the colons */
AlignStack nas; /* for the parameter label */
int level;
bool did_line;
cas.Start(4);
nas.Start(4);
nas.m_right_align = true;
while (pc != NULL)
{
if (pc->type != CT_OC_SCOPE)
{
pc = chunk_get_next(pc);
continue;
}
nas.Reset();
cas.Reset();
level = pc->level;
pc = chunk_get_next_ncnl(pc, CNAV_PREPROC);
did_line = false;
while ((pc != NULL) && (pc->level >= level))
{
/* The decl ends with an open brace or semicolon */
if ((pc->type == CT_BRACE_OPEN) || chunk_is_semicolon(pc))
{
break;
}
if (chunk_is_newline(pc))
{
nas.NewLines(pc->nl_count);
cas.NewLines(pc->nl_count);
did_line = false;
}
else if (!did_line && (pc->type == CT_OC_COLON))
{
cas.Add(pc);
tmp = chunk_get_prev(pc, CNAV_PREPROC);
tmp2 = chunk_get_prev_ncnl(tmp, CNAV_PREPROC);
/* Check for an un-labeled parameter */
if ((tmp != NULL) &&
(tmp2 != NULL)
&&
((tmp->type == CT_WORD) ||
(tmp->type == CT_TYPE) ||
(tmp->type == CT_OC_MSG_DECL))
&&
((tmp2->type == CT_WORD) ||
(tmp2->type == CT_TYPE) ||
(tmp2->type == CT_PAREN_CLOSE)))
{
nas.Add(tmp);
}
did_line = true;
}
pc = chunk_get_next(pc, CNAV_PREPROC);
}
nas.End();
cas.End();
}
}
/**
* Generically aligns on '=', '{', '(' and item after ','
* It scans the first line and picks up the location of those tags.
* It then scans subsequent lines and adjusts the column.
* Finally it does a second pass to align everything.
*
* Aligns all the '=' signs in stucture assignments.
* a = {
* .a = 1;
* .type = fast;
* };
*
* And aligns on '{', numbers, strings, words.
* colors[] = {
* {"red", {255, 0, 0}}, {"blue", { 0, 255, 0}},
* {"green", { 0, 0, 255}}, {"purple", {255, 255, 0}},
* };
*
* For the C99 indexed array assignment, the leading []= is skipped (no aligning)
* struct foo_t bars[] =
* {
* [0] = { .name = "bar",
* .age = 21 },
* [1] = { .name = "barley",
* .age = 55 },
* };
*
* NOTE: this assumes that spacing is at the minimum correct spacing (ie force)
* if it isn't, some extra spaces will be inserted.
*
* @param start Points to the open brace chunk
*/
static void align_init_brace(chunk_t *start)
{
int idx;
chunk_t *pc;
chunk_t *next;
chunk_t *prev;
chunk_t *num_token = NULL;
cpd.al_cnt = 0;
cpd.al_c99_array = false;
LOG_FMT(LALBR, "%s: line %d, col %d\n", __func__, start->orig_line, start->orig_col);
pc = chunk_get_next_ncnl(start);
pc = scan_ib_line(pc, true);
if ((pc == NULL) || ((pc->type == CT_BRACE_CLOSE) &&
(pc->parent_type == CT_ASSIGN)))
{
/* single line - nothing to do */
return;
}
do
{
pc = scan_ib_line(pc, false);
/* debug dump the current frame */
align_log_al(LALBR, pc->orig_line);
while (chunk_is_newline(pc))
{
pc = chunk_get_next(pc);
}
} while ((pc != NULL) && (pc->level > start->level));
/* debug dump the current frame */
align_log_al(LALBR, start->orig_line);
if (cpd.settings[UO_align_on_tabstop].b && (cpd.al_cnt >= 1) &&
(cpd.al[0].type == CT_ASSIGN))
{
int rem = (cpd.al[0].col - 1) % cpd.settings[UO_output_tab_size].n;
if (rem != 0)
{
LOG_FMT(LALBR, "%s: col=%d rem=%d", __func__, cpd.al[0].col, rem);
cpd.al[0].col += cpd.settings[UO_output_tab_size].n - rem;
}
}
pc = chunk_get_next(start);
idx = 0;
do
{
if ((idx == 0) && (pc->type == CT_SQUARE_OPEN))
{
pc = chunk_get_next_type(pc, CT_ASSIGN, pc->level);
pc = chunk_get_next(pc);
if (pc != NULL)
{
LOG_FMT(LALBR, " -%d- skipped '[] =' to %s\n",
pc->orig_line, get_token_name(pc->type));
}
continue;
}
next = pc;
if (idx < cpd.al_cnt)
{
LOG_FMT(LALBR, " (%d) check %s vs %s -- ",
idx, get_token_name(pc->type), get_token_name(cpd.al[idx].type));
if (pc->type == cpd.al[idx].type)
{
if ((idx == 0) && cpd.al_c99_array)
{
prev = chunk_get_prev(pc);
if (chunk_is_newline(prev))
{
pc->flags |= PCF_DONT_INDENT;
}
}
LOG_FMT(LALBR, " [%.*s] to col %d\n", pc->len, pc->str, cpd.al[idx].col);
if (num_token != NULL)
{
int col_diff = pc->column - num_token->column;
reindent_line(num_token, cpd.al[idx].col - col_diff);
//LOG_FMT(LSYS, "-= %d =- NUM indent [%.*s] col=%d diff=%d\n",
// num_token->orig_line,
// num_token->len, num_token->str, cpd.al[idx - 1].col, col_diff);
num_token->flags |= PCF_WAS_ALIGNED;
num_token = NULL;
}
/* Comma's need to 'fall back' to the previous token */
if (pc->type == CT_COMMA)
{
next = chunk_get_next(pc);
if ((next != NULL) && !chunk_is_newline(next))
{
//LOG_FMT(LSYS, "-= %d =- indent [%.*s] col=%d len=%d\n",
// next->orig_line,
// next->len, next->str, cpd.al[idx].col, cpd.al[idx].len);
if ((idx < (cpd.al_cnt - 1)) &&
cpd.settings[UO_align_number_left].b &&
((next->type == CT_NUMBER_FP) ||
(next->type == CT_NUMBER) ||
(next->type == CT_POS) ||
(next->type == CT_NEG)))
{
/* Need to wait until the next match to indent numbers */
num_token = next;
}
else
{
reindent_line(next, cpd.al[idx].col + cpd.al[idx].len);
next->flags |= PCF_WAS_ALIGNED;
}
}
}
else
{
/* first item on the line */
reindent_line(pc, cpd.al[idx].col);
pc->flags |= PCF_WAS_ALIGNED;
/* see if we need to right-align a number */
if ((idx < (cpd.al_cnt - 1)) &&
cpd.settings[UO_align_number_left].b)
{
next = chunk_get_next(pc);
if ((next != NULL) && !chunk_is_newline(next) &&
((next->type == CT_NUMBER_FP) ||
(next->type == CT_NUMBER) ||
(next->type == CT_POS) ||
(next->type == CT_NEG)))
{
/* Need to wait until the next match to indent numbers */
num_token = next;
}
}
}
idx++;
}
else
{
LOG_FMT(LALBR, " no match\n");
}
}
if (chunk_is_newline(pc) || chunk_is_newline(next))
{
idx = 0;
}
pc = chunk_get_next(pc);
} while ((pc != NULL) && (pc->level > start->level));
}
void tokenize_cleanup(void)
{
chunk_t *pc = chunk_get_head();
chunk_t *prev = NULL;
chunk_t *next;
chunk_t *tmp;
chunk_t *tmp2;
bool in_type_cast = false;
pc = chunk_get_head();
next = chunk_get_next_ncnl(pc);
while ((pc != NULL) && (next != NULL))
{
/* Change '[' + ']' into '[]' */
if ((pc->type == CT_SQUARE_OPEN) && (next->type == CT_SQUARE_CLOSE))
{
pc->type = CT_TSQUARE;
pc->str = "[]";
pc->len = 2;
chunk_del(next);
pc->orig_col_end += 1;
next = chunk_get_next_ncnl(pc);
}
if ((pc->type == CT_DOT) && ((cpd.lang_flags & LANG_ALLC) != 0))
{
pc->type = CT_MEMBER;
}
/* Determine the version stuff (D only) */
if (pc->type == CT_VERSION)
{
if (next->type == CT_PAREN_OPEN)
{
pc->type = CT_IF;
}
else
{
if (next->type != CT_ASSIGN)
{
LOG_FMT(LERR, "%s:%d %s: version: Unexpected token %s\n",
cpd.filename, pc->orig_line, __func__, get_token_name(next->type));
cpd.error_count++;
}
pc->type = CT_WORD;
}
}
/**
* Change CT_BASE before CT_PAREN_OPEN to CT_WORD.
* public myclass() : base() {
* }
*/
if ((pc->type == CT_BASE) && (next->type == CT_PAREN_OPEN))
{
pc->type = CT_WORD;
}
/**
* Change CT_WORD after CT_ENUM, CT_UNION, or CT_STRUCT to CT_TYPE
* Change CT_WORD before CT_WORD to CT_TYPE
*/
if (next->type == CT_WORD)
{
if ((pc->type == CT_ENUM) ||
(pc->type == CT_UNION) ||
(pc->type == CT_STRUCT))
{
next->type = CT_TYPE;
}
if (pc->type == CT_WORD)
{
pc->type = CT_TYPE;
}
}
/* change extern to qualifier if extern isn't followed by a string or
* an open paren
*/
if (pc->type == CT_EXTERN)
{
if (next->type == CT_STRING)
{
/* Probably 'extern "C"' */
}
else if (next->type == CT_PAREN_OPEN)
{
/* Probably 'extern (C)' */
}
else
{
/* Something else followed by a open brace */
tmp = chunk_get_next_ncnl(next);
if ((tmp != NULL) || (tmp->type != CT_BRACE_OPEN))
{
pc->type = CT_QUALIFIER;
}
}
}
/**
* Change CT_STAR to CT_PTR_TYPE if preceded by CT_TYPE,
* CT_QUALIFIER, or CT_PTR_TYPE.
*/
if ((next->type == CT_STAR) &&
((pc->type == CT_TYPE) ||
(pc->type == CT_QUALIFIER) ||
(pc->type == CT_PTR_TYPE)))
{
next->type = CT_PTR_TYPE;
}
if ((pc->type == CT_TYPE_CAST) &&
(next->type == CT_ANGLE_OPEN))
{
next->parent_type = CT_TYPE_CAST;
in_type_cast = true;
}
/**
* Change angle open/close to CT_COMPARE, if not a template thingy
*/
if ((pc->type == CT_ANGLE_OPEN) && (pc->parent_type != CT_TYPE_CAST))
{
check_template(pc);
}
if ((pc->type == CT_ANGLE_CLOSE) && (pc->parent_type != CT_TEMPLATE))
{
if (in_type_cast)
{
in_type_cast = false;
pc->parent_type = CT_TYPE_CAST;
}
else
{
pc->type = CT_COMPARE;
}
}
if ((cpd.lang_flags & LANG_D) != 0)
{
/* Check for the D string concat symbol '~' */
if ((pc->type == CT_INV) &&
((prev->type == CT_STRING) ||
(prev->type == CT_WORD) ||
(next->type == CT_STRING)))
{
pc->type = CT_CONCAT;
}
/* Check for the D template symbol '!' */
if ((pc->type == CT_NOT) &&
(prev->type == CT_WORD) &&
(next->type == CT_PAREN_OPEN))
{
pc->type = CT_D_TEMPLATE;
}
}
if ((cpd.lang_flags & LANG_CPP) != 0)
{
/* Change Word before '::' into a type */
if ((pc->type == CT_WORD) && (next->type == CT_DC_MEMBER))
{
pc->type = CT_TYPE;
}
}
/* Change get/set to CT_WORD if not followed by a brace open */
if ((pc->type == CT_GETSET) && (next->type != CT_BRACE_OPEN))
{
if ((next->type == CT_SEMICOLON) &&
((prev->type == CT_BRACE_CLOSE) ||
(prev->type == CT_BRACE_OPEN) ||
(prev->type == CT_SEMICOLON)))
{
pc->type = CT_GETSET_EMPTY;
next->parent_type = CT_GETSET;
}
else
{
pc->type = CT_WORD;
}
}
/* Change item after operator (>=, ==, etc) to a CT_OPERATOR_VAL
* Usually the next item is part of the operator.
* In a few cases the next few tokens are part of it:
* operator + - common case
* operator ()
* operator [] - already converted to TSQUARE
* operator new []
* operator delete []
* operator const char *
* operator std::allocator<U>
*
* In all cases except the last, this will put the entire operator value
* in one chunk.
*/
if (pc->type == CT_OPERATOR)
{
/* Handle special case of () operator -- [] already handled */
if (next->type == CT_PAREN_OPEN)
{
tmp = chunk_get_next(next);
if ((tmp != NULL) && (tmp->type == CT_PAREN_CLOSE))
{
next->str = "()";
next->len = 2;
next->type = CT_OPERATOR_VAL;
chunk_del(tmp);
next->orig_col_end += 1;
}
}
else if (next->flags & PCF_PUNCTUATOR)
{
next->type = CT_OPERATOR_VAL;
}
else
{
next->type = CT_TYPE;
/* Replace next with a collection of all tokens that are part of
* the type.
*/
char opbuf[256];
int len;
len = snprintf(opbuf, sizeof(opbuf), "%.*s",
next->len, next->str);
tmp2 = next;
while ((tmp = chunk_get_next(tmp2)) != NULL)
{
if ((tmp->type != CT_WORD) &&
(tmp->type != CT_TYPE) &&
(tmp->type != CT_QUALIFIER) &&
(tmp->type != CT_STAR) &&
(tmp->type != CT_AMP) &&
(tmp->type != CT_TSQUARE))
{
break;
}
len += snprintf(opbuf + len, sizeof(opbuf) - len, "%s%.*s",
space_needed(tmp2, tmp) ? " " : "",
tmp->len, tmp->str);
tmp2 = tmp;
}
while ((tmp2 = chunk_get_next(next)) != tmp)
{
chunk_del(tmp2);
}
next->str = strdup(opbuf);
next->len = len;
next->flags |= PCF_OWN_STR;
next->type = CT_OPERATOR_VAL;
next->orig_col_end = next->orig_col + next->len;
}
next->parent_type = CT_OPERATOR;
LOG_FMT(LOPERATOR, "%s: %d:%d operator '%.*s'\n",
__func__, pc->orig_line, pc->orig_col,
next->len, next->str);
}
/* Change private, public, protected into either a qualifier or label */
if (pc->type == CT_PRIVATE)
{
/* Handle Qt slots - maybe should just check for a CT_WORD? */
if (chunk_is_str(next, "slots", 5))
{
tmp = chunk_get_next(next);
if ((tmp != NULL) && (tmp->type == CT_COLON))
{
next = tmp;
}
}
if (next->type == CT_COLON)
{
next->type = CT_PRIVATE_COLON;
if ((tmp = chunk_get_next_ncnl(next)) != NULL)
{
tmp->flags |= PCF_STMT_START | PCF_EXPR_START;
}
}
else
{
pc->type = chunk_is_str(pc, "signals", 7) ? CT_WORD : CT_QUALIFIER;
}
}
/* Look for <newline> 'EXEC' 'SQL' */
if (chunk_is_str(pc, "EXEC", 4) && chunk_is_str(next, "SQL", 3))
{
tmp = chunk_get_prev(pc);
if (chunk_is_newline(tmp))
{
tmp = chunk_get_next(next);
if (chunk_is_str_case(tmp, "BEGIN", 5))
{
pc->type = CT_SQL_BEGIN;
}
else if (chunk_is_str_case(tmp, "END", 3))
{
pc->type = CT_SQL_END;
}
else
{
pc->type = CT_SQL_EXEC;
}
/* Change words into CT_SQL_WORD until CT_SEMICOLON */
while (tmp != NULL)
{
if (tmp->type == CT_SEMICOLON)
{
break;
}
if ((tmp->len > 0) && isalpha(*tmp->str))
{
tmp->type = CT_SQL_WORD;
}
tmp = chunk_get_next_ncnl(tmp);
}
}
}
/* Detect Objective C class name */
if ((pc->type == CT_OC_IMPL) ||
(pc->type == CT_OC_INTF) ||
(pc->type == CT_OC_PROTOCOL))
{
if (next->type != CT_PAREN_OPEN)
{
next->type = CT_OC_CLASS;
}
next->parent_type = pc->type;
tmp = chunk_get_next_ncnl(next);
if (tmp != NULL)
{
tmp->flags |= PCF_STMT_START | PCF_EXPR_START;
}
tmp = chunk_get_next_type(pc, CT_OC_END, pc->level);
if (tmp != NULL)
{
tmp->parent_type = pc->type;
}
}
/* Detect Objective-C categories and class extensions */
/* @interface ClassName (CategoryName) */
/* @implementation ClassName (CategoryName) */
/* @interface ClassName () */
/* @implementation ClassName () */
if (((pc->parent_type == CT_OC_IMPL) ||
(pc->parent_type == CT_OC_INTF) ||
(pc->type == CT_OC_CLASS)) &&
(next->type == CT_PAREN_OPEN))
{
next->parent_type = pc->parent_type;
tmp = chunk_get_next(next);
if ((tmp != NULL) && (tmp->next != NULL))
{
if (tmp->type == CT_PAREN_CLOSE)
{
//tmp->type = CT_OC_CLASS_EXT;
tmp->parent_type = pc->parent_type;
}
else
{
tmp->type = CT_OC_CATEGORY;
tmp->parent_type = pc->parent_type;
}
}
tmp = chunk_get_next_type(pc, CT_PAREN_CLOSE, pc->level);
if (tmp != NULL)
{
tmp->parent_type = pc->parent_type;
}
}
/**
* Objective C @dynamic and @synthesize
* @dynamic xxx, yyy;
* @synthesize xxx, yyy;
* Just find the semicolon and mark it.
*/
if (pc->type == CT_OC_DYNAMIC)
{
tmp = chunk_get_next_type(pc, CT_SEMICOLON, pc->level);
if (tmp != NULL)
{
tmp->parent_type = pc->type;
}
}
/* Detect Objective C @property
* @property NSString *stringProperty;
* @property(nonatomic, retain) NSMutableDictionary *shareWith;
*/
if (pc->type == CT_OC_PROPERTY)
{
if (next->type != CT_PAREN_OPEN)
{
next->flags |= PCF_STMT_START | PCF_EXPR_START;
}
else
{
next->parent_type = pc->type;
tmp = chunk_get_next_type(pc, CT_PAREN_CLOSE, pc->level);
if (tmp != NULL)
{
tmp->parent_type = pc->type;
tmp = chunk_get_next_ncnl(tmp);
if (tmp != NULL)
{
tmp->flags |= PCF_STMT_START | PCF_EXPR_START;
tmp = chunk_get_next_type(tmp, CT_SEMICOLON, pc->level);
if (tmp != NULL)
{
tmp->parent_type = pc->type;
}
}
}
}
}
/* Detect Objective C @selector
* @selector(msgNameWithNoArg)
* @selector(msgNameWith1Arg:)
* @selector(msgNameWith2Args:arg2Name:)
*/
if ((pc->type == CT_OC_SEL) && (next->type == CT_PAREN_OPEN))
{
next->parent_type = pc->type;
tmp = chunk_get_next(next);
if (tmp != NULL)
{
tmp->type = CT_OC_SEL_NAME;
tmp->parent_type = pc->type;
while ((tmp = chunk_get_next_ncnl(tmp)) != NULL)
{
if (tmp->type == CT_PAREN_CLOSE)
{
tmp->parent_type = CT_OC_SEL;
break;
}
tmp->type = CT_OC_SEL_NAME;
tmp->parent_type = pc->type;
}
}
}
/* Mark Objective-C blocks (aka lambdas or closures)
* The syntax and usage is exactly like C function pointers with two exceptions:
* Instead of an asterisk they have a caret as pointer symbol.
* In method declarations which take a block as parameter, there can be anonymous blocks, e.g.: (^)
* 1. block literal: ^{ ... };
* 2. block declaration: return_t (^name) (int arg1, int arg2, ...) NB: return_t is optional and name can be optional if found as param in a method declaration.
* 3. block expression: ^ return_t (int arg) { ... }; NB: return_t is optional
*
* See http://developer.apple.com/mac/library/documentation/Cocoa/Conceptual/Blocks for more info...
*/
if ((cpd.lang_flags & LANG_OC) &&
(pc->type == CT_ARITH) &&
(chunk_is_str(pc, "^", 1)) &&
(prev->type != CT_NUMBER) &&
(prev->type != CT_NUMBER_FP))
{
/* mark objc blocks caret so that we can process it later*/
pc->type = CT_OC_BLOCK_CARET;
if (prev->type == CT_PAREN_OPEN)
{
/* block declaration */
pc->parent_type = CT_OC_BLOCK_TYPE;
}
else if ((next->type == CT_PAREN_OPEN) ||
(next->type == CT_BRACE_OPEN))
{
/* block expression without return type */
/* block literal */
pc->parent_type = CT_OC_BLOCK_EXPR;
}
else
{
/* block expression with return type (seldomly used) */
if (prev->type == CT_ASSIGN)
{
/* shortcut to spare the peeking below
* the XOR operator wouldn't be used directly
* after an assign all by itself */
pc->parent_type = CT_OC_BLOCK_EXPR;
}
else
{
/* this ones tricky because we don't know how many
* stars the return type has - if there even is one */
tmp = pc;
while ((tmp = chunk_get_next(tmp)) != NULL)
{
/* we just peek ahead and see if the line contains
* an open brace somewhere.
* FIXME: this check needs to be more thorough. */
if (tmp->type == CT_BRACE_OPEN)
{
pc->parent_type = CT_OC_BLOCK_EXPR;
break;
}
}
}
}
}
/* Handle special preprocessor junk */
if (pc->type == CT_PREPROC)
{
pc->parent_type = next->type;
}
/* Detect "pragma region" and "pragma endregion" */
if ((pc->type == CT_PP_PRAGMA) && (next->type == CT_PREPROC_BODY))
{
if ((memcmp(next->str, "region", 6) == 0) ||
(memcmp(next->str, "endregion", 9) == 0))
{
pc->type = (*next->str == 'r') ? CT_PP_REGION : CT_PP_ENDREGION;
prev->parent_type = pc->type;
}
}
/* Check for C# nullable types '?' is in next */
if ((cpd.lang_flags & LANG_CS) &&
(next->type == CT_QUESTION) &&
(next->orig_col == (pc->orig_col + pc->len)))
{
tmp = chunk_get_next_ncnl(next);
if (tmp != NULL)
{
bool doit = ((tmp->type == CT_PAREN_CLOSE) ||
(tmp->type == CT_ANGLE_CLOSE));
if (tmp->type == CT_WORD)
{
tmp2 = chunk_get_next_ncnl(tmp);
if ((tmp2 != NULL) &&
((tmp2->type == CT_SEMICOLON) ||
(tmp2->type == CT_ASSIGN) ||
(tmp2->type == CT_COMMA)))
{
doit = true;
}
}
if (doit)
{
pc->len++;
chunk_del(next);
next = tmp;
}
}
}
/* Convert '>' + '>' into '>>' */
if ((cpd.lang_flags & LANG_CS) &&
(pc->type == CT_ANGLE_CLOSE) &&
(next->type == CT_ANGLE_CLOSE) &&
(pc->parent_type == CT_NONE) &&
((pc->orig_col + pc->len) == next->orig_col) &&
(next->parent_type == CT_NONE))
{
pc->len++;
pc->type = CT_ARITH;
tmp = chunk_get_next_ncnl(next);
chunk_del(next);
next = tmp;
}
/* Change 'default(' into a sizeof-like statement */
if ((cpd.lang_flags & LANG_CS) &&
(pc->type == CT_DEFAULT) &&
(next->type == CT_PAREN_OPEN))
{
pc->type = CT_SIZEOF;
}
if ((pc->type == CT_UNSAFE) && (next->type != CT_BRACE_OPEN))
{
pc->type = CT_QUALIFIER;
}
/* TODO: determine other stuff here */
prev = pc;
pc = next;
next = chunk_get_next_ncnl(pc);
}
}
/*
* See also it's preprocessor counterpart
* add_long_preprocessor_conditional_block_comment
* in defines.cpp
*/
void add_long_closebrace_comment(void)
{
chunk_t *pc;
chunk_t *tmp;
chunk_t *br_open;
chunk_t *br_close;
chunk_t *fcn_pc = NULL;
chunk_t *sw_pc = NULL;
int nl_count;
pc = chunk_get_head();
while ((pc = chunk_get_next_ncnl(pc)) != NULL)
{
if ((pc->type == CT_FUNC_DEF) ||
(pc->type == CT_OC_MSG_DECL))
{
fcn_pc = pc;
}
else if (pc->type == CT_SWITCH)
{
/* kinda pointless, since it always has the text "switch" */
sw_pc = pc;
}
if ((pc->type != CT_BRACE_OPEN) || ((pc->flags & PCF_IN_PREPROC) != 0))
{
continue;
}
br_open = pc;
nl_count = 0;
tmp = pc;
while ((tmp = chunk_get_next(tmp)) != NULL)
{
if (chunk_is_newline(tmp))
{
nl_count += tmp->nl_count;
}
else if ((tmp->level == br_open->level) &&
(tmp->type == CT_BRACE_CLOSE))
{
br_close = tmp;
//LOG_FMT(LSYS, "found brace pair on lines %d and %d, nl_count=%d\n",
// br_open->orig_line, br_close->orig_line, nl_count);
/* Found the matching close brace - make sure a newline is next */
tmp = chunk_get_next(tmp);
if ((tmp == NULL) || chunk_is_newline(tmp))
{
int nl_min = 0;
chunk_t *tag_pc = NULL;
if (br_open->parent_type == CT_SWITCH)
{
nl_min = cpd.settings[UO_mod_add_long_switch_closebrace_comment].n;
tag_pc = sw_pc;
}
else if ((br_open->parent_type == CT_FUNC_DEF) ||
(br_open->parent_type == CT_OC_MSG_DECL))
{
nl_min = cpd.settings[UO_mod_add_long_function_closebrace_comment].n;
tag_pc = fcn_pc;
}
if ((nl_min > 0) && (nl_count >= nl_min) && (tag_pc != NULL))
{
/* determine the added comment style */
c_token_t style = (cpd.lang_flags & (LANG_CPP | LANG_CS)) ?
CT_COMMENT_CPP : CT_COMMENT;
/* Add a comment after the close brace */
insert_comment_after(br_close, style, tag_pc->str);
}
}
break;
}
}
}
}
/**
* Marches through the whole file and checks to see how many spaces should be
* between two chunks
*/
void space_text(void)
{
chunk_t *pc;
chunk_t *next;
chunk_t *tmp;
int column, prev_column;
int delta;
pc = chunk_get_head();
if (pc == NULL)
{
return;
}
column = pc->column;
while (pc != NULL)
{
next = chunk_get_next(pc);
if (next == NULL)
{
break;
}
/* If the current chunk contains a newline, do not change the column
* of the next item */
if ((pc->type == CT_NEWLINE) ||
(pc->type == CT_NL_CONT) ||
(pc->type == CT_COMMENT_MULTI))
{
column = next->column;
}
else
{
/* Set to the minimum allowed column */
if (pc->nl_count == 0)
{
column += pc->len;
}
else
{
column = pc->orig_col_end;
}
prev_column = column;
/**
* Apply a general safety check
* If the two chunks combined will tokenize differently, then we
* must force a space.
* Two chunks -- "()" and "[]" will always tokenize differently.
* They are always safe to not have a space after them.
*/
pc->flags &= ~PCF_FORCE_SPACE;
if ((pc->len > 0) &&
!chunk_is_str(pc, "[]", 2) &&
!chunk_is_str(pc, "()", 2))
{
/* Find the next non-empty chunk on this line */
tmp = next;
while ((tmp != NULL) && (tmp->len == 0) && !chunk_is_newline(tmp))
{
tmp = chunk_get_next(tmp);
}
if ((tmp != NULL) && (tmp->len > 0))
{
bool kw1 = CharTable::IsKw2(pc->str[pc->len - 1]);
bool kw2 = CharTable::IsKw1(next->str[0]);
if (kw1 && kw2)
{
/* back-to-back words need a space */
pc->flags |= PCF_FORCE_SPACE;
}
else if (!kw1 && !kw2 && (pc->len < 4) && (next->len < 4))
{
/* We aren't dealing with keywords. concat and try punctuators */
char buf[9];
memcpy(buf, pc->str, pc->len);
memcpy(buf + pc->len, next->str, next->len);
buf[pc->len + next->len] = 0;
const chunk_tag_t *ct;
ct = find_punctuator(buf, cpd.lang_flags);
if ((ct != NULL) && ((int)strlen(ct->tag) != pc->len))
{
/* punctuator parsed to a different size.. */
pc->flags |= PCF_FORCE_SPACE;
}
}
}
}
int av = do_space(pc, next, false);
if (pc->flags & PCF_FORCE_SPACE)
{
LOG_FMT(LSPACE, "Forcing space between '%.*s' and '%.*s'\n",
pc->len, pc->str, next->len, next->str);
av |= AV_ADD;
}
switch (av)
{
case AV_FORCE:
/* add exactly one space */
column++;
break;
case AV_ADD:
delta = 1;
if ((next->orig_col >= pc->orig_col_end) && (pc->orig_col_end != 0))
{
/* Keep the same relative spacing, minimum 1 */
delta = next->orig_col - pc->orig_col_end;
if (delta < 1)
{
delta = 1;
}
}
column += delta;
break;
case AV_REMOVE:
/* the symbols will be back-to-back "a+3" */
break;
default:
/* Keep the same relative spacing, if possible */
if ((next->orig_col >= pc->orig_col_end) && (pc->orig_col_end != 0))
{
column += next->orig_col - pc->orig_col_end;
}
break;
}
if (chunk_is_comment(next) &&
chunk_is_newline(chunk_get_next(next)) &&
(column < (int)next->orig_col))
{
if ((cpd.settings[UO_sp_endif_cmt].a == AV_IGNORE) ||
((pc->type != CT_PP_ELSE) && (pc->type != CT_PP_ENDIF)))
{
if (cpd.settings[UO_indent_relative_single_line_comments].b)
{
column = pc->column + (next->orig_col - pc->orig_col_end);
}
else
{
column = next->orig_col;
}
}
}
next->column = column;
LOG_FMT(LSPACE, " = %s @ %d\n",
(av == AV_IGNORE) ? "IGNORE" :
(av == AV_ADD) ? "ADD" :
(av == AV_REMOVE) ? "REMOVE" : "FORCE",
column - prev_column);
}
pc = next;
}
}
static void add_msg_header(c_token_t type, file_mem& fm)
{
chunk_t *pc;
chunk_t *ref;
chunk_t *tmp;
bool do_insert;
for (pc = chunk_get_head(); pc != NULL; pc = chunk_get_next_ncnlnp(pc))
{
if (pc->type != type)
{
continue;
}
do_insert = false;
/* On a function proto or def. Back up to a close brace or semicolon on
* the same level
*/
ref = pc;
while ((ref = chunk_get_prev(ref)) != NULL)
{
/* ignore the CT_TYPE token that is the result type */
if ((ref->level != pc->level) &&
((ref->type == CT_TYPE) ||
(ref->type == CT_PTR_TYPE)))
{
continue;
}
if ((ref->level != pc->level) && (ref->type == CT_OC_CATEGORY))
{
ref = chunk_get_next_ncnl(ref);
if (ref)
{
do_insert = true;
}
break;
}
/* Bail if we change level or find an access specifier colon */
if ((ref->level != pc->level) || (ref->type == CT_PRIVATE_COLON))
{
do_insert = true;
break;
}
/* If we hit an angle close, back up to the angle open */
if (ref->type == CT_ANGLE_CLOSE)
{
ref = chunk_get_prev_type(ref, CT_ANGLE_OPEN, ref->level, CNAV_PREPROC);
continue;
}
/* Bail if we hit a preprocessor and cmt_insert_before_preproc is false */
if (ref->flags & PCF_IN_PREPROC)
{
tmp = chunk_get_prev_type(ref, CT_PREPROC, ref->level);
if ((tmp != NULL) && (tmp->parent_type == CT_PP_IF))
{
tmp = chunk_get_prev_nnl(tmp);
if (chunk_is_comment(tmp) &&
!cpd.settings[UO_cmt_insert_before_preproc].b)
{
break;
}
}
}
/* Ignore 'right' comments */
if (chunk_is_comment(ref) && chunk_is_newline(chunk_get_prev(ref)))
{
break;
}
if ((ref->level == pc->level) &&
((ref->flags & PCF_IN_PREPROC) ||
(ref->type == CT_SEMICOLON) ||
(ref->type == CT_BRACE_CLOSE) ||
(ref->type == CT_OC_CLASS)))
{
do_insert = true;
break;
}
}
if (do_insert)
{
/* Insert between after and ref */
chunk_t *after = chunk_get_next_ncnl(ref);
tokenize(fm.data, after);
for (tmp = chunk_get_next(ref); tmp != after; tmp = chunk_get_next(tmp))
{
tmp->level = after->level;
}
}
}
}
static void try_split_here(cw_entry &ent, chunk_t *pc)
{
LOG_FUNC_ENTRY();
LOG_FMT(LSPLIT, "%s(%d): at %s, orig_col=%zu\n", __func__, __LINE__, pc->text(), pc->orig_col);
size_t pc_pri = get_split_pri(pc->type);
LOG_FMT(LSPLIT, "%s(%d): pc_pri=%zu\n", __func__, __LINE__, pc_pri);
if (pc_pri == 0)
{
LOG_FMT(LSPLIT, "%s(%d): pc_pri is 0, return\n", __func__, __LINE__);
return;
}
LOG_FMT(LSPLIT, "%s(%d):\n", __func__, __LINE__);
// Can't split after a newline
chunk_t *prev = chunk_get_prev(pc);
if ( prev == nullptr
|| (chunk_is_newline(prev) && pc->type != CT_STRING))
{
if (prev != nullptr)
{
LOG_FMT(LSPLIT, "%s(%d): Can't split after a newline, orig_line=%zu, return\n",
__func__, __LINE__, prev->orig_line);
}
return;
}
LOG_FMT(LSPLIT, "%s(%d):\n", __func__, __LINE__);
// Can't split a function without arguments
if (pc->type == CT_FPAREN_OPEN)
{
chunk_t *next = chunk_get_next(pc);
if (next->type == CT_FPAREN_CLOSE)
{
LOG_FMT(LSPLIT, "%s(%d): Can't split a function without arguments, return\n", __func__, __LINE__);
return;
}
}
LOG_FMT(LSPLIT, "%s(%d):\n", __func__, __LINE__);
// Only split concatenated strings
if (pc->type == CT_STRING)
{
chunk_t *next = chunk_get_next(pc);
if (next->type != CT_STRING)
{
LOG_FMT(LSPLIT, "%s(%d): Only split concatenated strings, return\n", __func__, __LINE__);
return;
}
}
LOG_FMT(LSPLIT, "%s(%d):\n", __func__, __LINE__);
// keep common groupings unless ls_code_width
if (!cpd.settings[UO_ls_code_width].b && pc_pri >= 20)
{
LOG_FMT(LSPLIT, "%s(%d): keep common groupings unless ls_code_width, return\n", __func__, __LINE__);
return;
}
LOG_FMT(LSPLIT, "%s(%d):\n", __func__, __LINE__);
// don't break after last term of a qualified type
if (pc_pri == 25)
{
chunk_t *next = chunk_get_next(pc);
if (next->type != CT_WORD && (get_split_pri(next->type) != 25))
{
LOG_FMT(LSPLIT, "%s(%d): don't break after last term of a qualified type, return\n", __func__, __LINE__);
return;
}
}
LOG_FMT(LSPLIT, "%s(%d):\n", __func__, __LINE__);
// Check levels first
bool change = false;
if (ent.pc == nullptr || pc->level < ent.pc->level)
{
LOG_FMT(LSPLIT, "%s(%d):\n", __func__, __LINE__);
change = true;
}
else
{
if (pc->level >= ent.pc->level && pc_pri < ent.pri)
{
LOG_FMT(LSPLIT, "%s(%d):\n", __func__, __LINE__);
change = true;
}
}
LOG_FMT(LSPLIT, "%s(%d): change is %s\n", __func__, __LINE__, change ? "TRUE" : "FALSE");
if (change)
{
LOG_FMT(LSPLIT, "%s(%d): do the change\n", __func__, __LINE__);
ent.pc = pc;
ent.pri = pc_pri;
}
} // try_split_here
/**
* Adds an entry to the appropriate stack.
*
* @param pc The chunk
* @param seqnum Optional seqnum (0=assign one)
*/
void AlignStack::Add(chunk_t *start, int seqnum)
{
/* Assign a seqnum if needed */
if (seqnum == 0)
{
seqnum = m_seqnum;
}
chunk_t *ali;
chunk_t *ref;
chunk_t *tmp;
chunk_t *prev;
chunk_t *next;
int col_adj = 0; /* Amount the column is shifted for 'dangle' mode */
int tmp_col;
int endcol;
int gap;
m_last_added = 0;
/* Check threshold limits */
if ((m_max_col == 0) || (m_thresh == 0) ||
(((start->column + m_gap) <= (m_max_col + m_thresh)) &&
(((start->column + m_gap) >= (m_max_col - m_thresh)) ||
(start->column >= m_min_col))))
{
/* we are adding it, so update the newline seqnum */
if (seqnum > m_nl_seqnum)
{
m_nl_seqnum = seqnum;
}
/**
* SS_IGNORE: no special handling of '*' or '&', only 'foo' is aligned
* void foo; // gap=5, 'foo' is aligned
* char * foo; // gap=3, 'foo' is aligned
* foomatic foo; // gap=1, 'foo' is aligned
* The gap is the columns between 'foo' and the previous token.
* [void - foo], ['*' - foo], etc
*
* SS_INCLUDE: - space between variable and '*' or '&' is eaten
* void foo; // gap=5, 'foo' is aligned
* char *foo; // gap=5, '*' is aligned
* foomatic foo; // gap=1, 'foo' is aligned
* The gap is the columns between the first '*' or '&' before foo
* and the previous token. [void - foo], [char - '*'], etc
*
* SS_DANGLE: - space between variable and '*' or '&' is eaten
* void foo; // gap=5
* char *bar; // gap=5, as the '*' doesn't count
* foomatic foo; // gap=1
* The gap is the columns between 'foo' and the chunk before the first
* '*' or '&'. [void - foo], [char - bar], etc
*
* If the gap < m_gap, then the column is bumped out by the difference.
* So, if m_gap is 2, then the above would be:
* SS_IGNORE:
* void foo; // gap=6
* char * foo; // gap=4
* foomatic foo; // gap=2
* SS_INCLUDE:
* void foo; // gap=6
* char *foo; // gap=6
* foomatic foo; // gap=2
* SS_DANGLE:
* void foo; // gap=6
* char *bar; // gap=6, as the '*' doesn't count
* foomatic foo; // gap=2
* Right aligned numbers:
* #define A -1
* #define B 631
* #define C 3
* Left aligned numbers:
* #define A -1
* #define B 631
* #define C 3
*
* In the code below, pc is set to the item that is aligned.
* In the above examples, that is 'foo', '*', '-', or 63.
*
* Ref is set to the last part of the type.
* In the above examples, that is 'void', 'char', 'foomatic', 'A', or 'B'.
*
* The '*' and '&' can float between the two.
*
* If align_on_tabstop=true, then SS_DANGLE is changed to SS_INCLUDE.
*/
if (cpd.settings[UO_align_on_tabstop].b && (m_star_style == SS_DANGLE))
{
m_star_style = SS_INCLUDE;
}
/* Find ref. Back up to the real item that is aligned. */
prev = start;
while (((prev = chunk_get_prev(prev)) != NULL) &&
(chunk_is_star(prev) ||
chunk_is_addr(prev) ||
(prev->type == CT_TPAREN_OPEN)))
{
/* do nothing - we want prev when this exits */
}
ref = prev;
if (chunk_is_newline(ref))
{
ref = chunk_get_next(ref);
}
/* Find the item that we are going to align. */
ali = start;
if (m_star_style != SS_IGNORE)
{
/* back up to the first '*' preceding the token */
prev = chunk_get_prev(ali);
while (chunk_is_star(prev))
{
ali = prev;
prev = chunk_get_prev(ali);
}
if (chunk_is_token(prev, CT_TPAREN_OPEN))
{
ali = prev;
prev = chunk_get_prev(ali);
}
}
if (m_amp_style != SS_IGNORE)
{
/* back up to the first '&' preceding the token */
prev = chunk_get_prev(ali);
while (chunk_is_addr(prev))
{
ali = prev;
prev = chunk_get_prev(ali);
}
}
/* Tighten down the spacing between ref and start */
if (!cpd.settings[UO_align_keep_extra_space].b)
{
tmp_col = ref->column;
tmp = ref;
while (tmp != start)
{
next = chunk_get_next(tmp);
tmp_col += space_col_align(tmp, next);
if (next->column != tmp_col)
{
align_to_column(next, tmp_col);
}
tmp = next;
}
}
/* Set the column adjust and gap */
col_adj = 0;
gap = 0;
if (ref != ali)
{
gap = ali->column - (ref->column + ref->len());
}
tmp = ali;
if (chunk_is_token(tmp, CT_TPAREN_OPEN))
{
tmp = chunk_get_next(tmp);
}
if ((chunk_is_star(tmp) && (m_star_style == SS_DANGLE)) ||
(chunk_is_addr(tmp) && (m_amp_style == SS_DANGLE)))
{
col_adj = start->column - ali->column;
gap = start->column - (ref->column + ref->len());
}
/* See if this pushes out the max_col */
endcol = ali->column + col_adj;
if (gap < m_gap)
{
endcol += m_gap - gap;
}
// LOG_FMT(LSYS, "[%p] line %d pc='%s' [%s] col:%d ali='%s' [%s] col:%d ref='%s' [%s] col:%d col_adj=%d endcol=%d, ss=%d as=%d, gap=%d\n",
// this,
// start->orig_line,
// start->str.c_str(), get_token_name(start->type), start->column,
// ali->str.c_str(), get_token_name(ali->type), ali->column,
// ref->str.c_str(), get_token_name(ref->type), ref->column,
// col_adj, endcol, m_star_style, m_amp_style, gap);
ali->align.col_adj = col_adj;
ali->align.ref = ref;
ali->align.start = start;
m_aligned.Push_Back(ali, seqnum);
m_last_added = 1;
LOG_FMT(LAS, "Add-[%s]: line %d, col %d, adj %d : ref=[%s] endcol=%d\n",
ali->str.c_str(), ali->orig_line, ali->column, ali->align.col_adj,
ref->str.c_str(), endcol);
if (m_min_col > endcol)
{
m_min_col = endcol;
}
if (endcol > m_max_col)
{
LOG_FMT(LAS, "Add-aligned [%d/%d/%d]: line %d, col %d : max_col old %d, new %d - min_col %d\n",
seqnum, m_nl_seqnum, m_seqnum,
ali->orig_line, ali->column, m_max_col, endcol, m_min_col);
m_max_col = endcol;
/**
* If there were any entries that were skipped, re-add them as they
* may now be within the threshold
*/
if (!m_skipped.Empty())
{
ReAddSkipped();
}
}
else
{
LOG_FMT(LAS, "Add-aligned [%d/%d/%d]: line %d, col %d : col %d <= %d - min_col %d\n",
seqnum, m_nl_seqnum, m_seqnum,
ali->orig_line, ali->column, endcol, m_max_col, m_min_col);
}
}
else
{
/* The threshold check failed, so add it to the skipped list */
m_skipped.Push_Back(start, seqnum);
m_last_added = 2;
LOG_FMT(LAS, "Add-skipped [%d/%d/%d]: line %d, col %d <= %d + %d\n",
seqnum, m_nl_seqnum, m_seqnum,
start->orig_line, start->column, m_max_col, m_thresh);
}
}
static void split_fcn_params(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)
&& fpo->type != CT_FPAREN_OPEN)
{
// do nothing
LOG_FMT(LSPLIT, "%s(%d): '%s', orig_col is %zu, level is %zu\n",
__func__, __LINE__, fpo->text(), fpo->orig_col, fpo->level);
}
chunk_t *pc = chunk_get_next_ncnl(fpo);
size_t min_col = pc->column;
LOG_FMT(LSPLIT, " mincol is %zu, max_width is %zu\n",
min_col, cpd.settings[UO_code_width].u - min_col);
int cur_width = 0;
int last_col = -1;
LOG_FMT(LSPLIT, "%s(%d):look forward until CT_COMMA or CT_FPAREN_CLOSE\n", __func__, __LINE__);
while (pc != nullptr)
{
LOG_FMT(LSPLIT, "%s(%d): pc->text() '%s', type is %s\n",
__func__, __LINE__, pc->text(), get_token_name(pc->type));
if (chunk_is_newline(pc))
{
cur_width = 0;
last_col = -1;
}
else
{
if (last_col < 0)
{
last_col = pc->column;
LOG_FMT(LSPLIT, "%s(%d): last_col is %d\n",
__func__, __LINE__, last_col);
}
cur_width += (pc->column - last_col) + pc->len();
last_col = pc->column + pc->len();
LOG_FMT(LSPLIT, "%s(%d): last_col is %d\n",
__func__, __LINE__, last_col);
if (pc->type == CT_COMMA || pc->type == CT_FPAREN_CLOSE)
{
cur_width--;
LOG_FMT(LSPLIT, "%s(%d): cur_width is %d\n",
__func__, __LINE__, cur_width);
if ( ((last_col - 1) > static_cast<int>(cpd.settings[UO_code_width].u))
|| pc->type == CT_FPAREN_CLOSE)
{
break;
}
}
}
pc = chunk_get_next(pc);
}
// back up until the prev is a comma
chunk_t *prev = pc;
LOG_FMT(LSPLIT, " %s(%d): back up until the prev is a comma\n", __func__, __LINE__);
while ((prev = chunk_get_prev(prev)) != nullptr)
{
LOG_FMT(LSPLIT, "%s(%d): pc '%s', pc->level is %zu, prev '%s', prev->type is %s\n",
__func__, __LINE__, pc->text(), pc->level, prev->text(), get_token_name(prev->type));
if (chunk_is_newline(prev) || prev->type == CT_COMMA)
{
LOG_FMT(LSPLIT, "%s(%d): found at %zu\n",
__func__, __LINE__, prev->orig_col);
break;
}
LOG_FMT(LSPLIT, "%s(%d): last_col is %d\n",
__func__, __LINE__, last_col);
last_col -= pc->len();
LOG_FMT(LSPLIT, "%s(%d): last_col is %d\n",
__func__, __LINE__, last_col);
if (prev->type == CT_FPAREN_OPEN)
{
pc = chunk_get_next(prev);
if (!cpd.settings[UO_indent_paren_nl].b)
{
min_col = pc->brace_level * cpd.settings[UO_indent_columns].u + 1;
LOG_FMT(LSPLIT, "%s(%d): min_col is %zu\n",
__func__, __LINE__, min_col);
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);
}
LOG_FMT(LSPLIT, "%s(%d): min_col is %zu\n",
__func__, __LINE__, min_col);
}
// Don't split "()"
if (pc->type != c_token_t(prev->type + 1))
{
break;
}
}
}
if (prev != nullptr && !chunk_is_newline(prev))
{
LOG_FMT(LSPLIT, "%s(%d): -- ended on [%s] --\n",
__func__, __LINE__, get_token_name(prev->type));
LOG_FMT(LSPLIT, "%s(%d): min_col is %zu\n",
__func__, __LINE__, min_col);
pc = chunk_get_next(prev);
newline_add_before(pc);
reindent_line(pc, min_col);
cpd.changes++;
}
} // split_fcn_params
void do_braces(void)
{
LOG_FUNC_ENTRY();
if (cpd.settings[UO_mod_full_brace_if_chain].b
|| cpd.settings[UO_mod_full_brace_if_chain_only].b)
{
mod_full_brace_if_chain();
}
if ((cpd.settings[UO_mod_full_brace_if].a |
cpd.settings[UO_mod_full_brace_do].a |
cpd.settings[UO_mod_full_brace_for].a |
cpd.settings[UO_mod_full_brace_using].a |
cpd.settings[UO_mod_full_brace_while].a) & AV_REMOVE)
{
examine_braces();
}
/* convert vbraces if needed */
if ((cpd.settings[UO_mod_full_brace_if].a |
cpd.settings[UO_mod_full_brace_do].a |
cpd.settings[UO_mod_full_brace_for].a |
cpd.settings[UO_mod_full_brace_function].a |
cpd.settings[UO_mod_full_brace_using].a |
cpd.settings[UO_mod_full_brace_while].a) & AV_ADD)
{
convert_vbrace_to_brace();
}
/* Mark one-liners */
chunk_t *pc = chunk_get_head();
while ((pc = chunk_get_next_ncnl(pc)) != NULL)
{
if ((pc->type != CT_BRACE_OPEN) &&
(pc->type != CT_VBRACE_OPEN))
{
continue;
}
chunk_t *br_open = pc;
c_token_t brc_type = c_token_t(pc->type + 1);
/* Detect empty bodies */
chunk_t *tmp = chunk_get_next_ncnl(pc);
if ((tmp != NULL) && (tmp->type == brc_type))
{
chunk_flags_set(br_open, PCF_EMPTY_BODY);
chunk_flags_set(tmp, PCF_EMPTY_BODY);
}
/* Scan for the brace close or a newline */
tmp = br_open;
while ((tmp = chunk_get_next_nc(tmp)) != NULL)
{
if (chunk_is_newline(tmp))
{
break;
}
if ((tmp->type == brc_type) && (br_open->level == tmp->level))
{
flag_series(br_open, tmp, PCF_ONE_LINER);
break;
}
}
}
if (cpd.settings[UO_mod_case_brace].a != AV_IGNORE)
{
mod_case_brace();
}
if (cpd.settings[UO_mod_move_case_break].b)
{
move_case_break();
}
} // do_braces
/**
* 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
* - concatenated strings
* - ? :
* - function open paren not followed by close paren
*/
static void try_split_here(cw_entry &ent, chunk_t *pc)
{
LOG_FUNC_ENTRY();
chunk_t *next;
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) && (pc->type != CT_STRING)))
{
return;
}
/* Can't split a function without arguments */
if (pc->type == CT_FPAREN_OPEN)
{
next = chunk_get_next(pc);
if (next->type == CT_FPAREN_CLOSE)
{
return;
}
}
/* Only split concatenated strings */
if (pc->type == CT_STRING)
{
next = chunk_get_next(pc);
if (next->type != CT_STRING)
{
return;
}
}
/* keep common groupings unless ls_code_width */
if (!cpd.settings[UO_ls_code_width].b && (pc_pri >= 20))
{
return;
}
/* don't break after last term of a qualified type */
if (pc_pri == 25)
{
next = chunk_get_next(pc);
if ((next->type != CT_WORD) && (get_split_pri(next->type) != 25))
{
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;
}
} // try_split_here
static bool can_remove_braces(chunk_t *bopen)
{
LOG_FUNC_ENTRY();
chunk_t *prev = NULL;
size_t semi_count = 0;
size_t level = bopen->level + 1;
bool hit_semi = false;
bool was_fcn = false;
size_t nl_max = cpd.settings[UO_mod_full_brace_nl].u;
size_t nl_count = 0;
size_t if_count = 0;
int br_count = 0;
/* Cannot remove braces inside a preprocessor */
if (bopen->flags & PCF_IN_PREPROC)
{
return(false);
}
chunk_t *pc = chunk_get_next_ncnl(bopen, CNAV_PREPROC);
if ((pc != NULL) && (pc->type == CT_BRACE_CLOSE))
{
/* Can't remove empty statement */
return(false);
}
LOG_FMT(LBRDEL, "%s: start on %zu : ", __func__, bopen->orig_line);
pc = chunk_get_next_nc(bopen, CNAV_ALL);
while ((pc != NULL) && (pc->level >= level))
{
if (pc->flags & PCF_IN_PREPROC)
{
/* Cannot remove braces that contain a preprocessor */
return(false);
}
if (chunk_is_newline(pc))
{
nl_count += pc->nl_count;
if ((nl_max > 0) && (nl_count > nl_max))
{
LOG_FMT(LBRDEL, " exceeded %zu newlines\n", nl_max);
return(false);
}
}
else
{
if (pc->type == CT_BRACE_OPEN)
{
br_count++;
}
else if (pc->type == CT_BRACE_CLOSE)
{
br_count--;
}
else if ((pc->type == CT_IF) || (pc->type == CT_ELSEIF))
{
if (br_count == 0)
{
if_count++;
}
}
if (pc->level == level)
{
if ((semi_count > 0) && hit_semi)
{
/* should have bailed due to close brace level drop */
LOG_FMT(LBRDEL, " no close brace\n");
return(false);
}
LOG_FMT(LBRDEL, " [%s %zu-%zu]", pc->text(), pc->orig_line, semi_count);
if (pc->type == CT_ELSE)
{
LOG_FMT(LBRDEL, " bailed on %s on line %zu\n",
pc->text(), pc->orig_line);
return(false);
}
was_fcn = (prev != NULL) && (prev->type == CT_FPAREN_CLOSE);
if (chunk_is_semicolon(pc) ||
(pc->type == CT_IF) ||
(pc->type == CT_ELSEIF) ||
(pc->type == CT_FOR) ||
(pc->type == CT_DO) ||
(pc->type == CT_WHILE) ||
(pc->type == CT_USING_STMT) ||
((pc->type == CT_BRACE_OPEN) && was_fcn))
{
hit_semi |= chunk_is_semicolon(pc);
if (++semi_count > 1)
{
LOG_FMT(LBRDEL, " bailed on %zu because of %s on line %zu\n",
bopen->orig_line, pc->text(), pc->orig_line);
return(false);
}
}
}
}
prev = pc;
pc = chunk_get_next_nc(pc);
}
if (pc == NULL)
{
LOG_FMT(LBRDEL, " NULL\n");
return(false);
}
if ((pc->type == CT_BRACE_CLOSE) && (pc->parent_type == CT_IF))
{
chunk_t *next = chunk_get_next_ncnl(pc, CNAV_PREPROC);
prev = chunk_get_prev_ncnl(pc, CNAV_PREPROC);
if ((next != NULL) && (next->type == CT_ELSE) &&
((prev->type == CT_BRACE_CLOSE) || (prev->type == CT_VBRACE_CLOSE)) &&
(prev->parent_type == CT_IF))
{
LOG_FMT(LBRDEL, " - bailed on '%s'[%s] on line %zu due to 'if' and 'else' sequence\n",
get_token_name(pc->type), get_token_name(pc->parent_type),
pc->orig_line);
return(false);
}
}
LOG_FMT(LBRDEL, " - end on '%s' on line %zu. if_count=%zu semi_count=%zu\n",
get_token_name(pc->type), pc->orig_line, if_count, semi_count);
return((pc->type == CT_BRACE_CLOSE) && (pc->pp_level == bopen->pp_level));
} // can_remove_braces
/**
* Figures out where to split a function def/proto/call
*
* For fcn protos and defs. Also fcn calls where level == brace_level:
* - find the open fparen
* + if it doesn't have a newline right after it
* * see if all parameters will fit individually after the paren
* * if not, throw a newline after the open paren & return
* - scan backwards to the open fparen or comma
* + if there isn't a newline after that item, add one & return
* + otherwise, add a newline before the start token
*
* @param start the offending token
* @return the token that should have a newline
* inserted before it
*/
static void split_fcn_params(chunk_t *start)
{
LOG_FUNC_ENTRY();
LOG_FMT(LSPLIT, " %s: ", __func__);
chunk_t *prev;
chunk_t *fpo;
chunk_t *pc;
int cur_width = 0;
int last_col = -1;
int min_col;
/* Find the opening fparen */
fpo = start;
while (((fpo = chunk_get_prev(fpo)) != NULL) &&
(fpo->type != CT_FPAREN_OPEN))
{
/* do nothing */
}
pc = chunk_get_next_ncnl(fpo);
min_col = pc->column;
LOG_FMT(LSPLIT, " mincol=%d, max_width=%d ",
min_col, cpd.settings[UO_code_width].n - min_col);
while (pc != NULL)
{
if (chunk_is_newline(pc))
{
cur_width = 0;
last_col = -1;
}
else
{
if (last_col < 0)
{
last_col = pc->column;
}
cur_width += (pc->column - last_col) + pc->len();
last_col = pc->column + pc->len();
if ((pc->type == CT_COMMA) ||
(pc->type == CT_FPAREN_CLOSE))
{
cur_width--;
LOG_FMT(LSPLIT, " width=%d ", cur_width);
if (((last_col - 1) > cpd.settings[UO_code_width].n) ||
(pc->type == CT_FPAREN_CLOSE))
{
break;
}
}
}
pc = chunk_get_next(pc);
}
/* back up until the prev is a comma */
prev = pc;
while ((prev = chunk_get_prev(prev)) != NULL)
{
if (chunk_is_newline(prev) || (prev->type == CT_COMMA))
{
break;
}
last_col -= pc->len();
if (prev->type == CT_FPAREN_OPEN)
{
pc = chunk_get_next(prev);
if (!cpd.settings[UO_indent_paren_nl].b)
{
min_col = pc->brace_level * cpd.settings[UO_indent_columns].n + 1;
if (cpd.settings[UO_indent_continue].n == 0)
{
min_col += cpd.settings[UO_indent_columns].n;
}
else
{
min_col += abs(cpd.settings[UO_indent_continue].n);
}
}
/* Don't split "()" */
if (pc->type != c_token_t(prev->type + 1))
{
break;
}
}
}
if ((prev != NULL) && !chunk_is_newline(prev))
{
LOG_FMT(LSPLIT, " -- ended on [%s] --\n", get_token_name(prev->type));
pc = chunk_get_next(prev);
newline_add_before(pc);
reindent_line(pc, min_col);
cpd.changes++;
}
} // split_fcn_params
static void examine_brace(chunk_t *bopen)
{
LOG_FUNC_ENTRY();
chunk_t *next;
chunk_t *prev = NULL;
size_t semi_count = 0;
size_t level = bopen->level + 1;
bool hit_semi = false;
bool was_fcn = false;
size_t nl_max = cpd.settings[UO_mod_full_brace_nl].u;
size_t nl_count = 0;
size_t if_count = 0;
int br_count = 0;
LOG_FMT(LBRDEL, "%s: start on %zu : ", __func__, bopen->orig_line);
chunk_t *pc = chunk_get_next_nc(bopen);
while ((pc != NULL) && (pc->level >= level))
{
if (pc->flags & PCF_IN_PREPROC)
{
LOG_FMT(LBRDEL, " PREPROC\n");
return;
}
if (chunk_is_newline(pc))
{
nl_count += pc->nl_count;
if ((nl_max > 0) && (nl_count > nl_max))
{
LOG_FMT(LBRDEL, " exceeded %zu newlines\n", nl_max);
return;
}
}
else
{
if (pc->type == CT_BRACE_OPEN)
{
br_count++;
}
else if (pc->type == CT_BRACE_CLOSE)
{
br_count--;
if (br_count == 0)
{
next = chunk_get_next_ncnl(pc, CNAV_PREPROC);
if ((next == NULL) || (next->type != CT_BRACE_CLOSE))
{
LOG_FMT(LBRDEL, " junk after close brace\n");
return;
}
}
}
else if ((pc->type == CT_IF) || (pc->type == CT_ELSEIF))
{
if (br_count == 0)
{
if_count++;
}
}
if (pc->level == level)
{
if ((semi_count > 0) && hit_semi)
{
/* should have bailed due to close brace level drop */
LOG_FMT(LBRDEL, " no close brace\n");
return;
}
LOG_FMT(LBRDEL, " [%s %zu-%zu]", pc->text(), pc->orig_line, semi_count);
if (pc->type == CT_ELSE)
{
LOG_FMT(LBRDEL, " bailed on %s on line %zu\n",
pc->text(), pc->orig_line);
return;
}
was_fcn = (prev != NULL) && (prev->type == CT_FPAREN_CLOSE);
if (chunk_is_semicolon(pc) ||
(pc->type == CT_IF) ||
(pc->type == CT_ELSEIF) ||
(pc->type == CT_FOR) ||
(pc->type == CT_DO) ||
(pc->type == CT_WHILE) ||
(pc->type == CT_SWITCH) ||
(pc->type == CT_USING_STMT) ||
((pc->type == CT_BRACE_OPEN) && was_fcn))
{
hit_semi |= chunk_is_semicolon(pc);
if (++semi_count > 1)
{
LOG_FMT(LBRDEL, " bailed on %zu because of %s on line %zu\n",
bopen->orig_line, pc->text(), pc->orig_line);
return;
}
}
}
}
prev = pc;
pc = chunk_get_next_nc(pc);
}
if (pc == NULL)
{
LOG_FMT(LBRDEL, " NULL\n");
return;
}
LOG_FMT(LBRDEL, " - end on '%s' on line %zu. if_count=%zu semi_count=%zu\n",
get_token_name(pc->type), pc->orig_line, if_count, semi_count);
if (pc->type == CT_BRACE_CLOSE)
{
next = chunk_get_next_ncnl(pc);
while ((next != NULL) && (next->type == CT_VBRACE_CLOSE))
{
next = chunk_get_next_ncnl(next);
}
LOG_FMT(LBRDEL, " next is '%s'\n", get_token_name(next->type));
if ((if_count > 0) &&
((next->type == CT_ELSE) || (next->type == CT_ELSEIF)))
{
LOG_FMT(LBRDEL, " bailed on because 'else' is next and %zu ifs\n", if_count);
return;
}
if (semi_count > 0)
{
if (bopen->parent_type == CT_ELSE)
{
next = chunk_get_next_ncnl(bopen);
if (next->type == CT_IF)
{
prev = chunk_get_prev_ncnl(bopen);
LOG_FMT(LBRDEL, " else-if removing braces on line %zu and %zu\n",
bopen->orig_line, pc->orig_line);
chunk_del(bopen);
chunk_del(pc);
newline_del_between(prev, next);
if (cpd.settings[UO_nl_else_if].a & AV_ADD)
{
newline_add_between(prev, next);
}
return;
}
}
/* we have a pair of braces with only 1 statement inside */
convert_brace(bopen);
convert_brace(pc);
LOG_FMT(LBRDEL, " removing braces on line %zu and %zu\n",
bopen->orig_line, pc->orig_line);
}
else
{
LOG_FMT(LBRDEL, " empty statement\n");
}
}
else
{
LOG_FMT(LBRDEL, " not a close brace? - '%s'\n", pc->text());
}
} // examine_brace
/**
* Scans through the whole list and does stuff.
* It has to do some tricks to parse preprocessors.
*
* TODO: This can be cleaned up and simplified - we can look both forward and backward!
*/
void brace_cleanup(void)
{
chunk_t *pc;
struct parse_frame frm;
int pp_level;
memset(&frm, 0, sizeof(frm));
cpd.frame_count = 0;
cpd.in_preproc = CT_NONE;
cpd.pp_level = 0;
pc = chunk_get_head();
while (pc != NULL)
{
/* Check for leaving a #define body */
if ((cpd.in_preproc != CT_NONE) && ((pc->flags & PCF_IN_PREPROC) == 0))
{
if (cpd.in_preproc == CT_PP_DEFINE)
{
/* out of the #define body, restore the frame */
pf_pop(&frm);
}
cpd.in_preproc = CT_NONE;
}
/* Check for a preprocessor start */
pp_level = cpd.pp_level;
if (pc->type == CT_PREPROC)
{
pp_level = preproc_start(&frm, pc);
}
/* Do before assigning stuff from the frame */
if ((cpd.lang_flags & LANG_PAWN) != 0)
{
if ((frm.pse[frm.pse_tos].type == CT_VBRACE_OPEN) &&
(pc->type == CT_NEWLINE))
{
pc = pawn_check_vsemicolon(pc);
}
}
/* Assume the level won't change */
pc->level = frm.level;
pc->brace_level = frm.brace_level;
pc->pp_level = pp_level;
/**
* #define bodies get the full formatting treatment
* Also need to pass in the initial '#' to close out any virtual braces.
*/
if (!chunk_is_comment(pc) && !chunk_is_newline(pc) &&
((cpd.in_preproc == CT_PP_DEFINE) ||
(cpd.in_preproc == CT_NONE)))
{
cpd.consumed = false;
parse_cleanup(&frm, pc);
print_stack(LBCSAFTER, (pc->type == CT_VBRACE_CLOSE) ? "Virt-}" : pc->str, &frm, pc);
}
pc = chunk_get_next(pc);
}
}
/*
* See also it's preprocessor counterpart
* add_long_preprocessor_conditional_block_comment
* in defines.cpp
*/
void add_long_closebrace_comment(void)
{
LOG_FUNC_ENTRY();
chunk_t *br_close;
chunk_t *fcn_pc = NULL;
chunk_t *sw_pc = NULL;
chunk_t *ns_pc = NULL;
chunk_t *cl_pc = NULL;
chunk_t *cl_semi_pc = NULL;
unc_text xstr;
for (chunk_t *pc = chunk_get_head(); pc; pc = chunk_get_next_ncnl(pc))
{
if ((pc->type == CT_FUNC_DEF) ||
(pc->type == CT_OC_MSG_DECL))
{
fcn_pc = pc;
}
else if (pc->type == CT_SWITCH)
{
/* kinda pointless, since it always has the text "switch" */
sw_pc = pc;
}
else if (pc->type == CT_NAMESPACE)
{
ns_pc = pc;
}
else if (pc->type == CT_CLASS)
{
cl_pc = pc;
}
if ((pc->type != CT_BRACE_OPEN) || (pc->flags & PCF_IN_PREPROC))
{
continue;
}
chunk_t *br_open = pc;
size_t nl_count = 0;
chunk_t *tmp = pc;
while ((tmp = chunk_get_next(tmp)) != NULL)
{
if (chunk_is_newline(tmp))
{
nl_count += tmp->nl_count;
}
else if ((tmp->level == br_open->level) &&
(tmp->type == CT_BRACE_CLOSE))
{
br_close = tmp;
//LOG_FMT(LSYS, "found brace pair on lines %d and %d, nl_count=%d\n",
// br_open->orig_line, br_close->orig_line, nl_count);
/* Found the matching close brace - make sure a newline is next */
tmp = chunk_get_next(tmp);
// Check for end of class
if (tmp != NULL && tmp->parent_type == CT_CLASS && tmp->type == CT_SEMICOLON)
{
cl_semi_pc = tmp;
tmp = chunk_get_next(tmp);
if (tmp != NULL && !chunk_is_newline(tmp))
{
tmp = cl_semi_pc;
cl_semi_pc = NULL;
}
}
if ((tmp == NULL) || chunk_is_newline(tmp))
{
size_t nl_min = 0;
chunk_t *tag_pc = NULL;
if (br_open->parent_type == CT_SWITCH)
{
nl_min = cpd.settings[UO_mod_add_long_switch_closebrace_comment].u;
tag_pc = sw_pc;
xstr = sw_pc ? sw_pc->str : NULL; /* \todo NULL is no unc_text structure */
}
else if ((br_open->parent_type == CT_FUNC_DEF) ||
(br_open->parent_type == CT_OC_MSG_DECL))
{
nl_min = cpd.settings[UO_mod_add_long_function_closebrace_comment].u;
// 76006 Explicit null dereferenced, 2016-03-17
tag_pc = fcn_pc;
xstr.clear();
append_tag_name(xstr, tag_pc);
}
else if (br_open->parent_type == CT_NAMESPACE)
{
nl_min = cpd.settings[UO_mod_add_long_namespace_closebrace_comment].u;
// 76007 Explicit null dereferenced, 2016-03-17
tag_pc = ns_pc;
/* obtain the next chunck, normally this is the name of the namespace
* and append it to generate "namespace xyz" */
xstr = ns_pc->str;
xstr.append(" ");
append_tag_name(xstr, chunk_get_next(ns_pc));
}
else if (br_open->parent_type == CT_CLASS && cl_semi_pc && cl_pc)
{
nl_min = cpd.settings[UO_mod_add_long_class_closebrace_comment].u;
tag_pc = cl_pc;
xstr = tag_pc->str;
xstr.append(" ");
append_tag_name(xstr, chunk_get_next(cl_pc));
br_close = cl_semi_pc;
cl_semi_pc = NULL;
cl_pc = NULL;
}
if ((nl_min > 0) && (nl_count >= nl_min) && (tag_pc != NULL))
{
/* determine the added comment style */
c_token_t style = (cpd.lang_flags & (LANG_CPP | LANG_CS)) ?
CT_COMMENT_CPP : CT_COMMENT;
/* Add a comment after the close brace */
insert_comment_after(br_close, style, xstr);
}
}
break;
}
}
}
} // add_long_closebrace_comment
/**
* Swaps two lines that are started with the specified chunks.
*
* @param pc1 The first chunk of line 1
* @param pc2 The first chunk of line 2
*/
void chunk_swap_lines(chunk_t *pc1, chunk_t *pc2)
{
chunk_t *ref2;
chunk_t *tmp;
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
*/
ref2 = chunk_get_prev(pc2);
/* Move the line started at pc2 before pc1 */
while ((pc2 != NULL) && !chunk_is_newline(pc2))
{
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))
{
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))
{
int nl_count = pc1->nl_count;
pc1->nl_count = pc2->nl_count;
pc2->nl_count = nl_count;
chunk_swap(pc1, pc2);
}
} // chunk_swap_lines
/**
* For a series of lines ending in a comment, align them.
* The series ends when more than align_right_cmt_span newlines are found.
*
* Interesting info:
* - least pysically allowed column
* - intended column
* - least original cmt column
*
* min_col is the minimum allowed column (based on prev token col/size)
* cmt_col less than
*
* @param start Start point
* @return pointer the last item looked at
*/
chunk_t *align_trailing_comments(chunk_t *start)
{
int min_col = 0;
int min_orig = -1;
chunk_t *pc = start;
int nl_count = 0;
ChunkStack cs;
CmtAlignType cmt_type_start, cmt_type_cur;
int col;
int intended_col = cpd.settings[UO_align_right_cmt_at_col].n;
cmt_type_start = get_comment_align_type(pc);
LOG_FMT(LALADD, "%s: start on line=%d\n", __func__, pc->orig_line);
/* Find the max column */
while ((pc != NULL) && (nl_count < cpd.settings[UO_align_right_cmt_span].n))
{
if (((pc->flags & PCF_RIGHT_COMMENT) != 0) && (pc->column > 1))
{
cmt_type_cur = get_comment_align_type(pc);
if (cmt_type_cur == cmt_type_start)
{
col = 1 + (pc->brace_level * cpd.settings[UO_indent_columns].n);
LOG_FMT(LALADD, "%s: line=%d col=%d max_col=%d pc->col=%d pc->len=%d %s\n",
__func__, pc->orig_line, col, min_col, pc->column, pc->len,
get_token_name(pc->type));
if ((min_orig < 0) || (min_orig > pc->column))
{
min_orig = pc->column;
}
if (pc->column < col)
{
pc->column = col;
}
align_add(cs, pc, min_col, 1, true);//(intended_col < col));
nl_count = 0;
}
}
if (chunk_is_newline(pc))
{
nl_count += pc->nl_count;
}
pc = chunk_get_next(pc);
}
/* Start with the minimum original column */
col = min_orig;
/* fall back to the intended column */
if ((intended_col > 0) && (col > intended_col))
{
col = intended_col;
}
/* if less than allowed, bump it out */
if (col < min_col)
{
col = min_col;
}
/* bump out to the intended column */
if (col < intended_col)
{
col = intended_col;
}
LOG_FMT(LALADD, "%s: -- min_orig=%d intend=%d min_allowed=%d ==> col=%d\n", __func__,
min_orig, intended_col, min_col, col);
align_stack(cs, col, (intended_col != 0), LALTC);
return(chunk_get_next(pc));
}
