/**
* Scans between two parens and adds additional parens if needed.
* This function is recursive. If it hits another open paren, it'll call itself
* with the new bounds.
*
* Adds optional parens in an IF or SWITCH conditional statement.
*
* This basically just checks for a CT_COMPARE that isn't surrounded by parens.
* The edges for the compare are the open, close and any CT_BOOL tokens.
*
* This only handleds VERY simple patterns:
* (!a && b) => (!a && b) -- no change
* (a && b == 1) => (a && (b == 1))
* (a == 1 || b > 2) => ((a == 1) || (b > 2))
*
* FIXME: we really should bail if we transition between a preprocessor and
* a non-preprocessor
*/
static void check_bool_parens(chunk_t *popen, chunk_t *pclose, int nest)
{
chunk_t *pc;
chunk_t *ref = popen;
chunk_t *next;
bool hit_compare = false;
LOG_FMT(LPARADD, "%s(%d): popen on %d, col %d, pclose on %d, col %d, level=%d\n",
__func__, nest,
popen->orig_line, popen->orig_col,
pclose->orig_line, pclose->orig_col,
popen->level);
pc = popen;
while (((pc = chunk_get_next_ncnl(pc)) != NULL) && (pc != pclose))
{
if ((pc->type == CT_BOOL) ||
(pc->type == CT_QUESTION) ||
(pc->type == CT_COND_COLON))
{
LOG_FMT(LPARADD2, " -- %s [%.*s] at line %d col %d, level %d\n",
get_token_name(pc->type),
pc->len, pc->str, pc->orig_line, pc->orig_col, pc->level);
if (hit_compare)
{
hit_compare = false;
add_parens_between(ref, pc);
}
ref = pc;
}
else if (pc->type == CT_COMPARE)
{
LOG_FMT(LPARADD2, " -- compare [%.*s] at line %d col %d, level %d\n",
pc->len, pc->str, pc->orig_line, pc->orig_col, pc->level);
hit_compare = true;
}
else if (chunk_is_paren_open(pc))
{
next = chunk_get_next_type(pc, (c_token_t)(pc->type + 1), pc->level);
if (next != NULL)
{
check_bool_parens(pc, next, nest + 1);
pc = next;
}
}
else if ((pc->type == CT_BRACE_OPEN) ||
(pc->type == CT_SQUARE_OPEN) ||
(pc->type == CT_ANGLE_OPEN))
{
/* Skip [], {}, and <> */
pc = chunk_get_next_type(pc, (c_token_t)(pc->type + 1), pc->level);
}
}
if (hit_compare && (ref != popen))
{
add_parens_between(ref, pclose);
}
}
static int align_params(chunk_t *start, chunk_t *chunks[], int num_chunks)
{
int count = 0;
chunk_t *pc = start;
bool hit_comma = true;
pc = chunk_get_next_type(start, CT_FPAREN_OPEN, start->level);
while ((pc = chunk_get_next(pc)) != NULL)
{
if (chunk_is_newline(pc) ||
(count >= num_chunks) ||
(pc->type == CT_SEMICOLON) ||
((pc->type == CT_FPAREN_CLOSE) && (pc->level == start->level)))
{
break;
}
if (pc->level == (start->level + 1))
{
if (hit_comma)
{
chunks[count++] = pc;
hit_comma = false;
}
else if (pc->type == CT_COMMA)
{
hit_comma = true;
}
}
}
return(count);
}
void do_parens(void)
{
LOG_FUNC_ENTRY();
if (cpd.settings[UO_mod_full_paren_if_bool].b)
{
chunk_t *pc = chunk_get_head();
while ((pc = chunk_get_next_ncnl(pc)) != nullptr)
{
if ( pc->type != CT_SPAREN_OPEN
|| ( pc->parent_type != CT_IF
&& pc->parent_type != CT_ELSEIF
&& pc->parent_type != CT_SWITCH))
{
continue;
}
// Grab the close sparen
chunk_t *pclose = chunk_get_next_type(pc, CT_SPAREN_CLOSE, pc->level, scope_e::PREPROC);
if (pclose != nullptr)
{
check_bool_parens(pc, pclose, 0);
pc = pclose;
}
}
}
}
void do_parens(void)
{
LOG_FUNC_ENTRY();
chunk_t *pc;
chunk_t *pclose;
if (cpd.settings[UO_mod_full_paren_if_bool].b)
{
pc = chunk_get_head();
while ((pc = chunk_get_next_ncnl(pc)) != NULL)
{
if ((pc->type != CT_SPAREN_OPEN) ||
((pc->parent_type != CT_IF) &&
(pc->parent_type != CT_ELSEIF) &&
(pc->parent_type != CT_SWITCH)))
{
continue;
}
/* Grab the close sparen */
pclose = chunk_get_next_type(pc, CT_SPAREN_CLOSE, pc->level, CNAV_PREPROC);
if (pclose != NULL)
{
check_bool_parens(pc, pclose, 0);
pc = pclose;
}
}
}
}
/**
* We are on a level 0 function proto of def
*/
static chunk_t *pawn_mark_function0(chunk_t *start, chunk_t *fcn)
{
chunk_t *last;
/* handle prototypes */
if (start == fcn)
{
last = chunk_get_next_type(fcn, CT_PAREN_CLOSE, fcn->level);
last = chunk_get_next(last);
if ((last != NULL) && (last->type == CT_SEMICOLON))
{
LOG_FMT(LPFUNC, "%s: %d] '%s' proto due to semicolon\n", __func__,
fcn->orig_line, fcn->str.c_str());
fcn->type = CT_FUNC_PROTO;
return(last);
}
}
else
{
if ((start->type == CT_FORWARD) ||
(start->type == CT_NATIVE))
{
LOG_FMT(LPFUNC, "%s: %d] '%s' [%s] proto due to %s\n", __func__,
fcn->orig_line, fcn->str.c_str(),
get_token_name(fcn->type),
get_token_name(start->type));
fcn->type = CT_FUNC_PROTO;
return(chunk_get_next_nc(fcn));
}
}
/* Not a prototype, so it must be a function def */
return(pawn_process_func_def(fcn));
}
/**
* Functions prototypes and definitions can only appear in level 0.
*
* Function prototypes start with "native", "forward", or are just a function
* with a trailing semicolon instead of a open brace (or something else)
*
* somefunc(params) <-- def
* stock somefunc(params) <-- def
* somefunc(params); <-- proto
* forward somefunc(params) <-- proto
* native somefunc[rect](params) <-- proto
*
* Functions start with 'stock', 'static', 'public', or '@' (on level 0)
*
* Variable definitions start with 'stock', 'static', 'new', or 'public'.
*/
static chunk_t *pawn_process_line(chunk_t *start)
{
LOG_FUNC_ENTRY();
chunk_t *pc;
chunk_t *fcn = NULL;
//LOG_FMT(LSYS, "%s: %d - %s\n", __func__,
// start->orig_line, start->text());
if ((start->type == CT_NEW) ||
chunk_is_str(start, "const", 5))
{
return(pawn_process_variable(start));
}
/* if a open paren is found before an assign, then this is a function */
if (start->type == CT_WORD)
{
fcn = start;
}
pc = start;
while (((pc = chunk_get_next_nc(pc)) != NULL) &&
!chunk_is_str(pc, "(", 1) &&
(pc->type != CT_ASSIGN) &&
(pc->type != CT_NEWLINE))
{
if ((pc->level == 0) &&
((pc->type == CT_FUNCTION) ||
(pc->type == CT_WORD) ||
(pc->type == CT_OPERATOR_VAL)))
{
fcn = pc;
}
}
if (pc != NULL)
{
if (pc->type == CT_ASSIGN)
{
return(pawn_process_variable(pc));
}
}
if (fcn != NULL)
{
//LOG_FMT(LSYS, "FUNCTION: %s\n", fcn->text());
return(pawn_mark_function0(start, fcn));
}
if (start->type == CT_ENUM)
{
pc = chunk_get_next_type(start, CT_BRACE_CLOSE, start->level);
return(pc);
}
//LOG_FMT(LSYS, "%s: Don't understand line %d, starting with '%s' [%s]\n",
// __func__, start->orig_line, start->text(), get_token_name(start->type));
return(start);
} // pawn_process_line
/**
* Remove the case brace, if allowable.
*/
static chunk_t *mod_case_brace_remove(chunk_t *br_open)
{
LOG_FUNC_ENTRY();
chunk_t *pc;
chunk_t *br_close;
chunk_t *next = chunk_get_next_ncnl(br_open, CNAV_PREPROC);
LOG_FMT(LMCB, "%s: line %lu", __func__, br_open->orig_line);
/* Find the matching brace close */
br_close = chunk_get_next_type(br_open, CT_BRACE_CLOSE, br_open->level, CNAV_PREPROC);
if (br_close == NULL)
{
LOG_FMT(LMCB, " - no close\n");
return(next);
}
/* Make sure 'break', 'return', 'goto', 'case' or '}' is after the close brace */
pc = chunk_get_next_ncnl(br_close, CNAV_PREPROC);
if ((pc == NULL) ||
((pc->type != CT_BREAK) &&
(pc->type != CT_RETURN) &&
(pc->type != CT_CASE) &&
(pc->type != CT_GOTO) &&
(pc->type != CT_BRACE_CLOSE)))
{
LOG_FMT(LMCB, " - after '%s'\n",
(pc == NULL) ? "<null>" : get_token_name(pc->type));
return(next);
}
/* scan to make sure there are no definitions at brace level between braces */
for (pc = br_open; pc != br_close; pc = chunk_get_next_ncnl(pc, CNAV_PREPROC))
{
if ((pc->level == (br_open->level + 1)) && (pc->flags & PCF_VAR_DEF))
{
LOG_FMT(LMCB, " - vardef on line %lu: '%s'\n", pc->orig_line, pc->text());
return(next);
}
}
LOG_FMT(LMCB, " - removing braces on lines %lu and %lu\n",
br_open->orig_line, br_close->orig_line);
for (pc = br_open; pc != br_close; pc = chunk_get_next_ncnl(pc, CNAV_PREPROC))
{
pc->brace_level--;
pc->level--;
}
next = chunk_get_prev(br_open, CNAV_PREPROC);
chunk_del(br_open);
chunk_del(br_close);
return(chunk_get_next(next, CNAV_PREPROC));
} // mod_case_brace_remove
/**
* Aligns all backslash-newline combos in the file.
* This should be done LAST.
*/
void align_backslash_newline(void)
{
chunk_t *pc;
pc = chunk_get_head();
while (pc != NULL)
{
if (pc->type != CT_NL_CONT)
{
pc = chunk_get_next_type(pc, CT_NL_CONT, -1);
continue;
}
pc = align_nl_cont(pc);
}
}
void align_struct_initializers(void)
{
LOG_FUNC_ENTRY();
chunk_t *pc = chunk_get_head();
while (pc != nullptr)
{
chunk_t *prev = chunk_get_prev_ncnl(pc);
if ( chunk_is_token(prev, CT_ASSIGN)
&& ( chunk_is_token(pc, CT_BRACE_OPEN)
|| (language_is_set(LANG_D) && chunk_is_token(pc, CT_SQUARE_OPEN))))
{
align_init_brace(pc);
}
pc = chunk_get_next_type(pc, CT_BRACE_OPEN, -1);
}
} // align_struct_initializers
/**
* Aligns stuff inside a multi-line "= { ... }" sequence.
*/
void align_struct_initializers(void)
{
chunk_t *pc;
chunk_t *prev;
pc = chunk_get_head();
while (pc != NULL)
{
prev = chunk_get_prev_ncnl(pc);
if ((prev != NULL) && (prev->type == CT_ASSIGN) &&
((pc->type == CT_BRACE_OPEN) ||
((cpd.lang_flags & LANG_D) && (pc->type == CT_SQUARE_OPEN))))
{
align_init_brace(pc);
}
pc = chunk_get_next_type(pc, CT_BRACE_OPEN, -1);
}
}
/**
* Traverse the if chain and see if all can be removed
*/
static void process_if_chain(chunk_t *br_start)
{
chunk_t *braces[256];
chunk_t *br_close;
int br_cnt = 0;
chunk_t *pc;
bool must_have_braces = false;
bool tmp;
pc = br_start;
LOG_FMT(LBRCH, "%s: if starts on line %d\n", __func__, br_start->orig_line);
while (pc != NULL)
{
if (pc->type == CT_BRACE_OPEN)
{
tmp = can_remove_braces(pc);
LOG_FMT(LBRCH, " [%d] line %d - can%s remove %s\n",
br_cnt, pc->orig_line, tmp ? "" : "not",
get_token_name(pc->type));
if (!tmp)
{
must_have_braces = true;
}
}
else
{
tmp = should_add_braces(pc);
if (tmp)
{
must_have_braces = true;
}
LOG_FMT(LBRCH, " [%d] line %d - %s %s\n",
br_cnt, pc->orig_line, tmp ? "should add" : "ignore",
get_token_name(pc->type));
}
braces[br_cnt++] = pc;
br_close = chunk_get_next_type(pc, (c_token_t)(pc->type + 1), pc->level, CNAV_PREPROC);
if (br_close == NULL)
{
break;
}
braces[br_cnt++] = br_close;
pc = chunk_get_next_ncnl(br_close, CNAV_PREPROC);
if ((pc == NULL) || (pc->type != CT_ELSE))
{
break;
}
pc = chunk_get_next_ncnl(pc, CNAV_PREPROC);
if ((pc != NULL) && (pc->type == CT_ELSEIF))
{
while ((pc != NULL) && (pc->type != CT_VBRACE_OPEN) && (pc->type != CT_BRACE_OPEN))
{
pc = chunk_get_next_ncnl(pc, CNAV_PREPROC);
}
}
if (pc == NULL)
{
break;
}
if ((pc->type != CT_BRACE_OPEN) && (pc->type != CT_VBRACE_OPEN))
{
break;
}
}
if (must_have_braces)
{
LOG_FMT(LBRCH, "%s: add braces on lines[%d]:", __func__, br_cnt);
while (--br_cnt >= 0)
{
if ((braces[br_cnt]->type == CT_VBRACE_OPEN) ||
(braces[br_cnt]->type == CT_VBRACE_CLOSE))
{
LOG_FMT(LBRCH, " %d", braces[br_cnt]->orig_line);
convert_vbrace(braces[br_cnt]);
}
else
{
LOG_FMT(LBRCH, " {%d}", braces[br_cnt]->orig_line);
}
braces[br_cnt] = NULL;
}
LOG_FMT(LBRCH, "\n");
}
else
{
LOG_FMT(LBRCH, "%s: remove braces on lines[%d]:", __func__, br_cnt);
while (--br_cnt >= 0)
{
if ((braces[br_cnt]->type == CT_BRACE_OPEN) ||
(braces[br_cnt]->type == CT_BRACE_CLOSE))
{
LOG_FMT(LBRCH, " {%d}", braces[br_cnt]->orig_line);
convert_brace(braces[br_cnt]);
}
else
{
LOG_FMT(LBRCH, " %d", braces[br_cnt]->orig_line);
}
braces[br_cnt] = NULL;
}
LOG_FMT(LBRCH, "\n");
}
}
static chunk_t *pawn_process_func_def(chunk_t *pc)
{
/* We are on a function definition */
chunk_t *clp;
chunk_t *last;
chunk_t *next;
pc->type = CT_FUNC_DEF;
/* If we don't have a brace open right after the close fparen, then
* we need to add virtual braces around the function body.
*/
clp = chunk_get_next_str(pc, ")", 1, 0);
last = chunk_get_next_ncnl(clp);
if (last != NULL)
{
LOG_FMT(LPFUNC, "%s: %d] last is '%s' [%s]\n", __func__,
last->orig_line, last->str.c_str(), get_token_name(last->type));
}
/* See if there is a state clause after the function */
if ((last != NULL) && chunk_is_str(last, "<", 1))
{
LOG_FMT(LPFUNC, "%s: %d] '%s' has state angle open %s\n", __func__,
pc->orig_line, pc->str.c_str(), get_token_name(last->type));
last->type = CT_ANGLE_OPEN;
last->parent_type = CT_FUNC_DEF;
while (((last = chunk_get_next(last)) != NULL) &&
!chunk_is_str(last, ">", 1))
{
}
if (last != NULL)
{
LOG_FMT(LPFUNC, "%s: %d] '%s' has state angle close %s\n", __func__,
pc->orig_line, pc->str.c_str(), get_token_name(last->type));
last->type = CT_ANGLE_CLOSE;
last->parent_type = CT_FUNC_DEF;
}
last = chunk_get_next_ncnl(last);
}
if (last == NULL)
{
return(last);
}
if (last->type == CT_BRACE_OPEN)
{
last->parent_type = CT_FUNC_DEF;
last = chunk_get_next_type(last, CT_BRACE_CLOSE, last->level);
if (last != NULL)
{
last->parent_type = CT_FUNC_DEF;
}
}
else
{
LOG_FMT(LPFUNC, "%s: %d] '%s' fdef: expected brace open: %s\n", __func__,
pc->orig_line, pc->str.c_str(), get_token_name(last->type));
chunk_t chunk;
chunk = *last;
chunk.str.clear();
chunk.type = CT_VBRACE_OPEN;
chunk.parent_type = CT_FUNC_DEF;
chunk_t *prev = chunk_add_before(&chunk, last);
last = prev;
/* find the next newline at level 0 */
prev = chunk_get_next_ncnl(prev);
do
{
LOG_FMT(LPFUNC, "%s:%d] check %s, level %d\n", __func__,
prev->orig_line, get_token_name(prev->type), prev->level);
if ((prev->type == CT_NEWLINE) &&
(prev->level == 0))
{
next = chunk_get_next_ncnl(prev);
if ((next != NULL) &&
(next->type != CT_ELSE) &&
(next->type != CT_WHILE_OF_DO))
{
break;
}
}
prev->level++;
prev->brace_level++;
last = prev;
} while ((prev = chunk_get_next(prev)) != NULL);
if (last != NULL)
{
LOG_FMT(LPFUNC, "%s:%d] ended on %s, level %d\n", __func__,
last->orig_line, get_token_name(last->type), last->level);
}
chunk = *last;
chunk.str.clear();
chunk.column += last->len();
chunk.type = CT_VBRACE_CLOSE;
chunk.level = 0;
chunk.brace_level = 0;
chunk.parent_type = CT_FUNC_DEF;
last = chunk_add_after(&chunk, last);
}
return(last);
}
/**
* Adds the javadoc-style @param and @return stuff, based on the params and
* return value for pc.
* If the arg list is '()' or '(void)', then no @params are added.
* Likewise, if the return value is 'void', then no @return is added.
*/
static void add_comment_javaparam(chunk_t *pc, cmt_reflow& cmt)
{
chunk_t *fpo;
chunk_t *fpc;
chunk_t *tmp;
chunk_t *prev;
bool has_param = true;
bool need_nl = false;
fpo = chunk_get_next_type(pc, CT_FPAREN_OPEN, pc->level);
if (fpo == NULL)
{
return;
}
fpc = chunk_get_next_type(fpo, CT_FPAREN_CLOSE, pc->level);
if (fpc == NULL)
{
return;
}
/* Check for 'foo()' and 'foo(void)' */
if (chunk_get_next_ncnl(fpo) == fpc)
{
has_param = false;
}
else
{
tmp = chunk_get_next_ncnl(fpo);
if ((tmp == chunk_get_prev_ncnl(fpc)) &&
chunk_is_str(tmp, "void", 4))
{
has_param = false;
}
}
if (has_param)
{
tmp = fpo;
prev = NULL;
while ((tmp = chunk_get_next(tmp)) != NULL)
{
if ((tmp->type == CT_COMMA) || (tmp == fpc))
{
if (need_nl)
{
add_comment_text("\n ", cmt, false);
}
need_nl = true;
add_text("@param");
if (prev != NULL)
{
add_text(" ");
add_text(prev->str);
add_text(" TODO");
}
prev = NULL;
if (tmp == fpc)
{
break;
}
}
if (tmp->type == CT_WORD)
{
prev = tmp;
}
}
}
/* Do the return stuff */
tmp = chunk_get_prev_ncnl(pc);
if ((tmp != NULL) && !chunk_is_str(tmp, "void", 4))
{
if (need_nl)
{
add_comment_text("\n ", cmt, false);
}
add_text("@return TODO");
}
}
/**
* 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);
}
/**
* 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));
}
/**
* 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);
}
void tokenize_cleanup(void)
{
LOG_FUNC_ENTRY();
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
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 *
* 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))
{
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);
}
}
/**
* 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();
}
