struct hl_line_attr *hl_regex_highlight(struct hl_regex_info **info,
char *line, enum hl_group_kind group_kind)
{
hl_line_attr *attrs = NULL;
if (*info && (*info)->regex && (*info)->regex[0]) {
int pos = 0;
for (;;) {
int ret;
int len;
int start, end;
ret = hl_regex_search(info, line + pos, (*info)->regex, (*info)->icase, &start, &end);
if (ret <= 0)
break;
len = end - start;
pos += start;
/* Push search attribute */
sbpush(attrs, hl_line_attr(pos, group_kind));
/* And the back to regular text attribute */
sbpush(attrs, hl_line_attr(pos + len, 0));
pos += len;
}
}
return attrs;
}
static void scroller_addline(struct scroller *scr, char *line,
struct hl_line_attr *attrs, enum ScrInputKind kind)
{
struct scroller_line sl;
/* Add attribute from last inferior line to start of this one */
if (kind == SCR_INPUT_INFERIOR && (scr->last_inferior_attr != -1)) {
/* If there isn't already a color attribute for the first column */
if (!attrs || (attrs[0].col() != 0)) {
int count = sbcount(attrs);
/* Bump the count up and scoot the attributes over one */
sbsetcount(attrs, count + 1);
memmove(attrs+1, attrs, count * sizeof(struct hl_line_attr));
attrs[0] = hl_line_attr(0, scr->last_inferior_attr);
}
scr->last_inferior_attr = -1;
}
sl.line = line;
sl.line_len = strlen(line);
sl.kind = kind;
sl.attrs = attrs;
sbpush(scr->lines, sl);
scr->lines_to_display++;
scroller_set_last_inferior_attr(scr);
}
/**
* Display the source.
*
* A line in the source viewer looks like,
* # │ marker text
* where,
* # is the line number to display or ~ if no line number
* │ is the divider between the line number or it is a mark
* marker is shortarrow, longarrow, highlight, block, etc
* text is the source code to display
*
* The syntax highlighting works as follows,
*
* The #
* - If breakpoint is set, use Breakpoint
* - If breakpoint is disabled, use DisabledBreakpoint
* - If selected line, use SelectedLineNr
* - If executing line, use ExecutingLineNr
* - Otherwise, no highlighting group
*
* The │
* - When source window is in focus, the character is bolded, otherwise normal
* - If the user has a mark set, the mark will be displayed instead of any
* other character.
* - Edge case: When the marker is long or short arrow, CGDB prints ├
* instead of │ the ├ is colored based on highlighting group for
* the selected or executing arrow.
*
* The marker
* - The marker is the shortarrow, longarrow, highlight or block
* - The color is based off the corresponding highlighting group
*
* The text
* - The syntax highlighting source code to display
* - Will be colored with SelectedLineHighlight or ExecutingLineHighlight
* if the line is the selected or executing line and the display is set
* to highlight.
*/
int source_display(struct sviewer *sview, int focus, enum win_refresh dorefresh)
{
int i;
int lwidth;
int line;
int count;
enum LineDisplayStyle exe_display_style, sel_display_style;
int sellineno, exelineno;
int enabled_bp, disabled_bp;
int exe_line_display_is_arrow, sel_line_display_is_arrow;
int exe_arrow_attr, sel_arrow_attr;
int exe_block_attr, sel_block_attr;
char fmt[16];
int width, height;
int focus_attr = focus ? SWIN_A_BOLD : 0;
int showmarks = cgdbrc_get_int(CGDBRC_SHOWMARKS);
int hlsearch = cgdbrc_get_int(CGDBRC_HLSEARCH);
int mark_attr;
struct hl_line_attr *sel_highlight_attrs = 0;
struct hl_line_attr *exe_highlight_attrs = 0;
/* Check that a file is loaded */
if (!sview->cur || !sview->cur->file_buf.lines) {
logo_display(sview->win);
if (dorefresh == WIN_REFRESH)
swin_wrefresh(sview->win);
else
swin_wnoutrefresh(sview->win);
return 0;
}
sellineno = hl_groups_get_attr(
hl_groups_instance, HLG_SELECTED_LINE_NUMBER);
exelineno = hl_groups_get_attr(
hl_groups_instance, HLG_EXECUTING_LINE_NUMBER);
enabled_bp = hl_groups_get_attr(
hl_groups_instance, HLG_ENABLED_BREAKPOINT);
disabled_bp = hl_groups_get_attr(
hl_groups_instance, HLG_DISABLED_BREAKPOINT);
exe_display_style = cgdbrc_get_displaystyle(CGDBRC_EXECUTING_LINE_DISPLAY);
exe_arrow_attr = hl_groups_get_attr(
hl_groups_instance, HLG_EXECUTING_LINE_ARROW);
exe_block_attr = hl_groups_get_attr(
hl_groups_instance, HLG_EXECUTING_LINE_BLOCK);
sel_display_style = cgdbrc_get_displaystyle(CGDBRC_SELECTED_LINE_DISPLAY);
sel_arrow_attr = hl_groups_get_attr(
hl_groups_instance, HLG_SELECTED_LINE_ARROW);
sel_block_attr = hl_groups_get_attr(
hl_groups_instance, HLG_SELECTED_LINE_BLOCK);
exe_line_display_is_arrow =
exe_display_style == LINE_DISPLAY_SHORT_ARROW ||
exe_display_style == LINE_DISPLAY_LONG_ARROW;
sel_line_display_is_arrow =
sel_display_style == LINE_DISPLAY_SHORT_ARROW ||
sel_display_style == LINE_DISPLAY_LONG_ARROW;
mark_attr = hl_groups_get_attr(hl_groups_instance, HLG_MARK);
sbpush(sel_highlight_attrs, hl_line_attr(0, HLG_SELECTED_LINE_HIGHLIGHT));
sbpush(exe_highlight_attrs, hl_line_attr(0, HLG_EXECUTING_LINE_HIGHLIGHT));
/* Make sure cursor is visible */
swin_curs_set(!!focus);
/* Initialize variables */
height = swin_getmaxy(sview->win);
width = swin_getmaxx(sview->win);
/* Set starting line number (center source file if it's small enough) */
count = sbcount(sview->cur->file_buf.lines);
if (count < height) {
line = (count - height) / 2;
} else {
line = sview->cur->sel_line - height / 2;
if (line > count - height)
line = count - height;
else if (line < 0)
line = 0;
}
/* Print 'height' lines of the file, starting at 'line' */
lwidth = log10_uint(count) + 1;
snprintf(fmt, sizeof(fmt), "%%%dd", lwidth);
for (i = 0; i < height; i++, line++) {
int column_offset = 0;
/* Is this the current selected line? */
int is_sel_line = (line >= 0 && sview->cur->sel_line == line);
/* Is this the current executing line */
int is_exe_line = (line >= 0 && sview->cur->exe_line == line);
struct source_line *sline = (line < 0 || line >= count)?
NULL:&sview->cur->file_buf.lines[line];
struct hl_line_attr *printline_attrs = (sline)?sline->attrs:0;
swin_wmove(sview->win, i, 0);
/* Print the line number */
if (line < 0 || line >= count) {
for (int j = 1; j < lwidth; j++)
swin_waddch(sview->win, ' ');
swin_waddch(sview->win, '~');
} else {
int line_attr = 0;
int bp_val = sview->cur->lflags[line].breakpt;
if (bp_val == 1) {
line_attr = enabled_bp;
} else if (bp_val == 2) {
line_attr = disabled_bp;
} else if (bp_val == 0 && is_exe_line) {
line_attr = exelineno;
} else if (bp_val == 0 && is_sel_line) {
line_attr = sellineno;
}
swin_wattron(sview->win, line_attr);
swin_wprintw(sview->win, fmt, line + 1);
swin_wattroff(sview->win, line_attr);
}
if (!swin_has_colors()) {
/* TODO:
swin_wprintw(sview->win, "%.*s\n",
sview->cur->file_buf.lines[line].line,
sview->cur->file_buf.lines[line].len);
*/
continue;
}
/* Print the vertical bar or mark */
{
SWIN_CHTYPE vert_bar_char;
int vert_bar_attr;
int mc;
if (showmarks &&
((mc = source_get_mark_char(sview, sview->cur, line)) > 0)) {
vert_bar_char = mc;
vert_bar_attr = mark_attr;
} else if (is_exe_line && exe_line_display_is_arrow) {
vert_bar_attr = exe_arrow_attr;
vert_bar_char = SWIN_SYM_LTEE;
} else if (is_sel_line && sel_line_display_is_arrow) {
vert_bar_attr = sel_arrow_attr;
vert_bar_char = SWIN_SYM_LTEE;
} else {
vert_bar_attr = focus_attr;
vert_bar_char = SWIN_SYM_VLINE;
}
swin_wattron(sview->win, vert_bar_attr);
swin_waddch(sview->win, vert_bar_char);
swin_wattroff(sview->win, vert_bar_attr);
}
/* Print the marker */
if (is_exe_line || is_sel_line) {
enum LineDisplayStyle display_style;
int arrow_attr, block_attr;
struct hl_line_attr *highlight_attr;
if (is_exe_line) {
display_style = exe_display_style;
arrow_attr = exe_arrow_attr;
block_attr = exe_block_attr;
highlight_attr = exe_highlight_attrs;
} else {
display_style = sel_display_style;
arrow_attr = sel_arrow_attr;
block_attr = sel_block_attr;
highlight_attr = sel_highlight_attrs;
}
switch (display_style) {
case LINE_DISPLAY_SHORT_ARROW:
swin_wattron(sview->win, arrow_attr);
swin_waddch(sview->win, '>');
swin_wattroff(sview->win, arrow_attr);
break;
case LINE_DISPLAY_LONG_ARROW:
swin_wattron(sview->win, arrow_attr);
column_offset = get_line_leading_ws_count(
sline->line, sline->len);
column_offset -= (sview->cur->sel_col + 1);
if (column_offset < 0)
column_offset = 0;
/* Now actually draw the arrow */
for (int j = 0; j < column_offset; j++)
swin_waddch(sview->win, SWIN_SYM_HLINE);
swin_waddch(sview->win, '>');
swin_wattroff(sview->win, arrow_attr);
break;
case LINE_DISPLAY_HIGHLIGHT:
swin_waddch(sview->win, ' ');
printline_attrs = highlight_attr;
break;
case LINE_DISPLAY_BLOCK:
column_offset = get_line_leading_ws_count(
sline->line, sline->len);
column_offset -= (sview->cur->sel_col + 1);
if (column_offset < 0)
column_offset = 0;
/* Now actually draw the space to the block */
for (int j = 0; j < column_offset; j++)
swin_waddch(sview->win, ' ');
/* Draw the block */
swin_wattron(sview->win, block_attr);
swin_waddch(sview->win, ' ');
swin_wattroff(sview->win, block_attr);
break;
}
} else {
swin_waddch(sview->win, ' ');
}
/* Print the text */
if (line < 0 || line >= count) {
for (int j = 2 + lwidth; j < width; j++)
swin_waddch(sview->win, ' ');
} else {
int x, y;
y = swin_getcury(sview->win);
x = swin_getcurx(sview->win);
hl_printline(sview->win, sline->line, sline->len,
printline_attrs, -1, -1, sview->cur->sel_col + column_offset,
width - lwidth - 2);
if (hlsearch && sview->last_hlregex) {
struct hl_line_attr *attrs = hl_regex_highlight(
&sview->last_hlregex, sline->line, HLG_SEARCH);
if (sbcount(attrs)) {
hl_printline_highlight(sview->win, sline->line, sline->len,
attrs, x, y, sview->cur->sel_col + column_offset,
width - lwidth - 2);
sbfree(attrs);
}
}
if (is_sel_line && sview->hlregex) {
struct hl_line_attr *attrs = hl_regex_highlight(
&sview->hlregex, sline->line, HLG_INCSEARCH);
if (sbcount(attrs)) {
hl_printline_highlight(sview->win, sline->line, sline->len,
attrs, x, y, sview->cur->sel_col + column_offset,
width - lwidth - 2);
sbfree(attrs);
}
}
}
}
switch(dorefresh) {
case WIN_NO_REFRESH:
swin_wnoutrefresh(sview->win);
break;
case WIN_REFRESH:
swin_wrefresh(sview->win);
break;
}
sbfree(sel_highlight_attrs);
sbfree(exe_highlight_attrs);
return 0;
}
static int highlight_node(struct list_node *node)
{
int i;
int ret;
int line = 0;
int length = 0;
int lasttype = -1;
struct token_data tok_data;
struct tokenizer *t = tokenizer_init();
struct buffer *buf = &node->file_buf;
for (i = 0; i < sbcount(buf->lines); i++) {
sbfree(buf->lines[i].attrs);
buf->lines[i].attrs = NULL;
}
if (!buf->file_data) {
for (line = 0; line < sbcount(buf->lines); line++) {
struct source_line *sline = &buf->lines[line];
tokenizer_set_buffer(t, sline->line, buf->language);
length = 0;
lasttype = -1;
while ((ret = tokenizer_get_token(t, &tok_data)) > 0) {
if (tok_data.e == TOKENIZER_NEWLINE)
break;
enum hl_group_kind hlg = hlg_from_tokenizer_type(tok_data.e, tok_data.data);
/* Add attribute if highlight group has changed */
if (lasttype != hlg) {
sbpush(buf->lines[line].attrs, hl_line_attr(length, hlg));
lasttype = hlg;
}
/* Add the text and bump our length */
length += strlen(tok_data.data);
}
}
} else {
if (tokenizer_set_buffer(t, buf->file_data, buf->language) == -1) {
if_print_message("%s:%d tokenizer_set_buffer error", __FILE__, __LINE__);
return -1;
}
while ((ret = tokenizer_get_token(t, &tok_data)) > 0) {
if (tok_data.e == TOKENIZER_NEWLINE) {
if (length > buf->max_width)
buf->max_width = length;
length = 0;
lasttype = -1;
line++;
} else {
enum hl_group_kind hlg = hlg_from_tokenizer_type(tok_data.e, tok_data.data);
if (hlg == HLG_LAST) {
clog_error(CLOG_CGDB, "Bad hlg_type for '%s', e==%d\n", tok_data.data, tok_data.e);
hlg = HLG_TEXT;
}
/* Add attribute if highlight group has changed */
if (lasttype != hlg) {
sbpush(buf->lines[line].attrs, hl_line_attr(length, hlg));
lasttype = hlg;
}
/* Add the text and bump our length */
length += strlen(tok_data.data);
}
}
}
tokenizer_destroy(t);
return 0;
}
/* parse: Translates special characters in a string. (i.e. backspace, tab...)
* ------
*
* buf: The string to parse
*
* Return Value: A newly allocated copy of buf, with modifications made.
*/
static char *parse(struct scroller *scr, struct hl_line_attr **attrs,
const char *orig, const char *buf, int buflen, enum ScrInputKind kind)
{
// Read in tabstop settings, but don't change them on the fly as we'd have to
// store each previous line and recalculate every one of them.
static const int tab_size = cgdbrc_get_int(CGDBRC_TABSTOP);
int tabcount = count(buf, buflen, '\t');
int orig_len = strlen(orig);
int length = MAX(orig_len, scr->current.pos) + buflen +
(tab_size - 1) * tabcount + 1;
char *rv = (char *) cgdb_calloc(length, 1);
int i, j;
int debugwincolor = cgdbrc_get_int(CGDBRC_DEBUGWINCOLOR);
int width, height;
height = swin_getmaxy(scr->win);
width = swin_getmaxx(scr->win);
/* Copy over original buffer */
strcpy(rv, orig);
i = scr->current.pos;
/* Expand special characters */
for (j = 0; j < buflen; j++) {
switch (buf[j]) {
/* Backspace/Delete -> Erase last character */
case 8:
case 127:
if (i > 0)
i--;
break;
/* Tab -> Translating to spaces */
case '\t':
do {
rv[i++] = ' ';
} while (i % tab_size != 0);
break;
/* Carriage return -> Move back to the beginning of the line */
case '\r':
i = 0;
if (buf[j + 1] != '\n') {
sbfree(*attrs);
*attrs = NULL;
}
break;
case '\033':
/* Handle ansi escape characters */
if (hl_ansi_color_support(hl_groups_instance) &&
debugwincolor) {
int attr;
int ansi_count = hl_ansi_get_color_attrs(
hl_groups_instance, buf + j, &attr);
if (ansi_count) {
j += ansi_count - 1;
sbpush(*attrs, hl_line_attr(i, attr));
}
} else {
rv[i++] = buf[j];
}
break;
default:
rv[i++] = buf[j];
break;
}
}
scr->current.pos = i;
/**
* The prompt should never be longer than the width of the terminal.
*
* The below should only be done for the readline prompt interaction,
* not for text coming from gdb/inferior. Otherwise you'll truncate
* their text in the scroller!
*
* When readline is working with the prompt (at least in "dumb" mode)
* it assumes that the terminal will only display as many characters as
* the terminal is wide. If the terminal is reduced in size (resized to a
* smaller width) readline will only clear the number of characters
* that will fit into the new terminal width. Our prompt may still
* have a lot more characters than that (the characters that existed
* in the prompt before the resize). This truncation of the prompt
* is solving that problem.
*/
size_t rvlength = strlen(rv);
if (kind == SCR_INPUT_READLINE && rvlength >= width) {
rv[width - 1] = 0;
}
return rv;
}
static void scr_add_buf(struct scroller *scr, const char *buf,
enum ScrInputKind kind)
{
char *x;
int distance;
/* Find next newline in the string */
x = strchr((char *)buf, '\n');
distance = x ? x - buf : strlen(buf);
/* Append to the last line in the buffer */
if (distance > 0) {
int is_crlf = (distance == 1) && (buf[0] == '\r');
if (!is_crlf) {
int index = sbcount(scr->lines) - 1;
char *orig = scr->lines[index].line;
int orig_len = scr->lines[index].line_len;
if ((scr->last_inferior_attr != -1) &&
(kind != scr->lines[index].kind)) {
/* Default to 0: Add that color attribute in */
int attr = 0;
if (kind == SCR_INPUT_INFERIOR) {
attr = scr->last_inferior_attr;
scr->last_inferior_attr = -1;
}
sbpush(scr->lines[index].attrs, hl_line_attr(orig_len, attr));
}
scr->lines[index].kind = kind;
scr->lines[index].line = parse(
scr, &scr->lines[index].attrs, orig, buf, distance, kind);
scr->lines[index].line_len = strlen(scr->lines[index].line);
scroller_set_last_inferior_attr(scr);
free(orig);
}
}
/* Create additional lines if buf contains newlines */
while (x != NULL) {
char *line;
struct hl_line_attr *attrs = NULL;
buf = x + 1;
x = strchr((char *)buf, '\n');
distance = x ? x - buf : strlen(buf);
/* inferior input with no lf. */
if (!x && (kind == SCR_INPUT_INFERIOR) && distance && (distance < 4096)) {
/* Store away and parse when the rest of the line shows up */
scr->last_inferior_line = strdup(buf);
/* Add line since we did have a lf */
scr->current.pos = 0;
scroller_addline(scr, strdup(""), NULL, kind);
break;
}
/* Expand the buffer */
scr->current.pos = 0;
/* Add the new line */
line = parse(scr, &attrs, "", buf, distance, kind);
scroller_addline(scr, line, attrs, kind);
}
/* Don't want to exit scroll mode simply because new data received */
if (!scr->in_scroll_mode) {
scr_end(scr);
}
}