/**
* 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);
}
static bool check_complex_statements(parse_frame_t *frm, chunk_t *pc)
{
LOG_FUNC_ENTRY();
c_token_t parent;
// Turn an optional parenthesis into either a real parenthesis or a brace
if (frm->pse[frm->pse_tos].stage == brace_stage_e::OP_PAREN1)
{
frm->pse[frm->pse_tos].stage = (pc->type != CT_PAREN_OPEN) ? brace_stage_e::BRACE2 : brace_stage_e::PAREN1;
}
// Check for CT_ELSE after CT_IF
while (frm->pse[frm->pse_tos].stage == brace_stage_e::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 = brace_stage_e::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 == brace_stage_e::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
set_chunk_type(pc, CT_ELSEIF);
frm->pse[frm->pse_tos].type = CT_ELSEIF;
frm->pse[frm->pse_tos].stage = brace_stage_e::PAREN1;
return(true);
}
}
// Jump to the 'expecting brace' stage
frm->pse[frm->pse_tos].stage = brace_stage_e::BRACE2;
}
// Check for CT_CATCH or CT_FINALLY after CT_TRY or CT_CATCH
while (frm->pse[frm->pse_tos].stage == brace_stage_e::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) ? brace_stage_e::CATCH_WHEN : brace_stage_e::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 optional parenthesis and optional CT_WHEN after CT_CATCH
if (frm->pse[frm->pse_tos].stage == brace_stage_e::CATCH_WHEN)
{
if (pc->type == CT_PAREN_OPEN) // this is for the paren after "catch"
{
// Replace CT_PAREN_OPEN with CT_SPAREN_OPEN
set_chunk_type(pc, CT_SPAREN_OPEN);
frm->pse[frm->pse_tos].type = pc->type;
frm->pse[frm->pse_tos].stage = brace_stage_e::PAREN1;
return(false);
}
if (pc->type == CT_WHEN)
{
frm->pse[frm->pse_tos].type = pc->type;
frm->pse[frm->pse_tos].stage = brace_stage_e::OP_PAREN1;
return(true);
}
if (pc->type == CT_BRACE_OPEN)
{
frm->pse[frm->pse_tos].stage = brace_stage_e::BRACE2;
return(false);
}
}
// Check for CT_WHILE after the CT_DO
if (frm->pse[frm->pse_tos].stage == brace_stage_e::WHILE)
{
if (pc->type == CT_WHILE)
{
set_chunk_type(pc, CT_WHILE_OF_DO);
frm->pse[frm->pse_tos].type = CT_WHILE_OF_DO; //CT_WHILE;
frm->pse[frm->pse_tos].stage = brace_stage_e::WOD_PAREN;
return(true);
}
LOG_FMT(LWARN, "%s(%d): %s, orig_line is %zu, Error: Expected 'while', got '%s'\n",
__func__, __LINE__, cpd.filename, pc->orig_line, pc->text());
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 == brace_stage_e::BRACE2)
|| (frm->pse[frm->pse_tos].stage == brace_stage_e::BRACE_DO)))
{
if ( (cpd.lang_flags & LANG_CS)
&& pc->type == CT_USING_STMT
&& (!cpd.settings[UO_indent_using_block].b))
{
// don't indent the using block
}
else
{
parent = frm->pse[frm->pse_tos].type;
chunk_t *vbrace = insert_vbrace_open_before(pc, frm);
set_chunk_parent(vbrace, parent);
frm->level++;
frm->brace_level++;
push_fmr_pse(frm, vbrace, brace_stage_e::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, "%s(%d): orig_line is %zu, 2.marked '%s' as stmt start\n",
__func__, __LINE__, pc->orig_line, pc->text());
}
}
// Verify open parenthesis in complex statement
if ( pc->type != CT_PAREN_OPEN
&& ( (frm->pse[frm->pse_tos].stage == brace_stage_e::PAREN1)
|| (frm->pse[frm->pse_tos].stage == brace_stage_e::WOD_PAREN)))
{
LOG_FMT(LWARN, "%s(%d): %s, orig_line is %zu, Error: Expected '(', got '%s' for '%s'\n",
__func__, __LINE__, cpd.filename, pc->orig_line, pc->text(),
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);
} // check_complex_statements
/**
* At the heart of this algorithm are two stacks.
* There is the Paren Stack (PS) and the Frame stack.
*
* The PS (pse in the code) keeps track of braces, parens,
* if/else/switch/do/while/etc items -- anything that is nestable.
* Complex statements go through stages.
* Take this simple if statement as an example:
* if ( x ) { x--; }
*
* The stack would change like so: 'token' stack afterwards
* 'if' [IF - 1]
* '(' [IF - 1] [PAREN OPEN]
* 'x' [IF - 1] [PAREN OPEN]
* ')' [IF - 2] <- note that the state was incremented
* '{' [IF - 2] [BRACE OPEN]
* 'x' [IF - 2] [BRACE OPEN]
* '--' [IF - 2] [BRACE OPEN]
* ';' [IF - 2] [BRACE OPEN]
* '}' [IF - 3]
* <- lack of else kills the IF, closes statement
*
* Virtual braces example:
* if ( x ) x--; else x++;
*
* 'if' [IF - 1]
* '(' [IF - 1] [PAREN OPEN]
* 'x' [IF - 1] [PAREN OPEN]
* ')' [IF - 2]
* 'x' [IF - 2] [VBRACE OPEN] <- VBrace open inserted before because '{' was not next
* '--' [IF - 2] [VBRACE OPEN]
* ';' [IF - 3] <- VBrace close inserted after semicolon
* 'else' [ELSE - 0] <- IF changed into ELSE
* 'x' [ELSE - 0] [VBRACE OPEN] <- lack of '{' -> VBrace
* '++' [ELSE - 0] [VBRACE OPEN]
* ';' [ELSE - 0] <- VBrace close inserted after semicolon
* <- ELSE removed after statement close
*
* The pse stack is kept on a frame stack.
* The frame stack is need for languages that support preprocessors (C, C++, C#)
* that can arbitrarily change code flow. It also isolates #define macros so
* that they are indented independently and do not affect the rest of the program.
*
* When an #if is hit, a copy of the current frame is push on the frame stack.
* When an #else/#elif is hit, a copy of the current stack is pushed under the
* #if frame and the original (pre-#if) frame is copied to the current frame.
* When #endif is hit, the top frame is popped.
* This has the following effects:
* - a simple #if / #endif does not affect program flow
* - #if / #else /#endif - continues from the #if clause
*
* When a #define is entered, the current frame is pushed and cleared.
* When a #define is exited, the frame is popped.
*/
static void parse_cleanup(struct parse_frame *frm, chunk_t *pc)
{
c_token_t parent = CT_NONE;
chunk_t *prev;
LOG_FMT(LTOK, "%s:%d] %16s - tos:%d/%16s stg:%d\n",
__func__, pc->orig_line, get_token_name(pc->type),
frm->pse_tos, get_token_name(frm->pse[frm->pse_tos].type),
frm->pse[frm->pse_tos].stage);
/* Mark statement starts */
if (((frm->stmt_count == 0) || (frm->expr_count == 0)) &&
!chunk_is_semicolon(pc) &&
(pc->type != CT_BRACE_CLOSE) &&
(pc->type != CT_VBRACE_CLOSE) &&
!chunk_is_str(pc, ")", 1) &&
!chunk_is_str(pc, "]", 1))
{
pc->flags |= PCF_EXPR_START;
pc->flags |= (frm->stmt_count == 0) ? PCF_STMT_START : 0;
LOG_FMT(LSTMT, "%d] 1.marked %s as %s start st:%d ex:%d\n",
pc->orig_line, pc->str.c_str(), (pc->flags &PCF_STMT_START) ? "stmt" : "expr",
frm->stmt_count, frm->expr_count);
}
frm->stmt_count++;
frm->expr_count++;
if (frm->sparen_count > 0)
{
int tmp;
pc->flags |= PCF_IN_SPAREN;
/* Mark everything in the a for statement */
for (tmp = frm->pse_tos - 1; tmp >= 0; tmp--)
{
if (frm->pse[tmp].type == CT_FOR)
{
pc->flags |= PCF_IN_FOR;
break;
}
}
/* Mark the parent on semicolons in for() stmts */
if ((pc->type == CT_SEMICOLON) &&
(frm->pse_tos > 1) &&
(frm->pse[frm->pse_tos - 1].type == CT_FOR))
{
pc->parent_type = CT_FOR;
}
}
/* Check the progression of complex statements */
if (frm->pse[frm->pse_tos].stage != BS_NONE)
{
if (check_complex_statements(frm, pc))
{
return;
}
}
/**
* Check for a virtual brace statement close due to a semicolon.
* The virtual brace will get handled the next time through.
* The semicolon isn't handled at all.
* TODO: may need to float VBRACE past comments until newline?
*/
if (frm->pse[frm->pse_tos].type == CT_VBRACE_OPEN)
{
if (chunk_is_semicolon(pc))
{
cpd.consumed = true;
close_statement(frm, pc);
}
else if ((cpd.lang_flags & LANG_PAWN) != 0)
{
if (pc->type == CT_BRACE_CLOSE)
{
close_statement(frm, pc);
}
}
}
/* Handle close paren, vbrace, brace, and square */
if ((pc->type == CT_PAREN_CLOSE) ||
(pc->type == CT_BRACE_CLOSE) ||
(pc->type == CT_VBRACE_CLOSE) ||
(pc->type == CT_ANGLE_CLOSE) ||
(pc->type == CT_MACRO_CLOSE) ||
(pc->type == CT_SQUARE_CLOSE))
{
/* Change CT_PAREN_CLOSE into CT_SPAREN_CLOSE or CT_FPAREN_CLOSE */
if ((pc->type == CT_PAREN_CLOSE) &&
((frm->pse[frm->pse_tos].type == CT_FPAREN_OPEN) ||
(frm->pse[frm->pse_tos].type == CT_SPAREN_OPEN)))
{
pc->type = (c_token_t)(frm->pse[frm->pse_tos].type + 1);
if (pc->type == CT_SPAREN_CLOSE)
{
frm->sparen_count--;
pc->flags &= ~PCF_IN_SPAREN;
}
}
/* Make sure the open / close match */
if (pc->type != (frm->pse[frm->pse_tos].type + 1))
{
if ((frm->pse[frm->pse_tos].type != CT_NONE) &&
(frm->pse[frm->pse_tos].type != CT_PP_DEFINE))
{
LOG_FMT(LWARN, "%s:%d Error: Unexpected '%s' for '%s', which was on line %d\n",
cpd.filename, pc->orig_line, pc->str.c_str(),
get_token_name(frm->pse[frm->pse_tos].pc->type),
frm->pse[frm->pse_tos].pc->orig_line);
print_stack(LBCSPOP, "=Error ", frm, pc);
cpd.error_count++;
}
}
else
{
cpd.consumed = true;
/* Copy the parent, update the paren/brace levels */
pc->parent_type = frm->pse[frm->pse_tos].parent;
frm->level--;
if ((pc->type == CT_BRACE_CLOSE) ||
(pc->type == CT_VBRACE_CLOSE) ||
(pc->type == CT_MACRO_CLOSE))
{
frm->brace_level--;
}
pc->level = frm->level;
pc->brace_level = frm->brace_level;
/* Pop the entry */
frm->pse_tos--;
print_stack(LBCSPOP, "-Close ", frm, pc);
/* See if we are in a complex statement */
if (frm->pse[frm->pse_tos].stage != BS_NONE)
{
handle_complex_close(frm, pc);
}
}
}
/* In this state, we expect a semicolon, but we'll also hit the closing
* sparen, so we need to check cpd.consumed to see if the close sparen was
* aleady handled.
*/
if (frm->pse[frm->pse_tos].stage == BS_WOD_SEMI)
{
chunk_t *tmp = pc;
if (cpd.consumed)
{
/* If consumed, then we are on the close sparen.
* PAWN: Check the next chunk for a semicolon. If it isn't, then
* add a virtual semicolon, which will get handled on the next pass.
*/
if (cpd.lang_flags & LANG_PAWN)
{
tmp = chunk_get_next_ncnl(pc);
if ((tmp->type != CT_SEMICOLON) && (tmp->type != CT_VSEMICOLON))
{
pawn_add_vsemi_after(pc);
}
}
}
else
{
/* Complain if this ISN'T a semicolon, but close out WHILE_OF_DO anyway */
if ((pc->type == CT_SEMICOLON) || (pc->type == CT_VSEMICOLON))
{
cpd.consumed = true;
pc->parent_type = CT_WHILE_OF_DO;
}
else
{
LOG_FMT(LWARN, "%s:%d: Error: Expected a semicolon for WHILE_OF_DO, but got '%s'\n",
cpd.filename, pc->orig_line, get_token_name(pc->type));
cpd.error_count++;
}
handle_complex_close(frm, pc);
}
}
/* Get the parent type for brace and paren open */
parent = pc->parent_type;
if ((pc->type == CT_PAREN_OPEN) ||
(pc->type == CT_FPAREN_OPEN) ||
(pc->type == CT_SPAREN_OPEN) ||
(pc->type == CT_BRACE_OPEN))
{
prev = chunk_get_prev_ncnl(pc);
if (prev != NULL)
{
if ((pc->type == CT_PAREN_OPEN) ||
(pc->type == CT_FPAREN_OPEN) ||
(pc->type == CT_SPAREN_OPEN))
{
/* Set the parent for parens and change paren type */
if (frm->pse[frm->pse_tos].stage != BS_NONE)
{
pc->type = CT_SPAREN_OPEN;
parent = frm->pse[frm->pse_tos].type;
frm->sparen_count++;
}
else if (prev->type == CT_FUNCTION)
{
pc->type = CT_FPAREN_OPEN;
parent = CT_FUNCTION;
}
else
{
/* no need to set parent */
}
}
else /* must be CT_BRACE_OPEN */
{
/* Set the parent for open braces */
if (frm->pse[frm->pse_tos].stage != BS_NONE)
{
parent = frm->pse[frm->pse_tos].type;
}
else if ((prev->type == CT_ASSIGN) && (prev->str[0] == '='))
{
parent = CT_ASSIGN;
}
else if (prev->type == CT_FPAREN_CLOSE)
{
parent = CT_FUNCTION;
}
else
{
/* no need to set parent */
}
}
}
}
/**
* Adjust the level for opens & create a stack entry
* Note that CT_VBRACE_OPEN has already been handled.
*/
if ((pc->type == CT_BRACE_OPEN) ||
(pc->type == CT_PAREN_OPEN) ||
(pc->type == CT_FPAREN_OPEN) ||
(pc->type == CT_SPAREN_OPEN) ||
(pc->type == CT_ANGLE_OPEN) ||
(pc->type == CT_MACRO_OPEN) ||
(pc->type == CT_SQUARE_OPEN))
{
frm->level++;
if ((pc->type == CT_BRACE_OPEN) ||
(pc->type == CT_MACRO_OPEN))
{
frm->brace_level++;
}
push_fmr_pse(frm, pc, BS_NONE, "+Open ");
frm->pse[frm->pse_tos].parent = parent;
pc->parent_type = parent;
}
pattern_class patcls = get_token_pattern_class(pc->type);
/** Create a stack entry for complex statements IF/DO/FOR/WHILE/SWITCH */
if (patcls == PATCLS_BRACED)
{
push_fmr_pse(frm, pc,
(pc->type == CT_DO) ? BS_BRACE_DO : BS_BRACE2,
"+ComplexBraced");
}
else if (patcls == PATCLS_PBRACED)
{
brstage_e bs = BS_PAREN1;
if ((pc->type == CT_WHILE) && maybe_while_of_do(pc))
{
pc->type = CT_WHILE_OF_DO;
bs = BS_WOD_PAREN;
}
push_fmr_pse(frm, pc, bs, "+ComplexParenBraced");
}
else if (patcls == PATCLS_OPBRACED)
{
push_fmr_pse(frm, pc, BS_OP_PAREN1, "+ComplexOpParenBraced");
}
else if (patcls == PATCLS_ELSE)
{
push_fmr_pse(frm, pc, BS_ELSEIF, "+ComplexElse");
}
/* Mark simple statement/expression starts
* - after { or }
* - after ';', but not if the paren stack top is a paren
* - after '(' that has a parent type of CT_FOR
*/
if ((pc->type == CT_SQUARE_OPEN) ||
((pc->type == CT_BRACE_OPEN) && (pc->parent_type != CT_ASSIGN)) ||
(pc->type == CT_BRACE_CLOSE) ||
(pc->type == CT_VBRACE_CLOSE) ||
((pc->type == CT_SPAREN_OPEN) && (pc->parent_type == CT_FOR)) ||
(pc->type == CT_COLON) ||
(pc->type == CT_OC_END) ||
(chunk_is_semicolon(pc) &&
(frm->pse[frm->pse_tos].type != CT_PAREN_OPEN) &&
(frm->pse[frm->pse_tos].type != CT_FPAREN_OPEN) &&
(frm->pse[frm->pse_tos].type != CT_SPAREN_OPEN)))
{
LOG_FMT(LSTMT, "%s: %d> reset1 stmt on %s\n",
__func__, pc->orig_line, pc->str.c_str());
frm->stmt_count = 0;
frm->expr_count = 0;
}
/* Mark expression starts */
chunk_t *tmp = chunk_get_next_ncnl(pc);
if ((pc->type == CT_ARITH) ||
(pc->type == CT_ASSIGN) ||
(pc->type == CT_CASE) ||
(pc->type == CT_COMPARE) ||
((pc->type == CT_STAR) && tmp && (tmp->type != CT_STAR)) ||
(pc->type == CT_BOOL) ||
(pc->type == CT_MINUS) ||
(pc->type == CT_PLUS) ||
(pc->type == CT_CARET) ||
(pc->type == CT_ANGLE_OPEN) ||
(pc->type == CT_ANGLE_CLOSE) ||
(pc->type == CT_RETURN) ||
(pc->type == CT_THROW) ||
(pc->type == CT_GOTO) ||
(pc->type == CT_CONTINUE) ||
(pc->type == CT_PAREN_OPEN) ||
(pc->type == CT_FPAREN_OPEN) ||
(pc->type == CT_SPAREN_OPEN) ||
(pc->type == CT_BRACE_OPEN) ||
chunk_is_semicolon(pc) ||
(pc->type == CT_COMMA) ||
(pc->type == CT_NOT) ||
(pc->type == CT_INV) ||
(pc->type == CT_COLON) ||
(pc->type == CT_QUESTION))
{
frm->expr_count = 0;
LOG_FMT(LSTMT, "%s: %d> reset expr on %s\n",
__func__, pc->orig_line, pc->str.c_str());
}
}
/**
* At the heart of this algorithm are two stacks.
* There is the Paren Stack (PS) and the Frame stack.
*
* The PS (pse in the code) keeps track of braces, parens,
* if/else/switch/do/while/etc items -- anything that is nestable.
* Complex statements go through stages.
* Take this simple if statement as an example:
* if ( x ) { x--; }
*
* The stack would change like so: 'token' stack afterwards
* 'if' [IF - 1]
* '(' [IF - 1] [PAREN OPEN]
* 'x' [IF - 1] [PAREN OPEN]
* ')' [IF - 2] <- note that the state was incremented
* '{' [IF - 2] [BRACE OPEN]
* 'x' [IF - 2] [BRACE OPEN]
* '--' [IF - 2] [BRACE OPEN]
* ';' [IF - 2] [BRACE OPEN]
* '}' [IF - 3]
* <- lack of else kills the IF, closes statement
*
* Virtual braces example:
* if ( x ) x--; else x++;
*
* 'if' [IF - 1]
* '(' [IF - 1] [PAREN OPEN]
* 'x' [IF - 1] [PAREN OPEN]
* ')' [IF - 2]
* 'x' [IF - 2] [VBRACE OPEN] <- VBrace open inserted before because '{' was not next
* '--' [IF - 2] [VBRACE OPEN]
* ';' [IF - 3] <- VBrace close inserted after semicolon
* 'else' [ELSE - 0] <- IF changed into ELSE
* 'x' [ELSE - 0] [VBRACE OPEN] <- lack of '{' -> VBrace
* '++' [ELSE - 0] [VBRACE OPEN]
* ';' [ELSE - 0] <- VBrace close inserted after semicolon
* <- ELSE removed after statement close
*
* The pse stack is kept on a frame stack.
* The frame stack is need for languages that support preprocessors (C, C++, C#)
* that can arbitrarily change code flow. It also isolates #define macros so
* that they are indented independently and do not affect the rest of the program.
*
* When an #if is hit, a copy of the current frame is push on the frame stack.
* When an #else/#elif is hit, a copy of the current stack is pushed under the
* #if frame and the original (pre-#if) frame is copied to the current frame.
* When #endif is hit, the top frame is popped.
* This has the following effects:
* - a simple #if / #endif does not affect program flow
* - #if / #else /#endif - continues from the #if clause
*
* When a #define is entered, the current frame is pushed and cleared.
* When a #define is exited, the frame is popped.
*/
static void parse_cleanup(parse_frame_t *frm, chunk_t *pc)
{
LOG_FUNC_ENTRY();
LOG_FMT(LTOK, "%s(%d): orig_line is %zu, type is %s, tos is %zu, TOS.type is %s, TOS.stage is %u\n",
__func__, __LINE__, pc->orig_line, get_token_name(pc->type),
frm->pse_tos, get_token_name(frm->pse[frm->pse_tos].type),
(unsigned int)frm->pse[frm->pse_tos].stage);
// Mark statement starts
if ( (frm->stmt_count == 0 || frm->expr_count == 0)
&& !chunk_is_semicolon(pc)
&& pc->type != CT_BRACE_CLOSE
&& pc->type != CT_VBRACE_CLOSE
&& !chunk_is_str(pc, ")", 1)
&& !chunk_is_str(pc, "]", 1))
{
chunk_flags_set(pc, PCF_EXPR_START | ((frm->stmt_count == 0) ? PCF_STMT_START : 0));
LOG_FMT(LSTMT, "%s(%d): orig_line is %zu, 1.marked '%s' as %s, start stmt_count is %d, expr_count is %d\n",
__func__, __LINE__, pc->orig_line, pc->text(), (pc->flags & PCF_STMT_START) ? "stmt" : "expr",
frm->stmt_count, frm->expr_count);
}
frm->stmt_count++;
frm->expr_count++;
if (frm->sparen_count > 0)
{
chunk_flags_set(pc, PCF_IN_SPAREN);
// Mark everything in the for statement
for (int tmp = frm->pse_tos - 1; tmp >= 0; tmp--)
{
if (frm->pse[tmp].type == CT_FOR)
{
chunk_flags_set(pc, PCF_IN_FOR);
break;
}
}
// Mark the parent on semicolons in for() statements
if ( pc->type == CT_SEMICOLON
&& frm->pse_tos > 1
&& (frm->pse[frm->pse_tos - 1].type == CT_FOR))
{
set_chunk_parent(pc, CT_FOR);
}
}
// Check the progression of complex statements
if (frm->pse[frm->pse_tos].stage != brace_stage_e::NONE)
{
if (check_complex_statements(frm, pc))
{
return;
}
}
/*
* Check for a virtual brace statement close due to a semicolon.
* The virtual brace will get handled the next time through.
* The semicolon isn't handled at all.
* TODO: may need to float VBRACE past comments until newline?
*/
if (frm->pse[frm->pse_tos].type == CT_VBRACE_OPEN)
{
if (chunk_is_semicolon(pc))
{
cpd.consumed = true;
close_statement(frm, pc);
}
else if (cpd.lang_flags & LANG_PAWN)
{
if (pc->type == CT_BRACE_CLOSE)
{
close_statement(frm, pc);
}
}
}
// Handle close parenthesis, vbrace, brace, and square
if ( pc->type == CT_PAREN_CLOSE
|| pc->type == CT_BRACE_CLOSE
|| pc->type == CT_VBRACE_CLOSE
|| pc->type == CT_ANGLE_CLOSE
|| pc->type == CT_MACRO_CLOSE
|| pc->type == CT_SQUARE_CLOSE)
{
// Change CT_PAREN_CLOSE into CT_SPAREN_CLOSE or CT_FPAREN_CLOSE
if ( pc->type == CT_PAREN_CLOSE
&& ( (frm->pse[frm->pse_tos].type == CT_FPAREN_OPEN)
|| (frm->pse[frm->pse_tos].type == CT_SPAREN_OPEN)))
{
set_chunk_type(pc, (c_token_t)(frm->pse[frm->pse_tos].type + 1));
if (pc->type == CT_SPAREN_CLOSE)
{
frm->sparen_count--;
chunk_flags_clr(pc, PCF_IN_SPAREN);
}
}
// Make sure the open / close match
if (pc->type != (frm->pse[frm->pse_tos].type + 1))
{
if ( (frm->pse[frm->pse_tos].type != CT_NONE)
&& (frm->pse[frm->pse_tos].type != CT_PP_DEFINE))
{
LOG_FMT(LWARN, "%s(%d): %s, orig_line is %zu, Error: Unexpected '%s' for '%s', which was on line %zu\n",
__func__, __LINE__, cpd.filename, pc->orig_line, pc->text(),
get_token_name(frm->pse[frm->pse_tos].pc->type),
frm->pse[frm->pse_tos].pc->orig_line);
print_stack(LBCSPOP, "=Error ", frm, pc);
cpd.error_count++;
}
}
else
{
cpd.consumed = true;
// Copy the parent, update the parenthesis/brace levels
set_chunk_parent(pc, frm->pse[frm->pse_tos].parent);
frm->level--;
if ( pc->type == CT_BRACE_CLOSE
|| pc->type == CT_VBRACE_CLOSE
|| pc->type == CT_MACRO_CLOSE)
{
frm->brace_level--;
}
pc->level = frm->level;
pc->brace_level = frm->brace_level;
// Pop the entry
frm->pse_tos--;
print_stack(LBCSPOP, "-Close ", frm, pc);
// See if we are in a complex statement
if (frm->pse[frm->pse_tos].stage != brace_stage_e::NONE)
{
handle_complex_close(frm, pc);
}
}
}
/*
* In this state, we expect a semicolon, but we'll also hit the closing
* sparen, so we need to check cpd.consumed to see if the close sparen was
* aleady handled.
*/
if (frm->pse[frm->pse_tos].stage == brace_stage_e::WOD_SEMI)
{
chunk_t *tmp = pc;
if (cpd.consumed)
{
/*
* If consumed, then we are on the close sparen.
* PAWN: Check the next chunk for a semicolon. If it isn't, then
* add a virtual semicolon, which will get handled on the next pass.
*/
if (cpd.lang_flags & LANG_PAWN)
{
tmp = chunk_get_next_ncnl(pc);
if (tmp->type != CT_SEMICOLON && tmp->type != CT_VSEMICOLON)
{
pawn_add_vsemi_after(pc);
}
}
}
else
{
// Complain if this ISN'T a semicolon, but close out WHILE_OF_DO anyway
if (pc->type == CT_SEMICOLON || pc->type == CT_VSEMICOLON)
{
cpd.consumed = true;
set_chunk_parent(pc, CT_WHILE_OF_DO);
}
else
{
LOG_FMT(LWARN, "%s: %s(%d): %zu: Error: Expected a semicolon for WHILE_OF_DO, but got '%s'\n",
cpd.filename, __func__, __LINE__, pc->orig_line, get_token_name(pc->type));
cpd.error_count++;
}
handle_complex_close(frm, pc);
}
}
// Get the parent type for brace and parenthesis open
c_token_t parent = pc->parent_type;
if ( pc->type == CT_PAREN_OPEN
|| pc->type == CT_FPAREN_OPEN
|| pc->type == CT_SPAREN_OPEN
|| pc->type == CT_BRACE_OPEN)
{
chunk_t *prev = chunk_get_prev_ncnl(pc);
if (prev != nullptr)
{
if ( pc->type == CT_PAREN_OPEN
|| pc->type == CT_FPAREN_OPEN
|| pc->type == CT_SPAREN_OPEN)
{
// Set the parent for parenthesis and change parenthesis type
if (frm->pse[frm->pse_tos].stage != brace_stage_e::NONE)
{
set_chunk_type(pc, CT_SPAREN_OPEN);
parent = frm->pse[frm->pse_tos].type;
frm->sparen_count++;
}
else if (prev->type == CT_FUNCTION)
{
set_chunk_type(pc, CT_FPAREN_OPEN);
parent = CT_FUNCTION;
}
// NS_ENUM and NS_OPTIONS are followed by a (type, name) pair
else if (prev->type == CT_ENUM && (cpd.lang_flags & LANG_OC))
{
// Treat both as CT_ENUM since the syntax is identical
set_chunk_type(pc, CT_FPAREN_OPEN);
parent = CT_ENUM;
}
else
{
// no need to set parent
}
}
else // must be CT_BRACE_OPEN
{
// Set the parent for open braces
if (frm->pse[frm->pse_tos].stage != brace_stage_e::NONE)
{
parent = frm->pse[frm->pse_tos].type;
}
else if (prev->type == CT_ASSIGN && (prev->str[0] == '='))
{
parent = CT_ASSIGN;
}
// Carry through CT_ENUM parent in NS_ENUM (type, name) {
else if ( prev->type == CT_FPAREN_CLOSE
&& (cpd.lang_flags & LANG_OC)
&& prev->parent_type == CT_ENUM)
{
parent = CT_ENUM;
}
else if (prev->type == CT_FPAREN_CLOSE)
{
parent = CT_FUNCTION;
}
else
{
// no need to set parent
}
}
}
}
/*
* Adjust the level for opens & create a stack entry
* Note that CT_VBRACE_OPEN has already been handled.
*/
if ( pc->type == CT_BRACE_OPEN
|| pc->type == CT_PAREN_OPEN
|| pc->type == CT_FPAREN_OPEN
|| pc->type == CT_SPAREN_OPEN
|| pc->type == CT_ANGLE_OPEN
|| pc->type == CT_MACRO_OPEN
|| pc->type == CT_SQUARE_OPEN)
{
frm->level++;
if (pc->type == CT_BRACE_OPEN || pc->type == CT_MACRO_OPEN)
{
frm->brace_level++;
}
push_fmr_pse(frm, pc, brace_stage_e::NONE, "+Open ");
frm->pse[frm->pse_tos].parent = parent;
set_chunk_parent(pc, parent);
}
pattern_class_e patcls = get_token_pattern_class(pc->type);
/*
* Create a stack entry for complex statements:
* if, elseif, switch, for, while, synchronized, using, lock, with,
* version, CT_D_SCOPE_IF
*/
if (patcls == pattern_class_e::BRACED)
{
push_fmr_pse(frm, pc,
(pc->type == CT_DO) ? brace_stage_e::BRACE_DO : brace_stage_e::BRACE2,
"+ComplexBraced");
}
else if (patcls == pattern_class_e::PBRACED)
{
brace_stage_e bs = brace_stage_e::PAREN1;
if (pc->type == CT_WHILE && maybe_while_of_do(pc))
{
set_chunk_type(pc, CT_WHILE_OF_DO);
bs = brace_stage_e::WOD_PAREN;
}
push_fmr_pse(frm, pc, bs, "+ComplexParenBraced");
}
else if (patcls == pattern_class_e::OPBRACED)
{
push_fmr_pse(frm, pc, brace_stage_e::OP_PAREN1, "+ComplexOpParenBraced");
}
else if (patcls == pattern_class_e::ELSE)
{
push_fmr_pse(frm, pc, brace_stage_e::ELSEIF, "+ComplexElse");
}
/*
* Mark simple statement/expression starts
* - after { or }
* - after ';', but not if the paren stack top is a paren
* - after '(' that has a parent type of CT_FOR
*/
if ( pc->type == CT_SQUARE_OPEN
|| (pc->type == CT_BRACE_OPEN && pc->parent_type != CT_ASSIGN)
|| pc->type == CT_BRACE_CLOSE
|| pc->type == CT_VBRACE_CLOSE
|| (pc->type == CT_SPAREN_OPEN && pc->parent_type == CT_FOR)
|| pc->type == CT_COLON
|| pc->type == CT_OC_END
|| ( chunk_is_semicolon(pc)
&& frm->pse[frm->pse_tos].type != CT_PAREN_OPEN
&& frm->pse[frm->pse_tos].type != CT_FPAREN_OPEN
&& frm->pse[frm->pse_tos].type != CT_SPAREN_OPEN))
{
LOG_FMT(LSTMT, "%s(%d): orig_line is %zu, reset1 stmt on '%s'\n",
__func__, __LINE__, pc->orig_line, pc->text());
frm->stmt_count = 0;
frm->expr_count = 0;
}
// Mark expression starts
chunk_t *tmp = chunk_get_next_ncnl(pc);
if ( pc->type == CT_ARITH
|| pc->type == CT_ASSIGN
|| pc->type == CT_CASE
|| pc->type == CT_COMPARE
|| ( pc->type == CT_STAR
&& tmp != nullptr && tmp->type != CT_STAR)
|| pc->type == CT_BOOL
|| pc->type == CT_MINUS
|| pc->type == CT_PLUS
|| pc->type == CT_CARET
|| pc->type == CT_ANGLE_OPEN
|| pc->type == CT_ANGLE_CLOSE
|| pc->type == CT_RETURN
|| pc->type == CT_THROW
|| pc->type == CT_GOTO
|| pc->type == CT_CONTINUE
|| pc->type == CT_PAREN_OPEN
|| pc->type == CT_FPAREN_OPEN
|| pc->type == CT_SPAREN_OPEN
|| pc->type == CT_BRACE_OPEN
|| chunk_is_semicolon(pc)
|| pc->type == CT_COMMA
|| pc->type == CT_NOT
|| pc->type == CT_INV
|| pc->type == CT_COLON
|| pc->type == CT_QUESTION)
{
frm->expr_count = 0;
LOG_FMT(LSTMT, "%s(%d): orig_line is %zu, reset expr on '%s'\n",
__func__, __LINE__, pc->orig_line, pc->text());
}
else if (pc->type == CT_BRACE_CLOSE)
{
if (!cpd.consumed)
{
size_t file_pp_level = ifdef_over_whole_file() ? 1 : 0;
if (!cpd.unc_off_used && pc->pp_level == file_pp_level)
{
// fatal error
char *outputMessage;
if (cpd.settings[UO_tok_split_gte].b)
{
outputMessage = make_message("Unmatched BRACE_CLOSE\nat orig_line=%zu, orig_col=%zu\n",
pc->orig_line, pc->orig_col);
}
else
{
outputMessage = make_message("Unmatched BRACE_CLOSE\nat orig_line=%zu, orig_col=%zu\nTry the option 'tok_split_gte = true'\n",
pc->orig_line, pc->orig_col);
}
fprintf(stderr, "%s", outputMessage);
free(outputMessage);
log_flush(true);
exit(EXIT_FAILURE);
}
}
}
} // parse_cleanup
