static int test_delchar(ibuf s)
{
/* Delete the last '!' from the string. */
ibuf_delchar(s);
/* Make sure it was deleted correctly. */
if (strcmp(ibuf_get(s), "hello world") != 0) {
debug("test_delchar: Mismatch, expected \"hello world\", got: %s\n",
ibuf_get(s));
return 1;
}
/* Wipe the string via delchar, testing ibuf_length simultaneously */
while (ibuf_length(s) > 0) {
ibuf_delchar(s);
}
/* Make sure s is now an empty string. */
if (strcmp(ibuf_get(s), "") != 0) {
debug("test_delchar: Expected empty string, got: %s\n", ibuf_get(s));
return 2;
}
debug("test_delchar: Succeeded.\n");
return 0;
}
/**
* Capture a regular expression from the user, one key at a time.
* This modifies the global variables regex_cur and regex_last.
*
* \param sview
* The source viewer.
*
* \return
* 0 if user gave a regex, otherwise 1.
*/
static int status_bar_regex_input(struct sviewer *sview, int key)
{
int regex_icase = cgdbrc_get(CGDBRC_IGNORECASE)->variant.int_val;
/* Flag to indicate we're done with regex mode, need to switch back */
int done = 0;
/* Recieve a regex from the user. */
switch (key) {
case '\r':
case '\n':
case CGDB_KEY_CTRL_M:
/* Save for future searches via 'n' or 'N' */
if (regex_last != NULL) {
ibuf_free(regex_last);
}
regex_last = ibuf_dup(regex_cur);
regex_direction_last = regex_direction_cur;
source_search_regex(sview, ibuf_get(regex_last), 2,
regex_direction_last, regex_icase);
if_draw();
done = 1;
break;
case 8:
case 127:
/* Backspace or DEL key */
if (ibuf_length(regex_cur) == 0) {
done = 1;
} else {
ibuf_delchar(regex_cur);
source_search_regex(sview, ibuf_get(regex_cur), 1,
regex_direction_cur, regex_icase);
if_draw();
update_status_win();
}
break;
default:
if (kui_term_is_cgdb_key(key)) {
const char *keycode = kui_term_get_keycode_from_cgdb_key(key);
int length = strlen(keycode), i;
for (i = 0; i < length; i++)
ibuf_addchar(regex_cur, keycode[i]);
} else {
ibuf_addchar(regex_cur, key);
}
source_search_regex(sview, ibuf_get(regex_cur), 1,
regex_direction_cur, regex_icase);
if_draw();
update_status_win();
};
if (done) {
ibuf_free(regex_cur);
regex_cur = NULL;
if_set_focus(CGDB);
}
return 0;
}
/* Updates the status bar */
static void update_status_win(enum win_refresh dorefresh)
{
int pos;
int attr;
attr = hl_groups_get_attr(hl_groups_instance, HLG_STATUS_BAR);
/* Print white background */
swin_wattron(status_win, attr);
for (pos = 0; pos < WIDTH; pos++)
swin_mvwprintw(status_win, 0, pos, " ");
/* Show the user which window is focused */
if (focus == GDB)
swin_mvwprintw(status_win, 0, WIDTH - 1, "*");
else if (focus == CGDB || focus == CGDB_STATUS_BAR)
swin_mvwprintw(status_win, 0, WIDTH - 1, " ");
swin_wattroff(status_win, attr);
/* Print the regex that the user is looking for Forward */
if (sbc_kind == SBC_REGEX && regex_direction_cur) {
if_display_message("/", dorefresh, WIDTH - 1, "%s", ibuf_get(regex_cur));
swin_curs_set(1);
}
/* Regex backwards */
else if (sbc_kind == SBC_REGEX) {
if_display_message("?", dorefresh, WIDTH - 1, "%s", ibuf_get(regex_cur));
swin_curs_set(1);
}
/* A colon command typed at the status bar */
else if (focus == CGDB_STATUS_BAR && sbc_kind == SBC_NORMAL) {
const char *command = ibuf_get(cur_sbc);
if (!command)
command = "";
if_display_message(":", dorefresh, WIDTH - 1, "%s", command);
swin_curs_set(1);
}
/* Default: Current Filename */
else {
/* Print filename */
const char *filename = source_current_file(src_viewer);
if (filename) {
if_display_message("", dorefresh, WIDTH - 1, "%s", filename);
}
}
if (dorefresh == WIN_REFRESH)
swin_wrefresh(status_win);
else
swin_wnoutrefresh(status_win);
}
static int test_addchar(ibuf s) {
/* Add an exclamation to the hello world string. */
ibuf_addchar(s, '!');
/* Make sure it was added correctly. */
if (strcmp(ibuf_get(s), "hello world!") != 0) {
debug("test_addchar: Mismatch, expected \"hello world!\", got: %s\n",
ibuf_get(s));
return 1;
}
debug("test_addchar: Succeeded.\n");
return 0;
}
int Ctgdb::Process_console_command(tgdb_request_ptr request)
{
struct ibuf *command;
if (!request)
return -1;
if (!Can_issue_command())
return -1;
if (request->header != TGDB_REQUEST_CONSOLE_COMMAND)
return -1;
command = ibuf_init ();
ibuf_add (command, request->choice.console_command.command);
ibuf_addchar (command, '\n');
if (Send(ibuf_get (command), TGDB_COMMAND_CONSOLE) == -1)
{
Logger_write_pos( __FILE__, __LINE__, "tgdb_send failed");
return -1;
}
ibuf_free (command);
command = NULL;
return 0;
}
static int test_add(ibuf s) {
/* Add the strings "hello" and " world" to the ibuf */
ibuf_add(s, "hello");
ibuf_add(s, " world");
/* Make sure that's what got added */
if (strcmp(ibuf_get(s), "hello world") != 0) {
debug("test_add: Mismatch, expected \"hello world\", got: %s\n",
ibuf_get(s));
return 1;
}
debug("test_add: Succeeded.\n");
return 0;
}
struct ibuf *ibuf_dup(struct ibuf *s)
{
struct ibuf *ns = ibuf_init();
ibuf_add(ns, ibuf_get(s));
return ns;
}
int highlight_node(const char *filename, struct buffer *buf)
{
int ret;
int length = 0;
int lasttype = -1;
struct ibuf *ibuf = ibuf_init();
struct tokenizer *t = tokenizer_init();
if (tokenizer_set_file(t, filename, buf->language) == -1) {
if_print_message("%s:%d tokenizer_set_file error", __FILE__, __LINE__);
return -1;
}
while ((ret = tokenizer_get_token(t)) > 0) {
enum tokenizer_type e = tokenizer_get_packet_type(t);
/*if_print_message ( "TOKEN(%d:%s)\n", e, tokenizer_get_printable_enum ( e ) ); */
if (e == TOKENIZER_NEWLINE) {
sbpush(buf->tlines, strdup(ibuf_get(ibuf)));
if (length > buf->max_width)
buf->max_width = length;
length = 0;
lasttype = -1;
ibuf_clear(ibuf);
} else {
const char *tok_data = tokenizer_get_data(t);
enum hl_group_kind hlg = hlg_from_tokenizer_type(e, tok_data);
if (hlg == HLG_LAST) {
logger_write_pos(logger, __FILE__, __LINE__, "Bad hlg_type for '%s', e==%d\n", tok_data, e);
hlg = HLG_TEXT;
}
/* Set the highlight group type */
add_type(ibuf, &lasttype, hlg);
/* Add the text and bump our length */
length += ibuf_add(ibuf, tok_data);
}
}
ibuf_free(ibuf);
tokenizer_destroy(t);
return 0;
}
static void if_run_command(struct sviewer *sview, struct ibuf *ibuf_command)
{
char *command = ibuf_get(ibuf_command);
/* refresh and return if the user entered no data */
if (ibuf_length(ibuf_command) == 0) {
if_draw();
return;
}
if (command_parse_string(command)) {
if_display_message("Unknown command: ", 0, "%s", command);
} else {
update_status_win();
}
if_draw();
}
static int test_trim(ibuf s) {
/* Test #1: Empty string. */
ibuf_clear(s);
ibuf_trim(s);
if (strcmp(ibuf_get(s), "") != 0) {
debug("test_trim: 1: expected empty string, got: %s\n", ibuf_get(s));
return 1;
}
/* Test #2: Single space. */
ibuf_clear(s);
ibuf_addchar(s, ' ');
ibuf_trim(s);
if (strcmp(ibuf_get(s), "") != 0) {
debug("test_trim: 2: expected empty string, got: %s\n", ibuf_get(s));
return 2;
}
/* Test #3: "hello world" (no leading or trailing spaces) */
ibuf_clear(s);
ibuf_add(s, "hello world");
ibuf_trim(s);
if (strcmp(ibuf_get(s), "hello world") != 0) {
debug("test_trim: 3: expected \"hello world\", got: %s\n",
ibuf_get(s));
return 3;
}
/* Test #4: " hello world \t" (leading and trailing spaces) */
ibuf_clear(s);
ibuf_add(s, " hello world \t");
ibuf_trim(s);
if (strcmp(ibuf_get(s), "hello world") != 0) {
debug("test_trim: 4: expected \"hello world\", got: %s\n",
ibuf_get(s));
return 3;
}
debug("test_trim: Succeeded.\n");
return 0;
}
int Ctgdb::Send(char *command, enum tgdb_command_choice command_choice, ITarget* target)
{
struct tgdb_command *tc;
struct ibuf *temp_command = ibuf_init ();
int length = strlen (command);
/* Add a newline to the end of the command if it doesn't exist */
ibuf_add (temp_command, command);
if (command[length - 1] != '\n')
ibuf_addchar (temp_command, '\n');
/* Create the client command */
tc = tgdb_command_create (ibuf_get (temp_command), command_choice, NULL);
tc->ITarget = (void*) target;
ibuf_free (temp_command);
temp_command = NULL;
if (Run_or_queue_command(tc) == -1)
{
Logger_write_pos( __FILE__, __LINE__,
"tgdb_run_or_queue_command failed");
return -1;
}
if (tgdb_client_tgdb_ran_command(tcc) == -1)
{
Logger_write_pos( __FILE__, __LINE__,
"tgdb_client_tgdb_ran_command failed");
return -1;
}
Process_client_commands();
return 0;
}
static int test_dup(ibuf s)
{
ibuf t;
/* Test duplicating a string. */
ibuf_add(s, "test string 1");
t = ibuf_dup(s);
if (t == NULL) {
debug("test_dup: ibuf_dup (attempt #1) returned NULL\n");
return 1;
}
if (strcmp(ibuf_get(s), ibuf_get(t)) != 0) {
debug("test_dup: Strings mismatched: \"%s\" != \"%s\"\n",
ibuf_get(s), ibuf_get(t));
return 1;
}
ibuf_free(t);
/* Corner case: duplicate an empty string */
ibuf_clear(s);
t = ibuf_dup(s);
if (t == NULL) {
debug("test_dup: ibuf_dup (attempt #2) returned NULL\n");
return 1;
}
if (strcmp(ibuf_get(t), "") != 0) {
debug("test_dup: Expected empty string, got: %s\n", ibuf_get(t));
return 1;
}
ibuf_free(t);
debug("test_dup: Succeeded.\n");
return 0;
}
int a2_handle_data(
struct annotate_two *a2, struct state_machine *sm,
const char *data, const size_t size,
char *gui_data, size_t *gui_size,
struct tgdb_list *command_list){
int i, counter = 0;
/* track state to find next file and line number */
for(i = 0; i < size; ++i){
switch(data[i]){
/* Ignore all car returns outputted by gdb */
case '\r':
break;
case '\n':
switch(sm->tgdb_state){
case DATA:
sm->tgdb_state = NEW_LINE;
break;
case NEW_LINE:
sm->tgdb_state = NEW_LINE;
data_process(a2, '\n', gui_data, &counter, command_list);
break;
case CONTROL_Z:
sm->tgdb_state = DATA;
data_process(a2, '\n', gui_data, &counter, command_list);
data_process(a2, '\032', gui_data, &counter, command_list);
break;
case ANNOTATION: /* Found an annotation */
sm->tgdb_state = NL_DATA;
tgdb_parse_annotation(a2, ibuf_get ( sm->tgdb_buffer ), ibuf_length ( sm->tgdb_buffer ), command_list);
ibuf_clear ( sm->tgdb_buffer );
break;
case NL_DATA:
sm->tgdb_state = NEW_LINE;
break;
default:
logger_write_pos ( logger, __FILE__, __LINE__, "Bad state transition");
break;
} /* end switch */
break;
case '\032':
switch(sm->tgdb_state){
case DATA:
sm->tgdb_state = DATA;
data_process(a2, '\032', gui_data, &counter, command_list);
break;
case NEW_LINE:
sm->tgdb_state = CONTROL_Z;
break;
case NL_DATA:
sm->tgdb_state = CONTROL_Z;
break;
case CONTROL_Z:
sm->tgdb_state = ANNOTATION;
break;
case ANNOTATION:
ibuf_addchar ( sm->tgdb_buffer, data[i] );
break;
default:
logger_write_pos ( logger, __FILE__, __LINE__, "Bad state transition");
break;
} /* end switch */
break;
default:
switch(sm->tgdb_state){
case DATA:
data_process(a2, data[i], gui_data, &counter, command_list);
break;
case NL_DATA:
sm->tgdb_state = DATA;
data_process(a2, data[i], gui_data, &counter, command_list);
break;
case NEW_LINE:
sm->tgdb_state = DATA;
data_process(a2, '\n', gui_data, &counter, command_list);
data_process(a2, data[i], gui_data, &counter, command_list);
break;
case CONTROL_Z:
sm->tgdb_state = DATA;
data_process(a2, '\n', gui_data, &counter, command_list);
data_process(a2, '\032', gui_data, &counter, command_list);
data_process(a2, data[i], gui_data, &counter, command_list);
break;
case ANNOTATION:
ibuf_addchar ( sm->tgdb_buffer, data[i] );
break;
default:
logger_write_pos ( logger, __FILE__, __LINE__, "Bad state transition");
break;
} /* end switch */
break;
} /* end switch */
} /* end for */
gui_data[counter] = '\0';
*gui_size = counter;
return 0;
}
/* source_input: Handles user input to the source window.
* -------------
*
* sview: Source viewer object
* key: Keystroke received.
*/
static void source_input(struct sviewer *sview, int key)
{
switch (key) {
case CGDB_KEY_UP:
case 'k': { /* VI-style up-arrow */
int lineno = 1;
cgdb_string_to_int(ibuf_get(G_line_number), &lineno);
source_vscroll(sview, -lineno);
break;
}
case CGDB_KEY_DOWN:
case 'j': { /* VI-style down-arrow */
int lineno = 1;
cgdb_string_to_int(ibuf_get(G_line_number), &lineno);
source_vscroll(sview, lineno);
break;
}
case CGDB_KEY_LEFT:
case 'h':
source_hscroll(sview, -1);
break;
case CGDB_KEY_RIGHT:
case 'l':
source_hscroll(sview, 1);
break;
case CGDB_KEY_CTRL_U: /* VI-style 1/2 page up */
source_vscroll(sview, -(get_src_height() / 2));
break;
case CGDB_KEY_PPAGE:
case CGDB_KEY_CTRL_B: /* VI-style page up */
source_vscroll(sview, -(get_src_height() - 1));
break;
case CGDB_KEY_CTRL_D: /* VI-style 1/2 page down */
source_vscroll(sview, (get_src_height() / 2));
break;
case CGDB_KEY_NPAGE:
case CGDB_KEY_CTRL_F: /* VI-style page down */
source_vscroll(sview, get_src_height() - 1);
break;
case 'g': /* beginning of file */
if (last_key_pressed == 'g')
source_set_sel_line(sview, 1);
break;
case 'G': { /* end of file or a line number */
int lineno = -1;
cgdb_string_to_int(ibuf_get(G_line_number), &lineno);
source_set_sel_line(sview, lineno);
break;
}
case '=':
/* inc window by 1 */
increase_win_height(0);
break;
case '-':
/* dec window by 1 */
decrease_win_height(0);
break;
case '+':
increase_win_height(1);
break;
case '_':
decrease_win_height(1);
break;
case 'o':
/* Causes file dialog to be opened */
{
extern int kui_input_acceptable;
kui_input_acceptable = 0;
tgdb_request_inferiors_source_files(tgdb);
}
break;
case ' ':
{
enum tgdb_breakpoint_action t = TGDB_BREAKPOINT_ADD;
toggle_breakpoint(sview, t);
}
break;
case 't':
{
enum tgdb_breakpoint_action t = TGDB_TBREAKPOINT_ADD;
toggle_breakpoint(sview, t);
}
break;
default:
break;
}
/* Store digits into G_line_number for 'G' command. */
if (key >= '0' && key <= '9') {
ibuf_addchar(G_line_number, key);
} else {
ibuf_clear(G_line_number);
}
/* Some extended features that are set by :set sc */
if_draw();
}
/**
* Send input to the CGDB source window.
*
* @param key
* The key to send to the CGDB source window.
*
* @param last_key
* An output parameter. When set, that will tell cgdb to use the set value,
* instead of the current key, as the "last_key_pressed" in the next
* call to cgdb_input. This is useful to set mainly when the current input
* has consumed more than one character, and the "last_key_pressed" should
* be not set on the next call to cgdb_input.
*
* @return
* Currently only returns 0.
*/
static int cgdb_input(int key, int *last_key)
{
int regex_icase = cgdbrc_get_int(CGDBRC_IGNORECASE);
if (src_viewer && src_viewer->cur) {
int ret = 0;
/* Handle setting (mX) and going ('X) to source buffer marks */
if (last_key_pressed == 'm')
ret = source_set_mark(src_viewer, key);
else if (last_key_pressed == '\'')
ret = source_goto_mark(src_viewer, key);
if (ret) {
/* When m[a-zA-Z] matches, don't let the marker char
* be treated as the last key. That would allow the
* chars mgg, to set the marker g, and then move to the top
* of the file via gg.
* CGDB should see those as mg (set a local mark g), and then
* an individual g.
*/
*last_key = 0;
if_draw();
return 0;
}
}
switch (key) {
case 's':
gdb_scroller->in_scroll_mode = 1;
if_set_focus(GDB);
return 0;
case 'i':
if_set_focus(GDB);
return 0;
case ':':
/* Set the type of the command the user is typing in the status bar */
sbc_kind = SBC_NORMAL;
if_set_focus(CGDB_STATUS_BAR);
/* Since the user is about to type in a command, allocate a buffer
* in which this command can be stored. */
cur_sbc = ibuf_init();
return 0;
case '/':
case '?':
if (src_viewer->cur) {
regex_cur = ibuf_init();
regex_direction_cur = ('/' == key);
orig_line_regex = src_viewer->cur->sel_line;
sbc_kind = SBC_REGEX;
if_set_focus(CGDB_STATUS_BAR);
/* Capturing regular expressions */
source_search_regex_init(src_viewer);
/* Initialize the function for finding a regex and tell user */
if_draw();
}
return 0;
case 'n':
source_search_regex(src_viewer, ibuf_get(regex_last), 2,
regex_direction_last, regex_icase);
if_draw();
break;
case 'N':
source_search_regex(src_viewer, ibuf_get(regex_last), 2,
!regex_direction_last, regex_icase);
if_draw();
break;
case CGDB_KEY_CTRL_T:
if (tgdb_tty_new(tgdb) == -1) {
/* Error */
} else {
if_layout();
}
break;
case CGDB_KEY_CTRL_W:
switch (cur_split_orientation) {
case WSO_HORIZONTAL:
cur_split_orientation = WSO_VERTICAL;
break;
case WSO_VERTICAL:
cur_split_orientation = WSO_HORIZONTAL;
break;
}
if_layout();
break;
case CGDB_KEY_F1:
if_display_help();
return 0;
case CGDB_KEY_F5:
/* Issue GDB run command */
tgdb_request_run_debugger_command(tgdb, TGDB_RUN);
return 0;
case CGDB_KEY_F6:
/* Issue GDB continue command */
tgdb_request_run_debugger_command(tgdb, TGDB_CONTINUE);
return 0;
case CGDB_KEY_F7:
/* Issue GDB finish command */
tgdb_request_run_debugger_command(tgdb, TGDB_FINISH);
return 0;
case CGDB_KEY_F8:
/* Issue GDB next command */
tgdb_request_run_debugger_command(tgdb, TGDB_NEXT);
case CGDB_KEY_F10:
/* Issue GDB step command */
tgdb_request_run_debugger_command(tgdb, TGDB_STEP);
return 0;
case CGDB_KEY_CTRL_L:
if_layout();
return 0;
}
source_input(src_viewer, key);
return 0;
}
/**
* Capture a regular expression from the user, one key at a time.
* This modifies the global variables regex_cur and regex_last.
*
* \param sview
* The source viewer.
*
* \return
* 0 if user gave a regex, otherwise 1.
*/
static int gdb_input_regex_input(struct scroller *scr, int key)
{
int regex_icase = cgdbrc_get_int(CGDBRC_IGNORECASE);
/* Flag to indicate we're done with regex mode, need to switch back */
int done = 0;
/* Receive a regex from the user. */
switch (key)
{
case '\r':
case '\n':
case CGDB_KEY_CTRL_M:
/* Save for future searches via 'n' or 'N' */
ibuf_free(regex_last);
regex_last = ibuf_dup(regex_cur);
regex_direction_last = regex_direction_cur;
scr_search_regex(scr, ibuf_get(regex_last), 2,
regex_direction_last, regex_icase);
if_draw();
done = 1;
break;
case 8:
case 127:
/* Backspace or DEL key */
if (ibuf_length(regex_cur) == 0)
{
done = 1;
scr_search_regex(scr, "", 2,
regex_direction_cur, regex_icase);
}
else
{
ibuf_delchar(regex_cur);
scr_search_regex(scr, ibuf_get(regex_cur), 1,
regex_direction_cur, regex_icase);
if_draw();
update_status_win(WIN_REFRESH);
}
break;
default:
if (kui_term_is_cgdb_key(key))
{
const char *keycode = kui_term_get_keycode_from_cgdb_key(key);
int length = strlen(keycode), i;
for (i = 0; i < length; i++)
ibuf_addchar(regex_cur, keycode[i]);
}
else
{
ibuf_addchar(regex_cur, key);
}
scr_search_regex(scr, ibuf_get(regex_cur), 1,
regex_direction_cur, regex_icase);
if_draw();
update_status_win(WIN_REFRESH);
};
if (done)
{
gdb_scroller->in_search_mode = 0;
ibuf_free(regex_cur);
regex_cur = NULL;
sbc_kind = SBC_NORMAL;
if_set_focus(GDB);
}
return 0;
}
/* Updates the status bar */
static void update_status_win(void)
{
int pos;
char filename[FSUTIL_PATH_MAX];
int attr;
if (hl_groups_get_attr(hl_groups_instance, HLG_STATUS_BAR, &attr) == -1)
return;
/* Update the tty status bar */
if (tty_win_on) {
wattron(tty_status_win, attr);
for (pos = 0; pos < WIDTH; pos++)
mvwprintw(tty_status_win, 0, pos, " ");
mvwprintw(tty_status_win, 0, 0, (char *) tgdb_tty_name(tgdb));
wattroff(tty_status_win, attr);
}
/* Print white background */
wattron(status_win, attr);
for (pos = 0; pos < WIDTH; pos++)
mvwprintw(status_win, 0, pos, " ");
if (tty_win_on)
wattron(tty_status_win, attr);
/* Show the user which window is focused */
if (focus == GDB)
mvwprintw(status_win, 0, WIDTH - 1, "*");
else if (focus == TTY && tty_win_on)
mvwprintw(tty_status_win, 0, WIDTH - 1, "*");
else if (focus == CGDB || focus == CGDB_STATUS_BAR)
mvwprintw(status_win, 0, WIDTH - 1, " ");
wattroff(status_win, attr);
if (tty_win_on)
wattroff(tty_status_win, attr);
/* Print the regex that the user is looking for Forward */
if (focus == CGDB_STATUS_BAR && sbc_kind == SBC_REGEX
&& regex_direction_cur) {
if_display_message("/", WIDTH - 1, "%s", ibuf_get(regex_cur));
curs_set(1);
}
/* Regex backwards */
else if (focus == CGDB_STATUS_BAR && sbc_kind == SBC_REGEX) {
if_display_message("?", WIDTH - 1, "%s", ibuf_get(regex_cur));
curs_set(1);
}
/* A colon command typed at the status bar */
else if (focus == CGDB_STATUS_BAR && sbc_kind == SBC_NORMAL) {
char *command = ibuf_get(cur_sbc);
if (!command)
command = "";
if_display_message(":", WIDTH - 1, "%s", command);
curs_set(1);
}
/* Default: Current Filename */
else {
/* Print filename */
if (src_win != NULL && source_current_file(src_win, filename) != NULL)
if_display_message("", WIDTH - 1, "%s", filename);
}
wrefresh(status_win);
}
int internal_if_input(int key)
{
int regex_icase = cgdbrc_get(CGDBRC_IGNORECASE)->variant.int_val;
/* Normally, CGDB_KEY_ESC, but can be configured by the user */
int cgdb_mode_key = cgdbrc_get(CGDBRC_CGDB_MODE_KEY)->variant.int_val;
/* The cgdb mode key, puts the debugger into command mode */
if (focus != CGDB && key == cgdb_mode_key) {
/* Depending on which cgdb was in, it can free some memory here that
* it was previously using. */
if (focus == CGDB_STATUS_BAR && sbc_kind == SBC_NORMAL) {
ibuf_free(cur_sbc);
cur_sbc = NULL;
} else if (focus == CGDB_STATUS_BAR && sbc_kind == SBC_REGEX) {
ibuf_free(regex_cur);
regex_cur = NULL;
free(src_win->cur->buf.cur_line);
src_win->cur->buf.cur_line = NULL;
src_win->cur->sel_rline = orig_line_regex;
src_win->cur->sel_line = orig_line_regex;
}
if_set_focus(CGDB);
return 0;
}
/* If you are already in cgdb mode, the cgdb mode key does nothing */
else if (key == cgdb_mode_key)
return 0;
/* Check for global keystrokes */
switch (focus) {
case CGDB:
switch (key) {
case 'i':
if_set_focus(GDB);
return 0;
case 'I':
if_set_focus(TTY);
return 0;
case ':':
/* Set the type of the command the user is typing in the status bar */
sbc_kind = SBC_NORMAL;
if_set_focus(CGDB_STATUS_BAR);
/* Since the user is about to type in a command, allocate a buffer
* in which this command can be stored. */
cur_sbc = ibuf_init();
return 0;
case '/':
case '?':
if (src_win->cur != NULL) {
regex_cur = ibuf_init();
regex_direction_cur = ('/' == key);
orig_line_regex = src_win->cur->sel_line;
sbc_kind = SBC_REGEX;
if_set_focus(CGDB_STATUS_BAR);
/* Capturing regular expressions */
source_search_regex_init(src_win);
/* Initialize the function for finding a regex and tell user */
if_draw();
}
return 0;
case 'n':
source_search_regex(src_win, ibuf_get(regex_last), 2,
regex_direction_last, regex_icase);
if_draw();
break;
case 'N':
source_search_regex(src_win, ibuf_get(regex_last), 2,
!regex_direction_last, regex_icase);
if_draw();
break;
case 'T':
if (tty_win_on) {
tty_win_on = 0;
focus = CGDB;
} else {
tty_win_on = 1;
focus = TTY;
}
if_layout();
break;
case CGDB_KEY_CTRL_T:
if (tgdb_tty_new(tgdb) == -1) {
/* Error */
} else {
scr_free(tty_win);
tty_win = NULL;
if_layout();
}
break;
case CGDB_KEY_F1:
if_display_help();
return 0;
case CGDB_KEY_F5:
/* Issue GDB run command */
{
tgdb_request_ptr request_ptr;
request_ptr =
tgdb_request_run_debugger_command(tgdb, TGDB_RUN);
handle_request(tgdb, request_ptr);
}
return 0;
case CGDB_KEY_F6:
/* Issue GDB continue command */
{
tgdb_request_ptr request_ptr;
request_ptr =
tgdb_request_run_debugger_command(tgdb,
TGDB_CONTINUE);
handle_request(tgdb, request_ptr);
}
return 0;
case CGDB_KEY_F7:
/* Issue GDB finish command */
{
tgdb_request_ptr request_ptr;
request_ptr =
tgdb_request_run_debugger_command(tgdb,
TGDB_FINISH);
handle_request(tgdb, request_ptr);
}
return 0;
case CGDB_KEY_F8:
/* Issue GDB next command */
{
tgdb_request_ptr request_ptr;
request_ptr =
tgdb_request_run_debugger_command(tgdb, TGDB_NEXT);
handle_request(tgdb, request_ptr);
}
return 0;
case CGDB_KEY_F10:
/* Issue GDB step command */
{
tgdb_request_ptr request_ptr;
request_ptr =
tgdb_request_run_debugger_command(tgdb, TGDB_STEP);
handle_request(tgdb, request_ptr);
}
return 0;
case CGDB_KEY_CTRL_L:
if_layout();
return 0;
}
source_input(src_win, key);
return 0;
break;
case TTY:
return tty_input(key);
case GDB:
return gdb_input(key);
case FILE_DLG:
{
static char filedlg_file[MAX_LINE];
int ret = filedlg_recv_char(fd, key, filedlg_file);
/* The user cancelled */
if (ret == -1) {
if_set_focus(CGDB);
return 0;
/* Needs more data */
} else if (ret == 0) {
return 0;
/* The user picked a file */
} else if (ret == 1) {
tgdb_request_ptr request_ptr;
request_ptr = tgdb_request_filename_pair(tgdb, filedlg_file);
handle_request(tgdb, request_ptr);
if_set_focus(CGDB);
return 0;
}
}
return 0;
case CGDB_STATUS_BAR:
return status_bar_input(src_win, key);
}
/* Never gets here */
return 0;
}
/* gdb_input: Handles user input to the GDB window.
* ----------
*
* key: Keystroke received.
*
* Return Value: 0 if internal key was used,
* 1 if input to gdb or ...
* -1 : Error resizing terminal -- terminal too small
*/
static int gdb_input(int key, int *last_key)
{
int result = 0;
if (gdb_scroller->in_search_mode)
return gdb_input_regex_input(gdb_scroller, key);
if (gdb_scroller->in_scroll_mode) {
/* Handle setting (mX) and going ('X) to gdb buffer marks */
if (last_key_pressed == 'm' || last_key_pressed == '\'') {
int ret = 0;
if (last_key_pressed == 'm')
ret = scr_set_mark(gdb_scroller, key);
else if(last_key_pressed == '\'')
ret = scr_goto_mark(gdb_scroller, key);
if (ret) {
*last_key = 0;
if_draw();
}
return 0;
}
/* In scroll mode, all extra characters are not passed to
* the active GDB command. result = 0 above ensures that. */
switch (key) {
case 'm':
case '\'':
/* Mark keys - ignore them */
break;
case CGDB_KEY_CTRL_U:
scr_up(gdb_scroller, get_gdb_height() / 2);
break;
case CGDB_KEY_PPAGE:
scr_up(gdb_scroller, get_gdb_height() - 1);
break;
case CGDB_KEY_CTRL_D:
scr_down(gdb_scroller, get_gdb_height() / 2);
break;
case CGDB_KEY_NPAGE:
scr_down(gdb_scroller, get_gdb_height() - 1);
break;
case CGDB_KEY_HOME:
case CGDB_KEY_F11:
scr_home(gdb_scroller);
break;
case 'G':
case CGDB_KEY_END:
case CGDB_KEY_F12:
scr_end(gdb_scroller);
break;
case 'k':
case CGDB_KEY_UP:
case CGDB_KEY_CTRL_P:
scr_up(gdb_scroller, 1);
break;
case 'j':
case CGDB_KEY_DOWN:
case CGDB_KEY_CTRL_N:
scr_down(gdb_scroller, 1);
break;
case 'g':
if (last_key_pressed == 'g') {
scr_home(gdb_scroller);
}
break;
case 'q':
case 'i':
case '\r':
case '\n':
case CGDB_KEY_CTRL_M:
scr_end(gdb_scroller);
gdb_scroller->in_scroll_mode = 0;
break;
case 'n':
scr_search_regex(gdb_scroller, ibuf_get(regex_last), 2,
regex_direction_last, cgdbrc_get_int(CGDBRC_IGNORECASE));
break;
case 'N':
scr_search_regex(gdb_scroller, ibuf_get(regex_last), 2,
!regex_direction_last, cgdbrc_get_int(CGDBRC_IGNORECASE));
break;
case '/':
case '?':
/* Capturing regular expressions */
regex_cur = ibuf_init();
regex_direction_cur = ('/' == key);
orig_line_regex = gdb_scroller->current.r;
sbc_kind = SBC_REGEX;
scr_search_regex_init(gdb_scroller);
break;
}
} else {
switch (key) {
case CGDB_KEY_PPAGE:
scr_up(gdb_scroller, get_gdb_height() - 1);
break;
case CGDB_KEY_CTRL_L:
scr_clear(gdb_scroller);
/* The return 1 tells readline that gdb did not handle the
* Ctrl-l. That way readline will handle it. Because
* readline uses TERM=dumb, that means that it will clear
* a single line and put out the prompt. */
result = 1;
break;
default:
/* This tells the input to go to active GDB command */
result = 1;
}
}
if_draw();
return result;
}
/* Please forgive me for adding all the comment below. This function
* has some strange bahaviors that I thought should be well explained.
*/
void rlctx_send_user_command(char *line)
{
char *cline;
int length;
char *rline_prompt;
tgdb_request_ptr request_ptr;
if (line == NULL) {
/* NULL line means rl_callback_read_char received EOF */
ibuf_add(current_line, "quit");
} else {
/* Add the line passed in to the current line */
ibuf_add(current_line, line);
}
/* Get current line, and current line length */
cline = ibuf_get(current_line);
length = ibuf_length(current_line);
/* Check to see if the user is escaping the line, to use a
* multi line command. If so, return so that the user can
* continue the command. This data should not go into the history
* buffer, or be sent to gdb yet.
*
* Also, notice the length > 0 condition. (length == 0) can happen
* when the user simply hits Enter on the keyboard. */
if (length > 0 && cline[length - 1] == '\\') {
/* The \ char is for continuation only, it is not meant to be sent
* to GDB as a character. */
ibuf_delchar(current_line);
/* Only need to change the prompt the first time the \ char is used.
* Doing it a second time would erase the real rline_last_prompt,
* since the prompt has already been set to "".
*/
if (!rline_last_prompt) {
rline_get_prompt(rline, &rline_prompt);
rline_last_prompt = strdup(rline_prompt);
/* GDB set's the prompt to nothing when doing continuation.
* This is here just for compatibility. */
rline_set_prompt(rline, "");
}
return;
}
/* If here, a full command has been sent. Restore the prompt. */
if (rline_last_prompt) {
rline_set_prompt(rline, rline_last_prompt);
free(rline_last_prompt);
rline_last_prompt = NULL;
}
/* Don't add the enter command to the history */
if (length > 0)
rline_add_history(rline, cline);
request_ptr = tgdb_request_run_console_command(tgdb, cline);
if (!request_ptr)
logger_write_pos(logger, __FILE__, __LINE__,
"rlctx_send_user_command\n");
/* Send this command to TGDB */
handle_request(tgdb, request_ptr);
ibuf_clear(current_line);
}
int filedlg_recv_char(struct filedlg *fd, int key, char *file, int last_key_pressed)
{
/* Initialize size variables */
int height = swin_getmaxy(fd->win);
filedlg_display(fd);
switch (key) {
case 'q':
return -1;
/* Vertical scrolling */
case CGDB_KEY_DOWN:
case 'j':
filedlg_vscroll(fd, 1);
break;
case CGDB_KEY_NPAGE:
case CGDB_KEY_CTRL_F: /* VI-style page down */
filedlg_vscroll(fd, height - 1);
break;
case CGDB_KEY_CTRL_D: /* VI-style 1/2 page down */
filedlg_vscroll(fd, height / 2);
break;
case CGDB_KEY_CTRL_U: /* VI-style 1/2 page up */
filedlg_vscroll(fd, -height / 2);
break;
case CGDB_KEY_UP:
case 'k':
filedlg_vscroll(fd, -1);
break;
case CGDB_KEY_PPAGE:
case CGDB_KEY_CTRL_B: /* VI-style page up */
filedlg_vscroll(fd, -(height - 1));
break;
/* Horizontal scrolling */
case CGDB_KEY_RIGHT:
case 'l':
filedlg_hscroll(fd, 1);
break;
case CGDB_KEY_LEFT:
case 'h':
filedlg_hscroll(fd, -1);
break;
case '/':
case '?':
regex_direction = ('/' == key);
/* Capturing regular expressions */
filedlg_search_regex_init(fd);
capture_regex(fd);
break;
case 'n':
filedlg_search_regex(fd, regex_line, 2, regex_direction, 1);
break;
case 'N':
filedlg_search_regex(fd, regex_line, 2, !regex_direction, 1);
break;
/* User selected a file */
case '\n':
case '\r':
case CGDB_KEY_CTRL_M:
strcpy(file, fd->buf->files[fd->buf->sel_line]);
return 1;
case 'g': /* beginning of file */
if (last_key_pressed == 'g')
filedlg_set_sel_line(fd, 0);
break;
case 'G': { /* end of file, or a line number*/
int lineno = -1, result;
result = cgdb_string_to_int(ibuf_get(fd->G_line_number), &lineno);
if (result == 0) {
filedlg_set_sel_line(fd, lineno -1);
}
break;
}
default:
break;
}
/* Store digits into G_line_number for 'G' command. */
if (key >= '0' && key <= '9') {
ibuf_addchar(fd->G_line_number, key);
} else {
ibuf_clear(fd->G_line_number);
}
filedlg_display(fd);
return 0;
}
static int highlight_node ( struct list_node *node ) {
struct tokenizer *t = tokenizer_init ();
int ret;
struct ibuf *ibuf = ibuf_init ();
ibuf_addchar ( ibuf, HL_CHAR );
ibuf_addchar ( ibuf, HLG_TEXT );
/* Initialize */
node->buf.length = 0;
node->buf.tlines = NULL;
node->buf.max_width = 0;
if ( tokenizer_set_file ( t, node->path, node->language ) == -1 ) {
if_print_message ("%s:%d tokenizer_set_file error", __FILE__, __LINE__);
return -1;
}
while ( ( ret = tokenizer_get_token ( t ) ) > 0 ) {
enum tokenizer_type e = tokenizer_get_packet_type ( t );
/*if_print_message ( "TOKEN(%d:%s)\n", e, tokenizer_get_printable_enum ( e ) );*/
switch ( e ) {
case TOKENIZER_KEYWORD:
ibuf_addchar ( ibuf, HL_CHAR );
ibuf_addchar ( ibuf, HLG_KEYWORD );
ibuf_add ( ibuf, tokenizer_get_data ( t ) );
ibuf_addchar ( ibuf, HL_CHAR );
ibuf_addchar ( ibuf, HLG_TEXT );
break;
case TOKENIZER_TYPE:
ibuf_addchar ( ibuf, HL_CHAR );
ibuf_addchar ( ibuf, HLG_TYPE );
ibuf_add ( ibuf, tokenizer_get_data ( t ) );
ibuf_addchar ( ibuf, HL_CHAR );
ibuf_addchar ( ibuf, HLG_TEXT );
break;
case TOKENIZER_LITERAL:
ibuf_addchar ( ibuf, HL_CHAR );
ibuf_addchar ( ibuf, HLG_LITERAL );
ibuf_add ( ibuf, tokenizer_get_data ( t ) );
ibuf_addchar ( ibuf, HL_CHAR );
ibuf_addchar ( ibuf, HLG_TEXT );
break;
case TOKENIZER_NUMBER:
ibuf_add ( ibuf, tokenizer_get_data ( t ) );
break;
case TOKENIZER_COMMENT:
ibuf_addchar ( ibuf, HL_CHAR );
ibuf_addchar ( ibuf, HLG_COMMENT );
ibuf_add ( ibuf, tokenizer_get_data ( t ) );
ibuf_addchar ( ibuf, HL_CHAR );
ibuf_addchar ( ibuf, HLG_TEXT );
break;
case TOKENIZER_DIRECTIVE:
ibuf_addchar ( ibuf, HL_CHAR );
ibuf_addchar ( ibuf, HLG_DIRECTIVE );
ibuf_add ( ibuf, tokenizer_get_data ( t ) );
ibuf_addchar ( ibuf, HL_CHAR );
ibuf_addchar ( ibuf, HLG_TEXT );
break;
case TOKENIZER_TEXT:
ibuf_add ( ibuf, tokenizer_get_data ( t ) );
break;
case TOKENIZER_NEWLINE:
node->buf.length++;
node->buf.tlines = realloc ( node->buf.tlines, sizeof ( char *) * node->buf.length );
node->buf.tlines[node->buf.length-1] = strdup ( ibuf_get ( ibuf ) );
if ( ibuf_length ( ibuf ) > node->buf.max_width )
node->buf.max_width = ibuf_length ( ibuf );
ibuf_clear ( ibuf );
ibuf_addchar ( ibuf, HL_CHAR );
ibuf_addchar ( ibuf, HLG_TEXT );
break;
case TOKENIZER_ERROR:
ibuf_add ( ibuf, tokenizer_get_data ( t ) );
break;
default:
return -1;
break;
}
}
return 0;
}