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);
}
