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