static size_t One_Char_mbtowc(__Char *pwc, const Char *s, size_t n) { #ifdef WIDE_STRINGS char buf[MB_LEN_MAX], *p; if (n > MB_LEN_MAX) n = MB_LEN_MAX; p = buf; while (p < buf + n && (*p++ = LCHAR(*s++)) != 0) ; return one_mbtowc(pwc, buf, n); #else *pwc = *s & CHAR; return 1; #endif }
/* * pattern matching function for filenames. Each occurrence of the * * pattern causes a recursion level. */ static int match(const char *name, const Char *pat, const Char *patend, int m_not) { int ok, negate_range; Char c; while (pat < patend) { size_t lwk; __Char wc, wk; c = *pat; /* Only for M_MASK bits */ pat += One_Char_mbtowc(&wc, pat, MB_LEN_MAX); lwk = one_mbtowc(&wk, name, MB_LEN_MAX); switch (c & M_MASK) { case M_ALL: while (pat < patend && (*pat & M_MASK) == M_ALL) /* eat consecutive '*' */ pat += One_Char_mbtowc(&wc, pat, MB_LEN_MAX); if (pat == patend) return (1); while (!match(name, pat, patend, m_not)) { if (*name == EOS) return (0); name += lwk; lwk = one_mbtowc(&wk, name, MB_LEN_MAX); } return (1); case M_ONE: if (*name == EOS) return (0); name += lwk; break; case M_SET: ok = 0; if (*name == EOS) return (0); name += lwk; if ((negate_range = ((*pat & M_MASK) == m_not)) != 0) ++pat; while ((*pat & M_MASK) != M_END) { pat += One_Char_mbtowc(&wc, pat, MB_LEN_MAX); if ((*pat & M_MASK) == M_RNG) { __Char wc2; pat++; pat += One_Char_mbtowc(&wc2, pat, MB_LEN_MAX); if (globcharcoll(wc, wk, 0) <= 0 && globcharcoll(wk, wc2, 0) <= 0) ok = 1; } else if (wc == wk) ok = 1; } pat += One_Char_mbtowc(&wc, pat, MB_LEN_MAX); if (ok == negate_range) return (0); break; default: if (*name == EOS || samecase(wk) != samecase(wc)) return (0); name += lwk; break; } } return (*name == EOS); }
void vt_out(struct term_t *pwin, unsigned int ch) { int f; unsigned char c; int go_on = 0; wchar_t wc; term_t *win; win = (term_t *)pwin; if (!ch) return; c = (unsigned char)ch; if (win->state.vt_docap == 2) /* Literal. */ fputc(c, win->state.capfp); /* Process <31 chars first, even in an escape sequence. */ switch (c) { case '\r': /* Carriage return */ term_wputc(win, c); if (win->state.vt_addlf) { term_wputc(win, '\n'); if (win->state.vt_docap == 1) fputc('\n', win->state.capfp); } break; case '\t': /* Non - destructive TAB */ // printf("tab pants\n"); /* Find next tab stop. */ for (f = win->cursor_x + 1; f < 160; f++) if (win->state.vt_tabs[f / 32] & (1 << f % 32)) break; if (f >= win->W) f = win->W - 1; term_wlocate(win, f, win->cursor_y); if (win->state.vt_docap == 1) fputc(c, win->state.capfp); break; case 013: /* Old Minix: CTRL-K = up */ term_wlocate(win, win->cursor_x, win->cursor_y - 1); break; case '\f': /* Form feed: clear screen. */ term_winclr(win); term_wlocate(win, 0, 0); break; case 14: break; case 15: break; case 24: case 26: /* Cancel escape sequence. */ esc_s = 0; break; case ESC: /* Begin escape sequence */ esc_s = 1; break; case 128+ESC: /* Begin ESC [ sequence. */ esc_s = 2; break; case '\n': case '\b': case 7: /* Bell */ term_wputc(win, c); if (win->state.vt_docap == 1) fputc(c, win->state.capfp); break; default: go_on = 1; break; } if (!go_on) return; /* Now see which state we are in. */ switch (esc_s) { case 0: /* Normal character */ /* XXX:mappers */ c&=0xff; if (!win->state.enable_iconv) { one_mbtowc ((char *)&wc, (char *)&c, 1); if (win->state.vt_insert) term_winschar(win, wc, 1); else term_wputc(win, wc); } else term_wputc(win, c); break; case 1: /* ESC seen */ state1(win, c); break; case 2: /* ESC [ ... seen */ state2(win, c); break; case 3: state3(win, c); break; case 4: state4(win, c); break; case 5: state5(win, c); break; case 6: state6(win, c); break; case 7: state7(win,c); break; } }
/* * Initialize new file directory. * * Sets the current working directory. Non-0 return = no change. */ static int new_filedir(GETSDIR_ENTRY *dirdat, int flushit) { static size_t dp_len = 0; static char cwd_str_fmt[BUFSIZ] = ""; size_t new_dp_len, fmt_len; char disp_dir[80]; int initial_y = (76 - (WHAT_NR_OPTIONS * WHAT_WIDTH >= 76 ? 74 : WHAT_NR_OPTIONS * WHAT_WIDTH)) / 2; size_t i; char * new_prev_dir; cur = 0; ocur = 0; subm = SUBM_OKAY; quit = 0; top = 0; c = 0; pgud = 0; first = 1; min_len = 1; dprev = -1; tag_cnt = 0; /* * get last directory */ work_dir = down_loading ? d_work_dir : u_work_dir; /* * init working directory to default? */ if (work_dir == NULL) { char *s = down_loading? P_DOWNDIR : P_UPDIR; min_len = 1; if (*s != '/') min_len += strlen(homedir) + 1; min_len += strlen(s); if (min_len < BUFSIZ) min_len = BUFSIZ; work_dir = set_work_dir(NULL, min_len); if (*s == '/') strncpy(work_dir, s, min_len); else snprintf(work_dir, min_len, "%s/%s", homedir, s); } /* lop-off trailing "/" for consistency */ if (strlen(work_dir) > 1 && work_dir[strlen(work_dir) - 1] == '/') work_dir[strlen(work_dir) - 1] = (char)0; /* get the current working directory, which will become the prev_dir, on success */ new_prev_dir = getcwd(NULL, BUFSIZ); if (!new_prev_dir) return -1; if (!access(work_dir, R_OK | X_OK) && !chdir(work_dir)) { /* was able to change to new working directory */ free(prev_dir); prev_dir = new_prev_dir; } else { /* Could not change to the new working directory */ mc_wbell(); werror( _("Could not change to directory %s (%s)"), work_dir, strerror(errno)); /* restore the previous working directory */ free(work_dir); work_dir = set_work_dir(new_prev_dir, strlen(new_prev_dir)); } /* All right, draw the file directory! */ if (flushit) { dirflush = 0; mc_winclr(main_w); mc_wredraw(main_w, 1); } mc_wcursor(main_w, CNORMAL); { char *s; if (down_loading) { if (how_many < 0) s = _("Select one or more files for download"); else if (how_many) s = _("Select a file for download"); else s = _("Select a directory for download"); } else { if (how_many < 0) s = _("Select one or more files for upload"); else if (how_many) s = _("Select a file for upload"); else s = _("Select a directory for upload"); } snprintf(file_title, sizeof(file_title), "%s", s); } mc_wtitle(main_w, TMID, file_title); if ((new_dp_len = strlen(work_dir)) > dp_len) { dp_len = new_dp_len; snprintf(cwd_str_fmt, sizeof(cwd_str_fmt), _("Directory: %%-%ds"), (int)dp_len); } new_dp_len = mbslen (work_dir); if (new_dp_len + (fmt_len = mbslen(cwd_str_fmt)) > 75) { size_t i; char *tmp_dir = work_dir; /* We want the last 73 characters */ for (i = 0; 73 + i < new_dp_len + fmt_len; i++) { wchar_t wc; tmp_dir += one_mbtowc(&wc, work_dir, MB_LEN_MAX); } snprintf(disp_dir, sizeof(disp_dir), "...%s", tmp_dir); snprintf(cwd_str, sizeof(cwd_str), cwd_str_fmt, disp_dir); } else snprintf(cwd_str, sizeof(cwd_str), cwd_str_fmt, work_dir); mc_wlocate(main_w, 0, 0); mc_wputs(main_w, cwd_str); for (i = 0; i < WHAT_NR_OPTIONS; i++) { const char *str, *c; size_t j; str = _(what[i]); c = str; for (j = 0; j < WHAT_WIDTH - 1 && *c != 0; j++) { wchar_t wc; c += one_mbtowc (&wc, c, MB_LEN_MAX); } what_lens[i] = c - str; j = WHAT_WIDTH - j; /* Characters left for padding */ what_padding[i][1] = j / 2; /* Rounding down */ what_padding[i][0] = j - what_padding[i][1]; /* >= 1 */ } mc_wlocate(dsub, initial_y, 0); for (i = 0; i < WHAT_NR_OPTIONS; i++) horiz_draw(i, mc_wgetattr(dsub), mc_wgetattr(dsub)); mc_wsetregion(main_w, 1, main_w->ys - FILE_MWTR); main_w->doscroll = 0; /* old dir to discard? */ free(dirdat); dirdat = NULL; /* get sorted directory */ if ((nrents = getsdir(".", wc_str, GETSDIR_PARNT|GETSDIR_NSORT|GETSDIR_DIRSF, 0, &dirdat, &longest)) < 0) { /* we really want to announce the error here!!! */ mc_wclose(main_w, 1); mc_wclose(dsub, 1); free(dirdat); dirdat = NULL; return -1; } global_dirdat = dirdat; // Hmm... prdir(main_w, top, top, dirdat, longest); mc_wlocate(main_w, initial_y, main_w->ys - FILE_MWTR); mc_wputs(main_w, _("( Escape to exit, Space to tag )")); dhili(subm); /* this really needs to go in dhili !!!*/ mc_wlocate(main_w, 0, cur + FILE_MWTR - top); if (flushit) { dirflush = 1; mc_wredraw(dsub, 1); } return 0; }
void vt_out(int ch) { static unsigned char last_ch; int f; unsigned char c; int go_on = 0; wchar_t wc; if (!ch) return; if (last_ch == '\n' && vt_line_timestamp != TIMESTAMP_LINE_OFF) { struct timeval tmstmp_now; static time_t tmstmp_last; char s[36]; struct tm tmstmp_tm; gettimeofday(&tmstmp_now, NULL); if (( vt_line_timestamp == TIMESTAMP_LINE_PER_SECOND && tmstmp_now.tv_sec != tmstmp_last) || vt_line_timestamp == TIMESTAMP_LINE_SIMPLE || vt_line_timestamp == TIMESTAMP_LINE_EXTENDED) { if ( localtime_r(&tmstmp_now.tv_sec, &tmstmp_tm) && strftime(s, sizeof(s), "[%F %T", &tmstmp_tm)) { output_s(s); switch (vt_line_timestamp) { case TIMESTAMP_LINE_SIMPLE: output_s("] "); break; case TIMESTAMP_LINE_EXTENDED: snprintf(s, sizeof(s), ".%03ld] ", tmstmp_now.tv_usec / 1000); output_s(s); break; case TIMESTAMP_LINE_PER_SECOND: output_s("\r\n"); break; }; } tmstmp_last = tmstmp_now.tv_sec; } } c = (unsigned char)ch; last_ch = c; if (vt_docap == 2) /* Literal. */ fputc(c, capfp); /* Process <31 chars first, even in an escape sequence. */ switch (c) { case 5: /* AnswerBack for vt100's */ if (vt_type != VT100) { go_on = 1; break; } v_termout(P_ANSWERBACK, 0); break; case '\r': /* Carriage return */ mc_wputc(vt_win, c); if (vt_addlf) output_c('\n'); break; case '\t': /* Non - destructive TAB */ /* Find next tab stop. */ for (f = vt_win->curx + 1; f < 160; f++) if (vt_tabs[f / 32] & (1 << f % 32)) break; if (f >= vt_win->xs) f = vt_win->xs - 1; mc_wlocate(vt_win, f, vt_win->cury); if (vt_docap == 1) fputc(c, capfp); break; case 013: /* Old Minix: CTRL-K = up */ mc_wlocate(vt_win, vt_win->curx, vt_win->cury - 1); break; case '\f': /* Form feed: clear screen. */ mc_winclr(vt_win); mc_wlocate(vt_win, 0, 0); break; #if !TRANSLATE case 14: case 15: /* Change character set. Not supported. */ break; #else case 14: vt_charset = 1; break; case 15: vt_charset = 0; break; #endif case 24: case 26: /* Cancel escape sequence. */ esc_s = 0; break; case ESC: /* Begin escape sequence */ esc_s = 1; break; case 128+ESC: /* Begin ESC [ sequence. */ esc_s = 2; break; case '\n': if(vt_addcr) mc_wputc(vt_win, '\r'); output_c(c); break; case '\b': case 7: /* Bell */ output_c(c); break; default: go_on = 1; break; } if (!go_on) return; /* Now see which state we are in. */ switch (esc_s) { case 0: /* Normal character */ if (vt_docap == 1) fputc(P_CONVCAP[0] == 'Y' ? vt_inmap[c] : c, capfp); if (!using_iconv()) { c = vt_inmap[c]; /* conversion 04.09.97 / jl */ #if TRANSLATE if (vt_type == VT100 && vt_trans[vt_charset] && vt_asis == 0) c = vt_trans[vt_charset][c]; #endif } /* FIXME: This is wrong, but making it right would require * removing all the 8-bit mapping features. Assuming the locale * is 8-bit, the character should not be changed by mapping to * wchar and back; if the locale is multibyte, there is no hope * of getting it right anyway. */ if (!using_iconv()) { one_mbtowc (&wc, (char *)&c, 1); /* returns 1 */ if (vt_insert) mc_winschar2(vt_win, wc, 1); else mc_wputc(vt_win, wc); } else { mc_wputc(vt_win, c); } break; case 1: /* ESC seen */ state1(c); break; case 2: /* ESC [ ... seen */ state2(c); break; case 3: state3(c); break; case 4: state4(c); break; case 5: state5(c); break; case 6: state6(c); break; case 7: state7(c); break; } /* Flush output to capture file so that all output is visible there * immediately. Causes a write syscall for every call though. */ if (capfp) fflush(capfp); }