int command_parse_file(FILE * fp)
{
char buffer[4096];
char *p = buffer;
int linenumber = 0;
while (linenumber++, fgets(p, sizeof (buffer) - (p - buffer), fp)) {
int bufferlen = strlen(buffer);
if ((bufferlen - 2 >= 0) && buffer[bufferlen - 2] == '\\') {
/* line continuation character, read another line into the buffer */
linenumber--;
p = buffer + bufferlen - 2;
continue;
}
if (command_parse_string(buffer)) {
/* buffer already has an \n */
if_print_message("Error parsing line %d: %s", linenumber, buffer);
/* return -1; don't return, lets keep parsing the file. */
}
p = buffer;
}
return 0;
}
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 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;
}
/**
* The goal of this function is to display the tab completion information
* to the user in an asychronous and potentially interactive manner.
*
* It will output to the screen as much as can be until user input is needed.
* If user input is needed, then this function must stop, and wait until
* that data has been recieved.
*
* If this function is called a second time with the same completion_ptr
* parameter, it will continue outputting the tab completion data from
* where it left off.
*
* \param completion_ptr
* The tab completion data to output to the user
*
* \param key
* The key the user wants to pass to the query command that was made.
* If -1, then this is assummed to be the first time this function has been
* called.
*
* \return
* 0 on success or -1 on error
*/
static int handle_tab_completion_request(tab_completion_ptr comptr, int key)
{
int query_items;
int gdb_window_size;
if (!comptr)
return -1;
query_items = rline_get_rl_completion_query_items(rline);
gdb_window_size = get_gdb_height();
if (comptr->state == TAB_COMPLETION_START) {
if_print("\n");
if (query_items > 0 && comptr->num_matches >= query_items) {
if_print_message("Display all %d possibilities? (y or n)\n",
comptr->num_matches);
comptr->state = TAB_COMPLETION_QUERY_POSSIBILITIES;
return 0;
}
comptr->state = TAB_COMPLETION_COMPLETION_DISPLAY;
}
if (comptr->state == TAB_COMPLETION_QUERY_POSSIBILITIES) {
int val = cgdb_get_y_or_n(key, 0);
if (val == 1)
comptr->state = TAB_COMPLETION_COMPLETION_DISPLAY;
else if (val == 0)
comptr->state = TAB_COMPLETION_DONE;
else
return 0; /* stay at the same state */
}
if (comptr->state == TAB_COMPLETION_QUERY_PAGER) {
int i = cgdb_get_y_or_n(key, 1);
if_clear_line(); /* Clear the --More-- */
if (i == 0)
comptr->state = TAB_COMPLETION_DONE;
else if (i == 2) {
comptr->lines--;
comptr->state = TAB_COMPLETION_COMPLETION_DISPLAY;
} else {
comptr->lines = 0;
comptr->state = TAB_COMPLETION_COMPLETION_DISPLAY;
}
}
if (comptr->state == TAB_COMPLETION_COMPLETION_DISPLAY) {
for (; comptr->total <= comptr->num_matches; comptr->total++) {
if_print(comptr->matches[comptr->total]);
if_print("\n");
comptr->lines++;
if (comptr->lines >= (gdb_window_size - 1) &&
comptr->total < comptr->num_matches) {
if_print("--More--");
comptr->state = TAB_COMPLETION_QUERY_PAGER;
comptr->total++;
return 0;
}
}
comptr->state = TAB_COMPLETION_DONE;
}
if (comptr->state == TAB_COMPLETION_DONE) {
tab_completion_destroy(completion_ptr);
completion_ptr = NULL;
is_tab_completing = 0;
rline_rl_forced_update_display(rline);
}
return 0;
}
void if_sdc_print(const char *buf)
{
if_print_message("cgdb sdc:%s", buf);
}
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;
}
