void tail_reading_all(int N, FILE *stream) { Line **line, *l; int i, last, first; if (!N) return; line = malloc(N * sizeof(Line *)); if (!line) { fprintf(stderr, "Error in tail_reading_all\n"); exit(EXIT_FAILURE); } for (i = 0; i < N; ++i) line[i] = NULL; last = 0; while ((l = io_readline(stream))) { if (line[last]) line_free(line[last]); /* we could just reuse old buffers */ line[last] = l; last = (last + 1) % N; } last = (N + last - 1) % N; first = (last + 1) % N; if (!line[first]) first = 0; for (i = first; i != last; i = (i + 1) % N) { fwrite(line[i]->buf, 1, line[i]->size, stdout); fprintf(stdout, "\n"); } if (N && line[last]) { fwrite(line[last]->buf, 1, line[last]->size, stdout); fprintf(stdout, "\n"); } for (i = 0; i < N; i++) { if (line[i]) line_free(line[i]); else break; } free(line); }
/* This links the given line into the scrollback-buffer */ static void link_to_scrollback(struct tsm_screen *con, struct line *line) { struct line *tmp; if (con->sb_max == 0) { line_free(line); return; } /* Remove a line from the scrollback buffer if it reaches its maximum. * We must take care to correctly keep the current position as the new * line is linked in after we remove the top-most line here. * sb_max == 0 is tested earlier so we can assume sb_max > 0 here. In * other words, buf->sb_first is a valid line if sb_count >= sb_max. */ if (con->sb_count >= con->sb_max) { tmp = con->sb_first; con->sb_first = tmp->next; if (tmp->next) tmp->next->prev = NULL; else con->sb_last = NULL; --con->sb_count; /* (position == tmp && !next) means we have sb_max=1 so set * position to the new line. Otherwise, set to new first line. * If position!=tmp and we have a fixed-position then nothing * needs to be done because we can stay at the same line. If we * have no fixed-position, we need to set the position to the * next inserted line, which can be "line", too. */ if (con->sb_pos) { if (con->sb_pos == tmp || !(con->flags & TSM_SCREEN_FIXED_POS)) { if (con->sb_pos->next) con->sb_pos = con->sb_pos->next; else con->sb_pos = line; } } line_free(tmp); } line->next = NULL; line->prev = con->sb_last; if (con->sb_last) con->sb_last->next = line; else con->sb_first = line; con->sb_last = line; ++con->sb_count; }
SHL_EXPORT int tsm_screen_new(struct tsm_screen **out, tsm_log_t log, void *log_data) { struct tsm_screen *con; int ret; unsigned int i; if (!out) return -EINVAL; con = malloc(sizeof(*con)); if (!con) return -ENOMEM; memset(con, 0, sizeof(*con)); con->ref = 1; con->llog = log; con->llog_data = log_data; con->age_cnt = 1; con->age = con->age_cnt; con->def_attr.fr = 255; con->def_attr.fg = 255; con->def_attr.fb = 255; ret = tsm_symbol_table_new(&con->sym_table); if (ret) goto err_free; ret = tsm_screen_resize(con, 80, 24); if (ret) goto err_free; llog_debug(con, "new screen"); *out = con; return 0; err_free: for (i = 0; i < con->line_num; ++i) { line_free(con->main_lines[i]); line_free(con->alt_lines[i]); } free(con->main_lines); free(con->alt_lines); free(con->tab_ruler); tsm_symbol_table_unref(con->sym_table); free(con); return ret; }
/* set maximum scrollback buffer size */ void tsm_screen_set_max_sb(struct tsm_screen *con, unsigned int max) { struct line *line; if (!con) return; while (con->sb_count > max) { line = con->sb_first; con->sb_first = line->next; if (line->next) line->next->prev = NULL; else con->sb_last = NULL; con->sb_count--; /* We treat fixed/unfixed position the same here because we * remove lines from the TOP of the scrollback buffer. */ if (con->sb_pos == line) con->sb_pos = con->sb_first; line_free(line); } con->sb_max = max; }
/* clear scrollback buffer */ SHL_EXPORT void tsm_screen_clear_sb(struct tsm_screen *con) { struct line *iter, *tmp; if (!con) return; screen_inc_age(con); /* TODO: more sophisticated ageing */ con->age = con->age_cnt; for (iter = con->sb_first; iter; ) { tmp = iter; iter = iter->next; line_free(tmp); } con->sb_first = NULL; con->sb_last = NULL; con->sb_count = 0; con->sb_pos = NULL; if (con->sel_active) { if (con->sel_start.line) { con->sel_start.line = NULL; con->sel_start.y = SELECTION_TOP; } if (con->sel_end.line) { con->sel_end.line = NULL; con->sel_end.y = SELECTION_TOP; } } }
int main( int argc, char ** argv ) { line_t * ptr; int sz; char * lines[3] = { "goober", "", "Looks like a real line.\n" }; for(int i=0; i < 3; i++) { ptr = line_new(); line_set(ptr , lines[i]); sz = line_size( ptr ); printf("ptr size: %d\n", sz ); printf("ptr data: %s\n", line_get(ptr) ); printf("ends in newline: %s\n", line_has_newline( ptr ) ? "Yes" : "No" ); printf("null terminated: %s\n", line_null_terminated( ptr ) ? "Yes" : "No" ); line_free( ptr ); printf("line after free is null? %s\n", ptr == NULL ? "Yes" : "No" ); } return 0; }
/* clear scrollback buffer */ void tsm_screen_clear_sb(struct tsm_screen *con) { struct line *iter, *tmp; if (!con) return; for (iter = con->sb_first; iter; ) { tmp = iter; iter = iter->next; line_free(tmp); } con->sb_first = NULL; con->sb_last = NULL; con->sb_count = 0; con->sb_pos = NULL; if (con->sel_active) { if (con->sel_start.line) { con->sel_start.line = NULL; con->sel_start.y = SELECTION_TOP; } if (con->sel_end.line) { con->sel_end.line = NULL; con->sel_end.y = SELECTION_TOP; } } }
void fractal_polyline_free (fractal_line_struct *f) { if (f) { if (f->polyline) line_free(f->polyline); x_free(f); } }
int tsm_screen_new(struct tsm_screen **out, tsm_log_t log) { struct tsm_screen *con; int ret; unsigned int i; if (!out) return -EINVAL; con = malloc(sizeof(*con)); if (!con) return -ENOMEM; memset(con, 0, sizeof(*con)); con->ref = 1; con->llog = log; con->def_attr.fr = 255; con->def_attr.fg = 255; con->def_attr.fb = 255; ret = shl_timer_new(&con->timer); if (ret) goto err_free; ret = tsm_screen_resize(con, 80, 24); if (ret) goto err_timer; llog_debug(con, "new screen"); *out = con; return 0; err_timer: shl_timer_free(con->timer); for (i = 0; i < con->line_num; ++i) { line_free(con->main_lines[i]); line_free(con->alt_lines[i]); } free(con->main_lines); free(con->alt_lines); free(con->tab_ruler); err_free: free(con); return ret; }
void tsm_screen_unref(struct tsm_screen *con) { unsigned int i; if (!con || !con->ref || --con->ref) return; llog_debug(con, "destroying screen"); for (i = 0; i < con->line_num; ++i) { line_free(con->main_lines[i]); line_free(con->alt_lines[i]); } free(con->main_lines); free(con->alt_lines); free(con->tab_ruler); shl_timer_free(con->timer); free(con); }
static void free_buffer(void) { struct line *line, *tmp; line = buffer; while(line) { tmp = line->next; line_free(line); line = tmp; } }
//~~~~~~~~~~~~~~~~~MAIN~~~~~~~~~~~~~~~~~~~~~~~ int main(int argc, char* argv[]){ int debug = 0, flag = 1, arg, numRead = 0; char command, *stream; Line line = line_init( stdin); gen_parse_args( argc, argv, &debug); Htable htable = ht_init( ht_mod_hash); while(flag){ arg = -1; fprintf( stdout, "\ncommand: "); line_read_line( line); stream = get_line( line); sscanf( stream, " %c%n", &command, &numRead); switch( command){ case 'q': flag = 0; break; case 'i': sscanf( stream+numRead, "%d", &arg); if( arg < 0) fprintf( stderr, "MUST BE >= 0\n"); else ht_add( htable, arg, arg, debug); break; case 'd': sscanf( stream+numRead, "%d", &arg); if( arg < 0) fprintf( stderr, "MUST BE >= 0\n"); else{ int pos = ht_mod_hash( htable, arg); node_delete( &((htable->table)[pos]), arg, arg, debug); } break; case 'c': sscanf( stream+numRead, "%d", &arg); if( arg < 0) fprintf( stderr, "MUST BE >= 0\n"); else{ if( ht_exists( htable, arg, debug) ) fprintf( stdout, "The value, %d, exists!\n", arg); else fprintf( stdout, "The value, %d, does NOT exist\n", arg); } break; case 'e': ht_erase( htable); break; case 'r': sscanf( stream+numRead, "%d", &arg); if( arg >= 1) ht_resize( htable, arg, debug); else fprintf( stderr, "Error, size must be >= 1\n"); break; case 'l': ht_list( htable); break; case '\n': break; default: fprintf( stdout, "Sorry, Invalid command\n"); break; } free(stream); } line_free( line); ht_free( htable); return 0; }
int main( int argc, char** argv){ int d = 0, quit = 1, commandNum, numRead; char *input, command; Line l = line_init(stdin); Ll ll = ll_init(); gen_parse_args( argc, argv, &d); while( quit){ printf("Command: "); line_read_line( l); input = get_line( l); sscanf(input, " %c%n", &command, &numRead); switch( command){ case 'q': quit = 0; break; case 'i': if( gen_exists_num( input+numRead) ){ sscanf(input+numRead, "%d", &commandNum); ll_insert( ll, commandNum , d); } else printf("Sorry, you didn't enter a number!\n"); break; case 'd': if( gen_exists_num( input+numRead) ){ sscanf( input+numRead, "%d", &commandNum); ll_delete( ll, commandNum, d); } else printf("Sorry, you didn't enter a number!\n"); break; case 'c': if( gen_exists_num( input+numRead) ){ sscanf( input+numRead, "%d", &commandNum); if( ll_contains( ll, commandNum, d) ) printf("LIST DOES CONTAIN %d\n", commandNum); else printf("LIST DOES NOT CONATAIN %d\n", commandNum); } else printf("Sorry, you didn't enter a number!\n"); break; case 'e': ll_empty( ll, d); break; case 'l': ll_print( ll, d); break; case 'r': ll_print_rev( ll, d); break; case '?': gen_print_help(); break; case 'h': gen_print_help(); break; case '\n': break; default: printf("Invalid Command\n"); } free( input); } ll_free( ll, d); line_free( l); return 0; }
void line_destroy(Line *line) { Eina_List *l; for (l = drawing->layers; l; l = l->next) { Layer *layer; layer = (Layer *) l->data; layer->objects = eina_list_remove(layer->objects, line); } line_free(line); }
static void merge_line(struct line *line) { struct line *tmp; line_realloc(strlen(line->data) + strlen(line->next->data) + 1, line); tmp = line->next; line->next = line->next->next; if (line->next) line->next->prev = line; strcat(line->data, tmp->data); line_free(tmp); refresh(1); }
/* clear scrollback buffer */ void tsm_screen_clear_sb(struct tsm_screen *con) { struct line *iter, *tmp; if (!con) return; for (iter = con->sb_first; iter; ) { tmp = iter; iter = iter->next; line_free(tmp); } con->sb_first = NULL; con->sb_last = NULL; con->sb_count = 0; con->sb_pos = NULL; }
/* set maximum scrollback buffer size */ SHL_EXPORT void tsm_screen_set_max_sb(struct tsm_screen *con, unsigned int max) { struct line *line; if (!con) return; screen_inc_age(con); /* TODO: more sophisticated ageing */ con->age = con->age_cnt; while (con->sb_count > max) { line = con->sb_first; con->sb_first = line->next; if (line->next) line->next->prev = NULL; else con->sb_last = NULL; con->sb_count--; /* We treat fixed/unfixed position the same here because we * remove lines from the TOP of the scrollback buffer. */ if (con->sb_pos == line) con->sb_pos = con->sb_first; if (con->sel_active) { if (con->sel_start.line == line) { con->sel_start.line = NULL; con->sel_start.y = SELECTION_TOP; } if (con->sel_end.line == line) { con->sel_end.line = NULL; con->sel_end.y = SELECTION_TOP; } } line_free(line); } con->sb_max = max; }
/* not very efficient but simple */ Line * io_readline (FILE *f) { Line *l; int c; l = line_new(); while (!feof(f)) { c = fgetc(f); if (c == EOF || c == '\n') break; if (l->size >= l->max_size) line_grow(l); l->buf[l->size++] = c; } if (!l->size && feof(f)) { line_free(l); return NULL; } if (l->size) line_compact(l); else { free(l->buf); l->buf = NULL; } return l; }
/* Clears ckt and removes current circuit from database */ void com_remcirc(wordlist *wl) { struct variable *v, *next; struct line *dd; /*in: the spice deck */ struct circ *p, *prev = NULL; #ifdef SHARED_MODULE TRANan *job; #endif NG_IGNORE(wl); if (ft_curckt == NULL) { fprintf(cp_err, "Error: there is no circuit loaded.\n"); return; } #ifdef SHARED_MODULE /* This may happen only with shared ngspice during transient analysis, if simulation is stopped with 'bg_halt' and then circuit shall be removed prematurely. */ job = (TRANan *) ft_curckt->ci_ckt->CKTcurJob; if (job && (job->JOBtype == 4) && (job->TRANplot)) SPfrontEnd->OUTendPlot (job->TRANplot); #endif /* delete numparam data structure dicoS */ nupa_del_dicoS(); dbfree(ft_curckt->ci_dbs); ft_curckt->ci_dbs = NULL; dbs = NULL; /* The next lines stem from com_rset */ INPkillMods(); if_cktfree(ft_curckt->ci_ckt, ft_curckt->ci_symtab); for (v = ft_curckt->ci_vars; v; v = next) { next = v->va_next; tfree(v->va_name); tfree(v); } ft_curckt->ci_vars = NULL; /* delete the deck, parameter list, and options list in ft_curckt */ dd = ft_curckt->ci_deck; line_free(dd, TRUE); dd = ft_curckt->ci_param; line_free(dd, TRUE); dd = ft_curckt->ci_options; line_free(dd, TRUE); wl_free(ft_curckt->ci_commands); tfree(ft_curckt->FTEstats); ft_sim->deleteTask (ft_curckt->ci_ckt, ft_curckt->ci_defTask); if (ft_curckt->ci_name) tfree(ft_curckt->ci_name); if (ft_curckt->ci_filename) tfree(ft_curckt->ci_filename); /* delete the actual circuit entry from ft_circuits */ for (p = ft_circuits; p; p = p->ci_next) { if (ft_curckt == p) { if (prev == NULL) { ft_circuits = p->ci_next; tfree(p); p = NULL; break; } else { prev->ci_next = p->ci_next; tfree(p); p = NULL; break; } } prev = p; } /* make first entry in ft_circuits the actual circuit (or NULL) */ ft_curckt = ft_circuits; if (ft_curckt) { modtab = ft_curckt->ci_modtab; dbs = ft_curckt->ci_dbs; } }
SHL_EXPORT int tsm_screen_resize(struct tsm_screen *con, unsigned int x, unsigned int y) { struct line **cache; unsigned int i, j, width, diff, start; int ret; bool *tab_ruler; if (!con || !x || !y) return -EINVAL; if (con->size_x == x && con->size_y == y) return 0; /* First make sure the line buffer is big enough for our new screen. * That is, allocate all new lines and make sure each line has enough * cells to hold the new screen or the current screen. If we fail, we * can safely return -ENOMEM and the buffer is still valid. We must * allocate the new lines to at least the same size as the current * lines. Otherwise, if this function fails in later turns, we will have * invalid lines in the buffer. */ if (y > con->line_num) { /* resize main buffer */ cache = realloc(con->main_lines, sizeof(struct line*) * y); if (!cache) return -ENOMEM; if (con->lines == con->main_lines) con->lines = cache; con->main_lines = cache; /* resize alt buffer */ cache = realloc(con->alt_lines, sizeof(struct line*) * y); if (!cache) return -ENOMEM; if (con->lines == con->alt_lines) con->lines = cache; con->alt_lines = cache; /* allocate new lines */ if (x > con->size_x) width = x; else width = con->size_x; while (con->line_num < y) { ret = line_new(con, &con->main_lines[con->line_num], width); if (ret) return ret; ret = line_new(con, &con->alt_lines[con->line_num], width); if (ret) { line_free(con->main_lines[con->line_num]); return ret; } ++con->line_num; } } /* Resize all lines in the buffer if we increase screen width. This * will guarantee that all lines are big enough so we can resize the * buffer without reallocating them later. */ if (x > con->size_x) { tab_ruler = realloc(con->tab_ruler, sizeof(bool) * x); if (!tab_ruler) return -ENOMEM; con->tab_ruler = tab_ruler; for (i = 0; i < con->line_num; ++i) { ret = line_resize(con, con->main_lines[i], x); if (ret) return ret; ret = line_resize(con, con->alt_lines[i], x); if (ret) return ret; } } screen_inc_age(con); /* clear expansion/padding area */ start = x; if (x > con->size_x) start = con->size_x; for (j = 0; j < con->line_num; ++j) { /* main-lines may go into SB, so clear all cells */ i = 0; if (j < con->size_y) i = start; for ( ; i < con->main_lines[j]->size; ++i) screen_cell_init(con, &con->main_lines[j]->cells[i]); /* alt-lines never go into SB, only clear visible cells */ i = 0; if (j < con->size_y) i = con->size_x; for ( ; i < x; ++i) screen_cell_init(con, &con->alt_lines[j]->cells[i]); } /* xterm destroys margins on resize, so do we */ con->margin_top = 0; con->margin_bottom = con->size_y - 1; /* reset tabs */ for (i = 0; i < x; ++i) { if (i % 8 == 0) con->tab_ruler[i] = true; else con->tab_ruler[i] = false; } /* We need to adjust x-size first as screen_scroll_up() and friends may * have to reallocate lines. The y-size is adjusted after them to avoid * missing lines when shrinking y-size. * We need to carefully look for the functions that we call here as they * have stronger invariants as when called normally. */ con->size_x = x; if (con->cursor_x >= con->size_x) move_cursor(con, con->size_x - 1, con->cursor_y); /* scroll buffer if screen height shrinks */ if (y < con->size_y) { diff = con->size_y - y; screen_scroll_up(con, diff); if (con->cursor_y > diff) move_cursor(con, con->cursor_x, con->cursor_y - diff); else move_cursor(con, con->cursor_x, 0); } con->size_y = y; con->margin_bottom = con->size_y - 1; if (con->cursor_y >= con->size_y) move_cursor(con, con->cursor_x, con->size_y - 1); return 0; }