int replace_maps (struct block * b) {
int r = 0;
if (++mapdepth == 1000) {
scerror("recursive mapping");
flush_buf(b);
mapdepth = 0;
return 0;
}
// Recorro mapeos de sesion
map * m = maps;
while (m != NULL) {
// Verifico si algun mapeo existe en el buffer b
int pos = block_in_block(b, m->in);
if (pos != -1 && m->mode == curmode) {
// se reemplaza contenido m->in por m->out en la lista b
if (replace_block_in_block(b, m->in, m->out) == -1) {
scerror("error replacing maps");
return -1;
}
r = 1;
break;
}
m = m->psig;
}
if (r && m->recursive) replace_maps(b); // recursive mapping here!
return r;
}
int copy_buf(int fd , int outfd , char *outbuf , size_t *outlen )
{
ssize_t len ;
int tmp ;
{
{
#line 79
while (1) {
while_continue: /* CIL Label */ ;
#line 82
if (*outlen == 524288UL) {
{
#line 83
tmp = flush_buf(outfd, outbuf, outlen);
}
#line 83
if (tmp < 0) {
#line 84
return (-1);
}
}
{
#line 86
len = read(fd, (void *)(outbuf + *outlen), 524288UL - *outlen);
}
#line 87
if (len < 0L) {
{
#line 88
perror("read");
}
#line 89
return (-1);
} else
#line 90
if (len == 0L) {
#line 91
goto while_break;
}
#line 93
*outlen += (size_t )len;
}
while_break: /* CIL Label */ ;
}
#line 96
return (0);
}
}
BOOL modem_process (U8 ch) {
/* Modem character process event handler. This function is called when */
/* a new character has been received from the modem in command mode */
if (modem_st == MODEM_IDLE) {
mlen = 0;
return (__FALSE);
}
if (mlen < sizeof(mbuf)) {
mbuf[mlen++] = ch;
}
/* Modem driver is processing a command */
if (wait_for) {
/* 'modem_run()' is waiting for modem reply */
if (str_scomp (mbuf,reply) == __TRUE) {
wait_for = 0;
delay = 0;
if (wait_conn) {
/* OK, we are online here. */
wait_conn = 0;
modem_st = MODEM_ONLINE;
/* Inform the parent process we are online now. */
return (__TRUE);
}
}
}
/* Watch the modem disconnect because we do not use CD line */
if (mem_comp (mbuf,"NO CARRIER",10) == __TRUE) {
set_mode ();
}
if (ch == '\r' || ch == '\n') {
flush_buf ();
}
/* Modem not connected, return FALSE */
return (__FALSE);
}
int append_buf(char const *str , size_t len , int outfd , char *outbuf , size_t *outlen )
{
int tmp ;
{
#line 61
if (! (len <= 524288UL)) {
{
#line 61
__assert_fail("len <= 524288", "/home/june/collector/temp/bootchart-0.90.2/bootchart-collector.c",
61U, "append_buf");
}
}
#line 63
if (*outlen + len > 524288UL) {
{
#line 64
tmp = flush_buf(outfd, outbuf, outlen);
}
#line 64
if (tmp < 0) {
#line 65
return (-1);
}
}
{
#line 67
memcpy((void */* __restrict */)(outbuf + *outlen), (void const */* __restrict */)str,
len);
#line 68
*outlen += len;
}
#line 70
return (0);
}
}
void do_normalmode(struct block * buf) {
int bs = get_bufsize(buf);
struct ent * e;
switch (buf->value) {
// Movement commands
case 'j':
case OKEY_DOWN:
currow = forw_row(1)->row;
unselect_ranges();
update(TRUE);
break;
case 'k':
case OKEY_UP:
currow = back_row(1)->row;
unselect_ranges();
update(TRUE);
break;
case 'h':
case OKEY_LEFT:
curcol = back_col(1)->col;
unselect_ranges();
update(TRUE);
break;
case 'l':
case OKEY_RIGHT:
curcol = forw_col(1)->col;
unselect_ranges();
update(TRUE);
break;
case '0':
case OKEY_HOME:
curcol = left_limit()->col;
unselect_ranges();
update(TRUE);
break;
case '$':
case OKEY_END:
curcol = right_limit()->col;
unselect_ranges();
update(TRUE);
break;
case '^':
currow = goto_top()->row;
unselect_ranges();
update(TRUE);
break;
case '#':
currow = goto_bottom()->row;
unselect_ranges();
update(TRUE);
break;
// Tick
case '\'':
if (bs != 2) break;
unselect_ranges();
e = tick(buf->pnext->value);
if (row_hidden[e->row]) {
scerror("Cell row is hidden");
break;
}
if (col_hidden[e->col]) {
scerror("Cell column is hidden");
break;
}
currow = e->row;
curcol = e->col;
update(TRUE);
break;
// CTRL j
case ctl('j'):
{
int p, c = curcol, cf = curcol;
if ( (p = is_range_selected()) != -1) {
struct srange * sr = get_range_by_pos(p);
c = sr->tlcol;
cf = sr->brcol;
}
auto_justify(c, cf, DEFWIDTH); // auto justificado de columnas
update(TRUE);
break;
}
// CTRL d
case ctl('d'): // set date format using current locate D_FMT format
{
#ifdef USELOCALE
#include <locale.h>
#include <langinfo.h>
char * loc = NULL;
char * f = NULL;
loc = setlocale(LC_TIME, "");
if (loc != NULL) {
f = nl_langinfo(D_FMT);
} else {
scerror("No locale set. Nothing changed");
}
int p, r = currow, c = curcol, rf = currow, cf = curcol;
if ( (p = is_range_selected()) != -1) {
struct srange * sr = get_range_by_pos(p);
r = sr->tlrow;
c = sr->tlcol;
rf = sr->brrow;
cf = sr->brcol;
}
if (any_locked_cells(r, c, rf, cf)) {
scerror("Locked cells encountered. Nothing changed");
return;
}
dateformat(lookat(r, c), lookat(rf, cf), f);
update(TRUE);
break;
#else
scinfo("Build made without USELOCALE enabled");
#endif
}
// CTRL f
case ctl('f'):
case OKEY_PGDOWN:
{
int n = LINES - RESROW - 1;
if (atoi(get_conf_value("half_page_scroll"))) n = n / 2;
struct ent * e = forw_row(n);
currow = e->row;
unselect_ranges();
scroll_down(n);
update(TRUE);
break;
}
// CTRL b
case ctl('b'):
case OKEY_PGUP:
{
int n = LINES - RESROW - 1;
if (atoi(get_conf_value("half_page_scroll"))) n = n / 2;
currow = back_row(n)->row;
unselect_ranges();
scroll_up(n);
update(TRUE);
break;
}
case 'w':
e = go_forward();
currow = e->row;
curcol = e->col;
unselect_ranges();
update(TRUE);
break;
case 'b':
e = go_backward();
currow = e->row;
curcol = e->col;
unselect_ranges();
update(TRUE);
break;
case '/':
{
char cadena[] = ":int goto ";
int i;
for (i=0; i<strlen(cadena); i++) {
flush_buf(buf);
addto_buf(buf, cadena[i]);
exec_single_cmd(buf);
}
break;
}
case 'H':
currow = vert_top()->row;
unselect_ranges();
update(TRUE);
break;
case 'M':
currow = vert_middle()->row;
unselect_ranges();
update(TRUE);
break;
case 'L':
currow = vert_bottom()->row;
unselect_ranges();
update(TRUE);
break;
case 'G': // goto end
e = go_end();
currow = e->row;
curcol = e->col;
unselect_ranges();
update(TRUE);
break;
// GOTO goto
case ctl('a'):
e = go_home();
curcol = e->col;
currow = e->row;
unselect_ranges();
update(TRUE);
break;
case 'g':
if (buf->pnext->value == '0') { // g0
curcol = go_bol()->col;
} else if (buf->pnext->value == '$') { // g$
curcol = go_eol()->col;
} else if (buf->pnext->value == 'g') { // gg
e = go_home();
curcol = e->col;
currow = e->row;
} else if (buf->pnext->value == 'G') { // gG
e = go_end();
currow = e->row;
curcol = e->col;
} else if (buf->pnext->value == 'M') { // gM
curcol = horiz_middle()->col;
} else { // gA4 (goto cell)
(void) sprintf(interp_line, "goto %s", parse_cell_name(1, buf));
send_to_interp(interp_line);
}
unselect_ranges();
update(TRUE);
break;
// repeat last command
case '.':
copybuffer(lastcmd_buffer, buf); // nose graba en lastcmd_buffer!!
cmd_multiplier = 1;
exec_mult(buf, COMPLETECMDTIMEOUT);
break;
// enter command mode
case ':':
clr_header(input_win, 0);
chg_mode(':');
#ifdef HISTORY_FILE
add(commandline_history, "");
#endif
print_mode(input_win);
wrefresh(input_win);
handle_cursor();
inputline_pos = 0;
break;
// enter visual mode
case 'v':
chg_mode('v');
handle_cursor();
clr_header(input_win, 0);
print_mode(input_win);
wrefresh(input_win);
start_visualmode(currow, curcol, currow, curcol);
break;
// INPUT COMMANDS
case '=':
case '\\':
case '<':
case '>':
if (locked_cell(currow, curcol)) return;
insert_edit_submode = buf->value;
chg_mode(insert_edit_submode);
clr_header(input_win, 0);
print_mode(input_win);
wrefresh(input_win);
inputline_pos = 0;
break;
// EDITION COMMANDS
// edit cell (v)
case 'e':
if (locked_cell(currow, curcol)) return;
clr_header(input_win, 0);
inputline_pos = 0;
if (start_edit_mode(buf, 'v')) show_header(input_win);
break;
// edit cell (s)
case 'E':
if (locked_cell(currow, curcol)) return;
clr_header(input_win, 0);
inputline_pos = 0;
if (start_edit_mode(buf, 's')) show_header(input_win);
else {
scinfo("No string value to edit");
chg_mode('.');
show_celldetails(input_win);
print_mode(input_win);
wrefresh(input_win);
}
break;
// del current cell or range
case 'x':
del_selected_cells();
update(TRUE);
break;
// format col
case 'f':
if (bs != 2) return;
formatcol(buf->pnext->value);
break;
// mark cell or range
case 'm':
if (bs != 2) break;
int p = is_range_selected();
if (p != -1) { // mark range
struct srange * sr = get_range_by_pos(p);
set_range_mark(buf->pnext->value, sr);
} else // mark cell
set_cell_mark(buf->pnext->value, currow, curcol);
modflg++;
break;
// copy
case 'c':
{
if (bs != 2) break;
struct mark * m = get_mark(buf->pnext->value);
if ( m == NULL) return;
// if m represents a range
if ( m->row == -1 && m->col == -1) {
srange * r = m->rng;
yank_area(r->tlrow, r->tlcol, r->brrow, r->brcol, 'a', cmd_multiplier);
if (paste_yanked_ents(0, 'c') == -1) {
scerror("Locked cells encountered. Nothing changed");
break;
}
// if m represents just one cell
} else {
struct ent * p = *ATBL(tbl, get_mark(buf->pnext->value)->row, get_mark(buf->pnext->value)->col);
struct ent * n;
int c1;
#ifdef UNDO
create_undo_action();
#endif
for (c1 = curcol; cmd_multiplier-- && c1 < maxcols; c1++) {
if ((n = * ATBL(tbl, currow, c1))) {
if (n->flags & is_locked)
continue;
if (! p) {
clearent(n);
continue;
}
} else {
if (! p) break;
n = lookat(currow, c1);
}
#ifdef UNDO
copy_to_undostruct(currow, c1, currow, c1, 'd');
#endif
copyent(n, p, currow - get_mark(buf->pnext->value)->row, c1 - get_mark(buf->pnext->value)->col, 0, 0, maxrow, maxcol, 0);
n->row += currow - get_mark(buf->pnext->value)->row;
n->col += c1 - get_mark(buf->pnext->value)->col;
n->flags |= is_changed;
#ifdef UNDO
copy_to_undostruct(currow, c1, currow, c1, 'a');
#endif
}
#ifdef UNDO
end_undo_action();
#endif
}
if (atoi(get_conf_value("autocalc"))) EvalAll();
update(TRUE);
break;
}
// repeat last goto command
case 'n':
go_last();
update(TRUE);
break;
// range lock / unlock / valueize
case 'r':
{
int p, r = currow, c = curcol, rf = currow, cf = curcol;
if ( (p = is_range_selected()) != -1) {
struct srange * sr = get_range_by_pos(p);
r = sr->tlrow;
c = sr->tlcol;
rf = sr->brrow;
cf = sr->brcol;
}
if (buf->pnext->value == 'l') {
lock_cells(lookat(r, c), lookat(rf, cf));
} else if (buf->pnext->value == 'u') {
unlock_cells(lookat(r, c), lookat(rf, cf));
} else if (buf->pnext->value == 'v') {
valueize_area(r, c, rf, cf);
}
update(TRUE);
break;
}
// create range with two marks
case 'R':
if (bs == 3) {
create_range(buf->pnext->value, buf->pnext->pnext->value, NULL, NULL);
update(TRUE);
}
break;
// Zr Zc - Zap col or row - Show col or row - Sr Sc
case 'Z':
case 'S':
{
int rs, r = currow, c = curcol, arg = cmd_multiplier;
struct srange * sr;
if ( (rs = is_range_selected()) != -1) {
sr = get_range_by_pos(rs);
cmd_multiplier = 1;
r = sr->tlrow;
c = sr->tlcol;
arg = buf->pnext->value == 'r' ? sr->brrow - sr->tlrow + 1 : sr->brcol - sr->tlcol + 1;
}
if (buf->value == 'Z' && buf->pnext->value == 'r') {
hide_row(r, arg);
} else if (buf->value == 'Z' && buf->pnext->value == 'c') {
hide_col(c, arg);
} else if (buf->value == 'S' && buf->pnext->value == 'r') {
show_row(r, arg);
} else if (buf->value == 'S' && buf->pnext->value == 'c') {
show_col(c, arg);
}
cmd_multiplier = 0;
update(TRUE);
break;
}
// shift range or cell
case 's':
{
int p, r = currow, c = curcol, rf = currow, cf = curcol;
if ( (p = is_range_selected()) != -1) {
struct srange * sr = get_range_by_pos(p);
r = sr->tlrow;
c = sr->tlcol;
rf = sr->brrow;
cf = sr->brcol;
}
if ( any_locked_cells(r, c, rf, cf) && (buf->pnext->value == 'h' || buf->pnext->value == 'k') ) {
scerror("Locked cells encountered. Nothing changed");
return;
}
#ifdef UNDO
create_undo_action();
#endif
int ic = cmd_multiplier + 1;
switch (buf->pnext->value) {
case 'j':
fix_marks( (rf - r + 1) * cmd_multiplier, 0, r, maxrow, c, cf);
#ifdef UNDO
save_undo_range_shift(cmd_multiplier, 0, r, c, rf + (rf-r+1) * (cmd_multiplier - 1), cf);
#endif
while (ic--) shift_range(ic, 0, r, c, rf, cf);
break;
case 'k':
fix_marks( -(rf - r + 1) * cmd_multiplier, 0, r, maxrow, c, cf);
yank_area(r, c, rf + (rf-r+1) * (cmd_multiplier - 1), cf, 'a', cmd_multiplier); // keep ents in yanklist for sk
#ifdef UNDO
copy_to_undostruct(r, c, rf + (rf-r+1) * (cmd_multiplier - 1), cf, 'd');
save_undo_range_shift(-cmd_multiplier, 0, r, c, rf + (rf-r+1) * (cmd_multiplier - 1), cf);
#endif
while (ic--) shift_range(-ic, 0, r, c, rf, cf);
#ifdef UNDO
copy_to_undostruct(r, c, rf + (rf-r+1) * (cmd_multiplier - 1), cf, 'a');
#endif
break;
case 'h':
fix_marks(0, -(cf - c + 1) * cmd_multiplier, r, rf, c, maxcol);
yank_area(r, c, rf, cf + (cf-c+1) * (cmd_multiplier - 1), 'a', cmd_multiplier); // keep ents in yanklist for sk
#ifdef UNDO
copy_to_undostruct(r, c, rf, cf + (cf-c+1) * (cmd_multiplier - 1), 'd');
save_undo_range_shift(0, -cmd_multiplier, r, c, rf, cf + (cf-c+1) * (cmd_multiplier - 1));
#endif
while (ic--) shift_range(0, -ic, r, c, rf, cf);
#ifdef UNDO
copy_to_undostruct(r, c, rf, cf + (cf-c+1) * (cmd_multiplier - 1), 'a');
#endif
break;
case 'l':
fix_marks(0, (cf - c + 1) * cmd_multiplier, r, rf, c, maxcol);
#ifdef UNDO
save_undo_range_shift(0, cmd_multiplier, r, c, rf, cf + (cf-c+1) * (cmd_multiplier - 1));
#endif
while (ic--) shift_range(0, ic, r, c, rf, cf);
break;
}
#ifdef UNDO
end_undo_action();
#endif
cmd_multiplier = 0;
unselect_ranges();
update(TRUE);
break;
}
// delete row or column, or selected cell or range
case 'd':
{
if (bs != 2) return;
int ic = cmd_multiplier; // orig
if (buf->pnext->value == 'r') {
if (any_locked_cells(currow, 0, currow + cmd_multiplier, maxcol)) {
scerror("Locked cells encountered. Nothing changed");
return;
}
#ifdef UNDO
create_undo_action();
copy_to_undostruct(currow, 0, currow + ic - 1, maxcol, 'd');
save_undo_range_shift(-ic, 0, currow, 0, currow - 1 + ic, maxcol);
#endif
fix_marks(-ic, 0, currow + ic - 1, maxrow, 0, maxcol);
yank_area(currow, 0, currow - 1 + cmd_multiplier, maxcol, 'r', ic);
while (ic--) deleterow();
#ifdef UNDO
copy_to_undostruct(currow, 0, currow - 1 + cmd_multiplier, maxcol, 'a');
end_undo_action();
#endif
if (cmd_multiplier > 0) cmd_multiplier = 0;
} else if (buf->pnext->value == 'c') {
if (any_locked_cells(0, curcol, maxrow, curcol + cmd_multiplier)) {
scerror("Locked cells encountered. Nothing changed");
return;
}
#ifdef UNDO
create_undo_action();
copy_to_undostruct(0, curcol, maxrow, curcol - 1 + ic, 'd');
save_undo_range_shift(0, -ic, 0, curcol, maxrow, curcol - 1 + ic);
#endif
fix_marks(0, -ic, 0, maxrow, curcol - 1 + ic, maxcol);
yank_area(0, curcol, maxrow, curcol + cmd_multiplier - 1, 'c', ic);
while (ic--) deletecol();
#ifdef UNDO
copy_to_undostruct(0, curcol, maxrow, curcol + cmd_multiplier - 1, 'a');
end_undo_action();
#endif
if (cmd_multiplier > 0) cmd_multiplier = 0;
} else if (buf->pnext->value == 'd') {
del_selected_cells();
}
update(TRUE);
break;
}
// insert row or column
case 'i':
{
if (bs != 2) return;
#ifdef UNDO
create_undo_action();
#endif
if (buf->pnext->value == 'r') {
#ifdef UNDO
save_undo_range_shift(1, 0, currow, 0, currow, maxcol);
#endif
fix_marks(1, 0, currow, maxrow, 0, maxcol);
insert_row(0);
} else if (buf->pnext->value == 'c') {
#ifdef UNDO
save_undo_range_shift(0, 1, 0, curcol, maxrow, curcol);
#endif
fix_marks(0, 1, 0, maxrow, curcol, maxcol);
insert_col(0);
}
#ifdef UNDO
end_undo_action();
#endif
update(TRUE);
break;
}
case 'y':
// yank row
if ( bs == 2 && buf->pnext->value == 'r') {
yank_area(currow, 0, currow + cmd_multiplier - 1, maxcol, 'r', cmd_multiplier);
if (cmd_multiplier > 0) cmd_multiplier = 0;
// yank col
} else if ( bs == 2 && buf->pnext->value == 'c') {
yank_area(0, curcol, maxrow, curcol + cmd_multiplier - 1, 'c', cmd_multiplier);
if (cmd_multiplier > 0) cmd_multiplier = 0;
// yank cell
} else if ( bs == 2 && buf->pnext->value == 'y' && is_range_selected() == -1) {
yank_area(currow, curcol, currow, curcol, 'e', cmd_multiplier);
// yank range
} else if ( bs == 1 && is_range_selected() != -1) {
srange * r = get_selected_range();
yank_area(r->tlrow, r->tlcol, r->brrow, r->brcol, 'a', cmd_multiplier);
}
break;
// paste cell below or left
case 'p':
if (paste_yanked_ents(0, 'a') == -1) {
scerror("Locked cells encountered. Nothing changed");
break;
}
update(TRUE);
break;
case 'P':
case 'T':
if (bs != 2) break;
if (buf->pnext->value == 'v' || buf->pnext->value == 'f' || buf->pnext->value == 'c') {
int res = buf->value == 'P' ? paste_yanked_ents(0, buf->pnext->value) : paste_yanked_ents(1, buf->pnext->value); // paste cell above or right
if (res == -1) {
scerror("Locked cells encountered. Nothing changed");
break;
}
update(TRUE);
}
break;
// paste cell above or right
case 't':
if (paste_yanked_ents(1, 'a') == -1) {
scerror("Locked cells encountered. Nothing changed");
break;
}
update(TRUE);
break;
// select inner range - Vir
case 'V':
if (buf->value == 'V' && bs == 3 &&
buf->pnext->value == 'i' && buf->pnext->pnext->value == 'r') {
int tlrow = currow;
int brrow = currow;
int tlcol = curcol;
int brcol = curcol;
int * tlr = &tlrow;
int * brr = &brrow;
int * tlc = &tlcol;
int * brc = &brcol;
select_inner_range(tlr, tlc, brr, brc);
start_visualmode(*tlr, *tlc, *brr, *brc);
}
break;
// autojus
case 'a':
if ( bs != 2 ) break;
if (buf->pnext->value == 'a') {
int p, r = currow, c = curcol, rf = currow, cf = curcol;
if ( (p = is_range_selected()) != -1) {
struct srange * sr = get_range_by_pos(p);
r = sr->tlrow;
c = sr->tlcol;
rf = sr->brrow;
cf = sr->brcol;
}
if (any_locked_cells(r, c, rf, cf)) {
scerror("Locked cells encountered. Nothing changed");
return;
}
char cline [BUFFERSIZE];
sprintf(cline, "autojus %s:", coltoa(c));
sprintf(cline + strlen(cline), "%s", coltoa(cf));
send_to_interp(cline);
update(TRUE);
}
break;
// scroll
case 'z':
if ( bs != 2 ) break;
int scroll = 0;
switch (buf->pnext->value) {
case 'l':
scroll_right(1);
//unselect_ranges();
break;
case 'h':
scroll_left(1);
//unselect_ranges();
break;
case 'H':
scroll = calc_offscr_sc_cols();
if (atoi(get_conf_value("half_page_scroll"))) scroll /= 2;
scroll_left(scroll);
//unselect_ranges();
break;
case 'L':
scroll = calc_offscr_sc_cols();
if (atoi(get_conf_value("half_page_scroll"))) scroll /= 2;
scroll_right(scroll);
//unselect_ranges();
break;
case 'm':
;
int i = 0, c = 0, ancho = rescol;
offscr_sc_cols = 0;
for (i = 0; i < curcol; i++) {
for (c = i; c < curcol; c++) {
if (!col_hidden[c]) ancho += fwidth[c];
if (ancho >= (COLS - rescol)/ 2) {
ancho = rescol;
break;
}
}
if (c == curcol) break;
}
offscr_sc_cols = i;
break;
case 'z':
case '.':
case 't':
case 'b':
if (buf->pnext->value == 'z' || buf->pnext->value == '.')
scroll = currow - offscr_sc_rows + LINES - RESROW - 2 - (LINES - RESROW - 2)/2; // zz
else if (buf->pnext->value == 't')
scroll = currow - offscr_sc_rows + 1;
else if (buf->pnext->value == 'b')
scroll = currow - offscr_sc_rows - LINES + RESROW + 2;
if (scroll > 0)
scroll_down(scroll);
// else if (scroll > offscr_sc_rows)
// scroll_up(-scroll);
else if (scroll < 0)
scroll_up(-scroll);
// else if (offscr_sc_rows > 0)
// scroll_up(offscr_sc_rows);
break;
}
update(TRUE);
break;
// scroll up a line
case ctl('y'):
scroll_up(1);
update(TRUE);
break;
// scroll down a line
case ctl('e'):
scroll_down(1);
update(TRUE);
break;
// undo
case 'u':
#ifdef UNDO
do_undo();
// sync_refs();
EvalAll();
update(TRUE);
break;
#else
scerror("Build was done without UNDO support");
#endif
// redo
case ctl('r'):
#ifdef UNDO
do_redo();
// sync_refs();
EvalAll();
update(TRUE);
break;
#else
scerror("Build was done without UNDO support");
#endif
case '{': // left align
case '}': // right align
case '|': // center align
{
int p, r = currow, c = curcol, rf = currow, cf = curcol;
struct srange * sr;
if ( (p = is_range_selected()) != -1) {
sr = get_range_by_pos(p);
r = sr->tlrow;
c = sr->tlcol;
rf = sr->brrow;
cf = sr->brcol;
}
if (any_locked_cells(r, c, rf, cf)) {
scerror("Locked cells encountered. Nothing changed");
return;
}
#ifdef UNDO
create_undo_action();
#endif
if (buf->value == '{') sprintf(interp_line, "leftjustify %s", v_name(r, c));
else if (buf->value == '}') sprintf(interp_line, "rightjustify %s", v_name(r, c));
else if (buf->value == '|') sprintf(interp_line, "center %s", v_name(r, c));
if (p != -1) sprintf(interp_line + strlen(interp_line), ":%s", v_name(rf, cf));
#ifdef UNDO
copy_to_undostruct(r, c, rf, cf, 'd');
#endif
send_to_interp(interp_line);
#ifdef UNDO
copy_to_undostruct(r, c, rf, cf, 'a');
end_undo_action();
#endif
cmd_multiplier = 0;
update(TRUE);
break;
}
case ctl('l'):
/*
endwin();
start_screen();
clearok(stdscr, TRUE);
update(TRUE);
flushinp();
show_header(input_win);
show_celldetails(input_win);
wrefresh(input_win);
update(TRUE);
*/
winchg();
break;
case '@':
EvalAll();
update(TRUE);
break;
// increase or decrease numeric value of cell or range
case '-':
case '+':
{
int r, c, tlrow = currow, tlcol = curcol, brrow = currow, brcol = curcol;
if ( is_range_selected() != -1 ) {
struct srange * sr = get_selected_range();
tlrow = sr->tlrow;
tlcol = sr->tlcol;
brrow = sr->brrow;
brcol = sr->brcol;
}
if (any_locked_cells(tlrow, tlcol, brrow, brcol)) {
scerror("Locked cells encountered. Nothing changed");
return;
}
if (atoi(get_conf_value("numeric")) == 1) goto numeric;
struct ent * p;
#ifdef UNDO
create_undo_action();
#endif
int arg = cmd_multiplier;
int mf = modflg; // keep original modflg
for (r = tlrow; r <= brrow; r++) {
for (c = tlcol; c <= brcol; c++) {
p = *ATBL(tbl, r, c);
if ( ! p ) {
continue;
} else if (p->expr && !(p->flags & is_strexpr)) {
//scerror("Can't increment / decrement a formula");
continue;
} else if (p->flags & is_valid) {
#ifdef UNDO
copy_to_undostruct(r, c, r, c, 'd');
#endif
p->v += buf->value == '+' ? (double) arg : - 1 * (double) arg;
#ifdef UNDO
copy_to_undostruct(r, c, r, c, 'a');
#endif
if (mf == modflg) modflg++; // increase just one time
}
}
}
#ifdef UNDO
end_undo_action();
#endif
if (atoi(get_conf_value("autocalc"))) EvalAll();
cmd_multiplier = 0;
update(TRUE);
}
break;
// input of numbers
default:
numeric:
if ( (isdigit(buf->value) || buf->value == '-' || buf->value == '+') &&
atoi(get_conf_value("numeric")) ) {
insert_edit_submode='=';
chg_mode(insert_edit_submode);
inputline_pos = 0;
ins_in_line(buf->value);
show_header(input_win);
}
}
return;
}
int mailimf_string_write(FILE * f, int * col,
const char * str, size_t length)
{
int r;
size_t count;
const char * block_begin;
const char * p;
int done;
p = str;
block_begin = str;
count = 0;
while (length > 0) {
#ifdef CUT_AT_MAX_VALID_IMF_LINE
if (count >= 998) {
/*
cut lines at maximum valid length for internet message
format standard (currently RFC 2822)
This should not happen.
In case there are some lines larger than 998 in body,
the encoding must be changed into base64 or quoted-printable
so that wrapping to 72 columns is done.
*/
r = flush_buf(f, block_begin, count);
if (r != MAILIMF_NO_ERROR)
return r;
r = fwrite(CRLF, 1, sizeof(CRLF) - 1, f);
if (r == 0)
return MAILIMF_ERROR_FILE;
count = 0;
block_begin = p;
* col = 0;
}
#endif
switch (* p) {
case '\n':
r = flush_buf(f, block_begin, count);
if (r != MAILIMF_NO_ERROR)
return r;
r = fwrite(CRLF, 1, sizeof(CRLF) - 1, f);
if (r == 0)
return MAILIMF_ERROR_FILE;
p ++;
length --;
count = 0;
block_begin = p;
* col = 0;
break;
case '\r':
done = 0;
if (length >= 2) {
if (* (p + 1) == '\n') {
r = flush_buf(f, block_begin, count);
if (r != MAILIMF_NO_ERROR)
return r;
r = fwrite(CRLF, 1, sizeof(CRLF) - 1, f);
if (r == 0)
return MAILIMF_ERROR_FILE;
p += 2;
length -= 2;
count = 0;
block_begin = p;
* col = 0;
done = 1;
}
}
if (!done) {
r = flush_buf(f, block_begin, count);
if (r != MAILIMF_NO_ERROR)
return r;
r = fwrite(CRLF, 1, sizeof(CRLF) - 1, f);
if (r == 0)
return MAILIMF_ERROR_FILE;
p ++;
length --;
count = 0;
block_begin = p;
* col = 0;
}
break;
default:
p ++;
count ++;
length --;
break;
}
}
r = flush_buf(f, block_begin, count);
if (r != MAILIMF_NO_ERROR)
return r;
* col += count;
return MAILIMF_NO_ERROR;
}
int main(int argc , char **argv )
{
struct sigaction act ;
sigset_t mask ;
sigset_t oldmask ;
struct rlimit rlim ;
struct timespec timeout ;
char const *output_dir ;
char filename[4096] ;
int sfd ;
int dfd ;
int ufd ;
DIR *proc ;
int statfd ;
int diskfd ;
int procfd ;
char statbuf[524288] ;
char diskbuf[524288] ;
char procbuf[524288] ;
size_t statlen ;
size_t disklen ;
size_t proclen ;
unsigned long reltime ;
int arg ;
int rel ;
int tmp ;
unsigned long hz ;
char *endptr ;
int tmp___0 ;
int tmp___1 ;
int tmp___2 ;
char uptime[80] ;
size_t uptimelen ;
unsigned long u ;
int tmp___3 ;
int tmp___4 ;
int tmp___5 ;
int tmp___6 ;
int *tmp___7 ;
int tmp___8 ;
int tmp___9 ;
int tmp___10 ;
int tmp___11 ;
int tmp___12 ;
int tmp___13 ;
int tmp___14 ;
int tmp___15 ;
int tmp___16 ;
int tmp___17 ;
int tmp___18 ;
{
#line 227
output_dir = ".";
#line 233
statlen = (size_t )0;
#line 233
disklen = (size_t )0;
#line 233
proclen = (size_t )0;
#line 234
reltime = 0UL;
#line 235
arg = 1;
#line 235
rel = 0;
#line 237
if (argc > arg) {
{
#line 237
tmp = strcmp((char const *)*(argv + arg), "-r");
}
#line 237
if (! tmp) {
#line 238
rel = 1;
#line 239
arg ++;
}
}
#line 242
if (argc <= arg) {
{
#line 243
fprintf((FILE */* __restrict */)stderr, (char const */* __restrict */)"Usage: %s [-r] HZ [DIR]\n",
*(argv + 0));
#line 244
exit(1);
}
}
#line 247
if (argc > arg) {
{
#line 251
hz = strtoul((char const */* __restrict */)*(argv + arg), (char **/* __restrict */)(& endptr),
10);
}
#line 252
if (*endptr) {
{
#line 253
fprintf((FILE */* __restrict */)stderr, (char const */* __restrict */)"%s: HZ not an integer\n",
*(argv + 0));
#line 254
exit(1);
}
}
#line 257
if (hz > 1UL) {
#line 258
timeout.tv_sec = (__time_t )0;
#line 259
timeout.tv_nsec = (__syscall_slong_t )(1000000000UL / hz);
} else {
#line 261
timeout.tv_sec = (__time_t )1;
#line 262
timeout.tv_nsec = (__syscall_slong_t )0;
}
#line 265
arg ++;
}
#line 268
if (argc > arg) {
#line 269
output_dir = (char const *)*(argv + arg);
#line 270
arg ++;
}
{
#line 274
sigemptyset(& mask);
#line 275
sigaddset(& mask, 15);
#line 276
sigaddset(& mask, 2);
#line 278
tmp___0 = sigprocmask(0, (sigset_t const */* __restrict */)(& mask), (sigset_t */* __restrict */)(& oldmask));
}
#line 278
if (tmp___0 < 0) {
{
#line 279
perror("sigprocmask");
#line 280
exit(1);
}
}
{
#line 283
act.__sigaction_handler.sa_handler = & sig_handler;
#line 284
act.sa_flags = 0;
#line 285
sigemptyset(& act.sa_mask);
#line 287
tmp___1 = sigaction(15, (struct sigaction const */* __restrict */)(& act), (struct sigaction */* __restrict */)((void *)0));
}
#line 287
if (tmp___1 < 0) {
{
#line 288
perror("sigaction SIGTERM");
#line 289
exit(1);
}
}
{
#line 292
tmp___2 = sigaction(2, (struct sigaction const */* __restrict */)(& act), (struct sigaction */* __restrict */)((void *)0));
}
#line 292
if (tmp___2 < 0) {
{
#line 293
perror("sigaction SIGINT");
#line 294
exit(1);
}
}
{
#line 298
chdir("/");
#line 301
rlim.rlim_cur = (__rlim_t )-1;
#line 302
rlim.rlim_max = (__rlim_t )-1;
#line 304
setrlimit(4, (struct rlimit const *)(& rlim));
#line 307
proc = opendir("/proc");
}
#line 308
if (! proc) {
{
#line 309
perror("opendir /proc");
#line 310
exit(1);
}
}
{
#line 313
sfd = open("/proc/stat", 0);
}
#line 314
if (sfd < 0) {
{
#line 315
perror("open /proc/stat");
#line 316
exit(1);
}
}
{
#line 319
dfd = open("/proc/diskstats", 0);
}
#line 320
if (dfd < 0) {
{
#line 321
perror("open /proc/diskstats");
#line 322
exit(1);
}
}
{
#line 325
ufd = open("/proc/uptime", 0);
}
#line 326
if (ufd < 0) {
{
#line 327
perror("open /proc/uptime");
#line 328
exit(1);
}
}
{
#line 332
sprintf((char */* __restrict */)(filename), (char const */* __restrict */)"%s/proc_stat.log",
output_dir);
#line 333
statfd = open((char const *)(filename), 577, 420);
}
#line 334
if (statfd < 0) {
{
#line 335
perror("open proc_stat.log");
#line 336
exit(1);
}
}
{
#line 339
sprintf((char */* __restrict */)(filename), (char const */* __restrict */)"%s/proc_diskstats.log",
output_dir);
#line 340
diskfd = open((char const *)(filename), 577, 420);
}
#line 341
if (diskfd < 0) {
{
#line 342
perror("open proc_diskstats.log");
#line 343
exit(1);
}
}
{
#line 346
sprintf((char */* __restrict */)(filename), (char const */* __restrict */)"%s/proc_ps.log",
output_dir);
#line 347
procfd = open((char const *)(filename), 577, 420);
}
#line 348
if (procfd < 0) {
{
#line 349
perror("open proc_ps.log");
#line 350
exit(1);
}
}
#line 354
if (rel) {
{
#line 355
reltime = get_uptime(ufd);
}
#line 356
if (! reltime) {
{
#line 357
exit(1);
}
}
}
{
#line 360
while (1) {
while_continue: /* CIL Label */ ;
{
#line 365
u = get_uptime(ufd);
}
#line 366
if (! u) {
{
#line 367
exit(1);
}
}
{
#line 369
tmp___3 = sprintf((char */* __restrict */)(uptime), (char const */* __restrict */)"%lu\n",
u - reltime);
#line 369
uptimelen = (size_t )tmp___3;
#line 372
tmp___4 = read_file(sfd, (char const *)(uptime), uptimelen, statfd, statbuf,
& statlen);
}
#line 372
if (tmp___4 < 0) {
{
#line 374
exit(1);
}
}
{
#line 376
tmp___5 = read_file(dfd, (char const *)(uptime), uptimelen, diskfd, diskbuf,
& disklen);
}
#line 376
if (tmp___5 < 0) {
{
#line 378
exit(1);
}
}
{
#line 380
tmp___6 = read_proc(proc, (char const *)(uptime), uptimelen, procfd, procbuf,
& proclen);
}
#line 380
if (tmp___6 < 0) {
{
#line 382
exit(1);
}
}
{
#line 384
tmp___8 = pselect(0, (fd_set */* __restrict */)((void *)0), (fd_set */* __restrict */)((void *)0),
(fd_set */* __restrict */)((void *)0), (struct timespec const */* __restrict */)(& timeout),
(__sigset_t const */* __restrict */)(& oldmask));
}
#line 384
if (tmp___8 < 0) {
{
#line 385
tmp___7 = __errno_location();
}
#line 385
if (*tmp___7 == 4) {
#line 386
goto while_break;
} else {
{
#line 388
perror("pselect");
#line 389
exit(1);
}
}
}
}
while_break: /* CIL Label */ ;
}
{
#line 395
tmp___9 = flush_buf(statfd, statbuf, & statlen);
}
#line 395
if (tmp___9 < 0) {
{
#line 396
exit(1);
}
}
{
#line 397
tmp___10 = close(statfd);
}
#line 397
if (tmp___10 < 0) {
{
#line 398
perror("close proc_stat.log");
#line 399
exit(1);
}
}
{
#line 402
tmp___11 = flush_buf(diskfd, diskbuf, & disklen);
}
#line 402
if (tmp___11 < 0) {
{
#line 403
exit(1);
}
}
{
#line 404
tmp___12 = close(diskfd);
}
#line 404
if (tmp___12 < 0) {
{
#line 405
perror("close proc_diskstats.log");
#line 406
exit(1);
}
}
{
#line 409
tmp___13 = flush_buf(procfd, procbuf, & proclen);
}
#line 409
if (tmp___13 < 0) {
{
#line 410
exit(1);
}
}
{
#line 411
tmp___14 = close(procfd);
}
#line 411
if (tmp___14 < 0) {
{
#line 412
perror("close proc_ps.log");
#line 413
exit(1);
}
}
{
#line 417
tmp___15 = close(ufd);
}
#line 417
if (tmp___15 < 0) {
{
#line 418
perror("close /proc/uptime");
#line 419
exit(1);
}
}
{
#line 422
tmp___16 = close(dfd);
}
#line 422
if (tmp___16 < 0) {
{
#line 423
perror("close /proc/diskstats");
#line 424
exit(1);
}
}
{
#line 427
tmp___17 = close(sfd);
}
#line 427
if (tmp___17 < 0) {
{
#line 428
perror("close /proc/stat");
#line 429
exit(1);
}
}
{
#line 432
tmp___18 = closedir(proc);
}
#line 432
if (tmp___18 < 0) {
{
#line 433
perror("close /proc");
#line 434
exit(1);
}
}
#line 437
return (0);
}
}
