ul: improve function and variable names
Signed-off-by: Sami Kerola <kerolasa@iki.fi>
This commit is contained in:
Sami Kerola
parent
580c63259b
commit
9a59ee6525
390
text-utils/ul.c
390
text-utils/ul.c
|
|
@ -63,7 +63,7 @@
|
|||
#include "c.h"
|
||||
#include "closestream.h"
|
||||
|
||||
#define IESC '\033'
|
||||
#define ESC '\033'
|
||||
#define SO '\016'
|
||||
#define SI '\017'
|
||||
#define HFWD '9'
|
||||
|
|
@ -71,12 +71,12 @@
|
|||
#define FREV '7'
|
||||
|
||||
enum {
|
||||
NORMAL_CHARSET = 0, /* Must be zero, see initbuf() */
|
||||
NORMAL_CHARSET = 0, /* Must be zero, see initbuf() */
|
||||
ALTERNATIVE_CHARSET = 1 << 0, /* Reverse */
|
||||
SUPERSCRIPT = 1 << 1, /* Dim */
|
||||
SUBSCRIPT = 1 << 2, /* Dim | Ul */
|
||||
UNDERLINE = 1 << 3, /* Ul */
|
||||
BOLD = 1 << 4, /* Bold */
|
||||
SUPERSCRIPT = 1 << 1, /* Dim */
|
||||
SUBSCRIPT = 1 << 2, /* Dim | Ul */
|
||||
UNDERLINE = 1 << 3, /* Ul */
|
||||
BOLD = 1 << 4, /* Bold */
|
||||
};
|
||||
|
||||
struct term_caps {
|
||||
|
|
@ -101,16 +101,16 @@ struct ul_char {
|
|||
};
|
||||
|
||||
struct ul_ctl {
|
||||
int obuflen;
|
||||
int col;
|
||||
int maxcol;
|
||||
int column;
|
||||
int max_column;
|
||||
int half_position;
|
||||
int up_line;
|
||||
int mode;
|
||||
int halfpos;
|
||||
int upln;
|
||||
int curmode;
|
||||
struct ul_char *obuf;
|
||||
int current_mode;
|
||||
int buflen;
|
||||
struct ul_char *buf;
|
||||
unsigned int
|
||||
iflag:1,
|
||||
indicated_opt:1,
|
||||
must_use_uc:1,
|
||||
must_overstrike:1;
|
||||
};
|
||||
|
|
@ -136,53 +136,53 @@ static void __attribute__((__noreturn__)) usage(void)
|
|||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
static void needcol(struct ul_ctl *ctl, int acol)
|
||||
static void need_column(struct ul_ctl *ctl, int new_max)
|
||||
{
|
||||
ctl->maxcol = acol;
|
||||
ctl->max_column = new_max;
|
||||
|
||||
/* If col >= obuflen, expand obuf until obuflen > col. */
|
||||
while (acol >= ctl->obuflen) {
|
||||
/* Paranoid check for obuflen == INT_MAX. */
|
||||
if (ctl->obuflen == INT_MAX)
|
||||
/* If col >= buflen, expand buf until buflen > col. */
|
||||
while (new_max >= ctl->buflen) {
|
||||
/* Paranoid check for buflen == INT_MAX. */
|
||||
if (ctl->buflen == INT_MAX)
|
||||
errx(EXIT_FAILURE, _("Input line too long."));
|
||||
|
||||
/* Similar paranoia: double only up to INT_MAX. */
|
||||
if (ctl->obuflen < (INT_MAX / 2))
|
||||
ctl->obuflen *= 2;
|
||||
if (ctl->buflen < (INT_MAX / 2))
|
||||
ctl->buflen *= 2;
|
||||
else
|
||||
ctl->obuflen = INT_MAX;
|
||||
ctl->buflen = INT_MAX;
|
||||
|
||||
/* Now we can try to expand obuf. */
|
||||
ctl->obuf = xrealloc(ctl->obuf, sizeof(struct ul_char) * ctl->obuflen);
|
||||
/* Now we can try to expand buf. */
|
||||
ctl->buf = xrealloc(ctl->buf, sizeof(struct ul_char) * ctl->buflen);
|
||||
}
|
||||
}
|
||||
|
||||
static void setcol(struct ul_ctl *ctl, int newcol)
|
||||
static void set_column(struct ul_ctl *ctl, int column)
|
||||
{
|
||||
ctl->col = newcol;
|
||||
ctl->column = column;
|
||||
|
||||
if (ctl->col < 0)
|
||||
ctl->col = 0;
|
||||
else if (ctl->col > ctl->maxcol)
|
||||
needcol(ctl, ctl->col);
|
||||
if (ctl->column < 0)
|
||||
ctl->column = 0;
|
||||
else if (ctl->column > ctl->max_column)
|
||||
need_column(ctl, ctl->column);
|
||||
}
|
||||
|
||||
static void initbuf(struct ul_ctl *ctl)
|
||||
static void init_buffer(struct ul_ctl *ctl)
|
||||
{
|
||||
if (ctl->obuf == NULL) {
|
||||
if (ctl->buf == NULL) {
|
||||
/* First time. */
|
||||
ctl->obuflen = BUFSIZ;
|
||||
ctl->obuf = xcalloc(ctl->obuflen, sizeof(struct ul_char));
|
||||
ctl->buflen = BUFSIZ;
|
||||
ctl->buf = xcalloc(ctl->buflen, sizeof(struct ul_char));
|
||||
} else
|
||||
/* assumes NORMAL_CHARSET == 0 */
|
||||
memset(ctl->obuf, 0, sizeof(struct ul_char) * ctl->maxcol);
|
||||
memset(ctl->buf, 0, sizeof(struct ul_char) * ctl->max_column);
|
||||
|
||||
setcol(ctl, 0);
|
||||
ctl->maxcol = 0;
|
||||
set_column(ctl, 0);
|
||||
ctl->max_column = 0;
|
||||
ctl->mode &= ALTERNATIVE_CHARSET;
|
||||
}
|
||||
|
||||
static void initinfo(struct ul_ctl *ctl, struct term_caps *const tcs)
|
||||
static void init_term_caps(struct ul_ctl *ctl, struct term_caps *const tcs)
|
||||
{
|
||||
tcs->curs_up = tigetstr("cuu1");
|
||||
tcs->curs_right = tigetstr("cuf1");
|
||||
|
|
@ -246,97 +246,99 @@ static int ul_putwchar(int c)
|
|||
return c;
|
||||
}
|
||||
|
||||
static void print_out(char *line)
|
||||
static void print_line(char *line)
|
||||
{
|
||||
if (line == NULL)
|
||||
return;
|
||||
tputs(line, STDOUT_FILENO, ul_putwchar);
|
||||
}
|
||||
|
||||
static void xsetmode(struct ul_ctl *ctl, struct term_caps const *const tcs, int newmode)
|
||||
static void ul_setmode(struct ul_ctl *ctl, struct term_caps const *const tcs,
|
||||
int new_mode)
|
||||
{
|
||||
if (!ctl->iflag) {
|
||||
if (ctl->curmode != NORMAL_CHARSET && newmode != NORMAL_CHARSET)
|
||||
xsetmode(ctl, tcs, NORMAL_CHARSET);
|
||||
switch (newmode) {
|
||||
if (!ctl->indicated_opt) {
|
||||
if (ctl->current_mode != NORMAL_CHARSET && new_mode != NORMAL_CHARSET)
|
||||
ul_setmode(ctl, tcs, NORMAL_CHARSET);
|
||||
switch (new_mode) {
|
||||
case NORMAL_CHARSET:
|
||||
switch (ctl->curmode) {
|
||||
switch (ctl->current_mode) {
|
||||
case NORMAL_CHARSET:
|
||||
break;
|
||||
case UNDERLINE:
|
||||
print_out(tcs->exit_underline);
|
||||
print_line(tcs->exit_underline);
|
||||
break;
|
||||
default:
|
||||
/* This includes standout */
|
||||
print_out(tcs->exit_attributes);
|
||||
print_line(tcs->exit_attributes);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case ALTERNATIVE_CHARSET:
|
||||
print_out(tcs->enter_reverse);
|
||||
print_line(tcs->enter_reverse);
|
||||
break;
|
||||
case SUPERSCRIPT:
|
||||
/*
|
||||
* This only works on a few terminals.
|
||||
* It should be fixed.
|
||||
*/
|
||||
print_out(tcs->enter_underline);
|
||||
print_out(tcs->enter_dim);
|
||||
print_line(tcs->enter_underline);
|
||||
print_line(tcs->enter_dim);
|
||||
break;
|
||||
case SUBSCRIPT:
|
||||
print_out(tcs->enter_dim);
|
||||
print_line(tcs->enter_dim);
|
||||
break;
|
||||
case UNDERLINE:
|
||||
print_out(tcs->enter_underline);
|
||||
print_line(tcs->enter_underline);
|
||||
break;
|
||||
case BOLD:
|
||||
print_out(tcs->enter_bold);
|
||||
print_line(tcs->enter_bold);
|
||||
break;
|
||||
default:
|
||||
/*
|
||||
* We should have some provision here for multiple modes
|
||||
* on at once. This will have to come later.
|
||||
*/
|
||||
print_out(tcs->enter_standout);
|
||||
print_line(tcs->enter_standout);
|
||||
break;
|
||||
}
|
||||
}
|
||||
ctl->curmode = newmode;
|
||||
ctl->current_mode = new_mode;
|
||||
}
|
||||
|
||||
static void iattr(struct ul_ctl *ctl)
|
||||
static void indicate_attribute(struct ul_ctl *ctl)
|
||||
{
|
||||
int i;
|
||||
wchar_t *lbuf = xcalloc(ctl->maxcol + 1, sizeof(wchar_t));
|
||||
wchar_t *cp = lbuf;
|
||||
wchar_t *buf = xcalloc(ctl->max_column + 1, sizeof(wchar_t));
|
||||
wchar_t *p = buf;
|
||||
|
||||
for (i = 0; i < ctl->maxcol; i++)
|
||||
switch (ctl->obuf[i].c_mode) {
|
||||
case NORMAL_CHARSET: *cp++ = ' '; break;
|
||||
case ALTERNATIVE_CHARSET: *cp++ = 'g'; break;
|
||||
case SUPERSCRIPT: *cp++ = '^'; break;
|
||||
case SUBSCRIPT: *cp++ = 'v'; break;
|
||||
case UNDERLINE: *cp++ = '_'; break;
|
||||
case BOLD: *cp++ = '!'; break;
|
||||
default: *cp++ = 'X'; break;
|
||||
for (i = 0; i < ctl->max_column; i++)
|
||||
switch (ctl->buf[i].c_mode) {
|
||||
case NORMAL_CHARSET: *p++ = ' '; break;
|
||||
case ALTERNATIVE_CHARSET: *p++ = 'g'; break;
|
||||
case SUPERSCRIPT: *p++ = '^'; break;
|
||||
case SUBSCRIPT: *p++ = 'v'; break;
|
||||
case UNDERLINE: *p++ = '_'; break;
|
||||
case BOLD: *p++ = '!'; break;
|
||||
default: *p++ = 'X'; break;
|
||||
}
|
||||
for (*cp = ' '; *cp == ' '; cp--)
|
||||
*cp = 0;
|
||||
fputws(lbuf, stdout);
|
||||
for (*p = ' '; *p == ' '; p--)
|
||||
*p = 0;
|
||||
fputws(buf, stdout);
|
||||
putwchar('\n');
|
||||
free(lbuf);
|
||||
free(buf);
|
||||
}
|
||||
|
||||
static void outc(struct ul_ctl *ctl, struct term_caps const *const tcs, wint_t c, int width)
|
||||
static void output_char(struct ul_ctl *ctl, struct term_caps const *const tcs,
|
||||
wint_t c, int width)
|
||||
{
|
||||
int i;
|
||||
|
||||
putwchar(c);
|
||||
if (ctl->must_use_uc && (ctl->curmode & UNDERLINE)) {
|
||||
if (ctl->must_use_uc && (ctl->current_mode & UNDERLINE)) {
|
||||
for (i = 0; i < width; i++)
|
||||
print_out(tcs->curs_left);
|
||||
print_line(tcs->curs_left);
|
||||
for (i = 0; i < width; i++)
|
||||
print_out(tcs->under_char);
|
||||
print_line(tcs->under_char);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -347,96 +349,96 @@ static void outc(struct ul_ctl *ctl, struct term_caps const *const tcs, wint_t c
|
|||
static void overstrike(struct ul_ctl *ctl)
|
||||
{
|
||||
int i;
|
||||
wchar_t *lbuf = xcalloc(ctl->maxcol + 1, sizeof(wchar_t));
|
||||
wchar_t *cp = lbuf;
|
||||
int hadbold = 0;
|
||||
wchar_t *buf = xcalloc(ctl->max_column + 1, sizeof(wchar_t));
|
||||
wchar_t *p = buf;
|
||||
int had_bold = 0;
|
||||
|
||||
/* Set up overstrike buffer */
|
||||
for (i = 0; i < ctl->maxcol; i++)
|
||||
switch (ctl->obuf[i].c_mode) {
|
||||
for (i = 0; i < ctl->max_column; i++)
|
||||
switch (ctl->buf[i].c_mode) {
|
||||
case NORMAL_CHARSET:
|
||||
default:
|
||||
*cp++ = ' ';
|
||||
*p++ = ' ';
|
||||
break;
|
||||
case UNDERLINE:
|
||||
*cp++ = '_';
|
||||
*p++ = '_';
|
||||
break;
|
||||
case BOLD:
|
||||
*cp++ = ctl->obuf[i].c_char;
|
||||
if (ctl->obuf[i].c_width > 1)
|
||||
i += ctl->obuf[i].c_width - 1;
|
||||
hadbold = 1;
|
||||
*p++ = ctl->buf[i].c_char;
|
||||
if (ctl->buf[i].c_width > 1)
|
||||
i += ctl->buf[i].c_width - 1;
|
||||
had_bold = 1;
|
||||
break;
|
||||
}
|
||||
putwchar('\r');
|
||||
for (*cp = ' '; *cp == ' '; cp--)
|
||||
*cp = 0;
|
||||
fputws(lbuf, stdout);
|
||||
if (hadbold) {
|
||||
for (*p = ' '; *p == ' '; p--)
|
||||
*p = 0;
|
||||
fputws(buf, stdout);
|
||||
if (had_bold) {
|
||||
putwchar('\r');
|
||||
for (cp = lbuf; *cp; cp++)
|
||||
putwchar(*cp == '_' ? ' ' : *cp);
|
||||
for (p = buf; *p; p++)
|
||||
putwchar(*p == '_' ? ' ' : *p);
|
||||
putwchar('\r');
|
||||
for (cp = lbuf; *cp; cp++)
|
||||
putwchar(*cp == '_' ? ' ' : *cp);
|
||||
for (p = buf; *p; p++)
|
||||
putwchar(*p == '_' ? ' ' : *p);
|
||||
}
|
||||
free(lbuf);
|
||||
free(buf);
|
||||
}
|
||||
|
||||
static void flushln(struct ul_ctl *ctl, struct term_caps const *const tcs)
|
||||
static void flush_line(struct ul_ctl *ctl, struct term_caps const *const tcs)
|
||||
{
|
||||
int lastmode;
|
||||
int last_mode;
|
||||
int i;
|
||||
int hadmodes = 0;
|
||||
int had_mode = 0;
|
||||
|
||||
lastmode = NORMAL_CHARSET;
|
||||
for (i = 0; i < ctl->maxcol; i++) {
|
||||
if (ctl->obuf[i].c_mode != lastmode) {
|
||||
hadmodes++;
|
||||
xsetmode(ctl, tcs, ctl->obuf[i].c_mode);
|
||||
lastmode = ctl->obuf[i].c_mode;
|
||||
last_mode = NORMAL_CHARSET;
|
||||
for (i = 0; i < ctl->max_column; i++) {
|
||||
if (ctl->buf[i].c_mode != last_mode) {
|
||||
had_mode = 1;
|
||||
ul_setmode(ctl, tcs, ctl->buf[i].c_mode);
|
||||
last_mode = ctl->buf[i].c_mode;
|
||||
}
|
||||
if (ctl->obuf[i].c_char == '\0') {
|
||||
if (ctl->upln)
|
||||
print_out(tcs->curs_right);
|
||||
if (ctl->buf[i].c_char == '\0') {
|
||||
if (ctl->up_line)
|
||||
print_line(tcs->curs_right);
|
||||
else
|
||||
outc(ctl, tcs, ' ', 1);
|
||||
output_char(ctl, tcs, ' ', 1);
|
||||
} else
|
||||
outc(ctl, tcs, ctl->obuf[i].c_char, ctl->obuf[i].c_width);
|
||||
if (ctl->obuf[i].c_width > 1)
|
||||
i += ctl->obuf[i].c_width - 1;
|
||||
output_char(ctl, tcs, ctl->buf[i].c_char, ctl->buf[i].c_width);
|
||||
if (ctl->buf[i].c_width > 1)
|
||||
i += ctl->buf[i].c_width - 1;
|
||||
}
|
||||
if (lastmode != NORMAL_CHARSET)
|
||||
xsetmode(ctl, tcs, NORMAL_CHARSET);
|
||||
if (ctl->must_overstrike && hadmodes)
|
||||
if (last_mode != NORMAL_CHARSET)
|
||||
ul_setmode(ctl, tcs, NORMAL_CHARSET);
|
||||
if (ctl->must_overstrike && had_mode)
|
||||
overstrike(ctl);
|
||||
putwchar('\n');
|
||||
if (ctl->iflag && hadmodes)
|
||||
iattr(ctl);
|
||||
if (ctl->indicated_opt && had_mode)
|
||||
indicate_attribute(ctl);
|
||||
fflush(stdout);
|
||||
if (ctl->upln)
|
||||
ctl->upln--;
|
||||
initbuf(ctl);
|
||||
if (ctl->up_line)
|
||||
ctl->up_line--;
|
||||
init_buffer(ctl);
|
||||
}
|
||||
|
||||
static void fwd(struct ul_ctl *ctl, struct term_caps const *const tcs)
|
||||
static void forward(struct ul_ctl *ctl, struct term_caps const *const tcs)
|
||||
{
|
||||
int oldcol, oldmax;
|
||||
int old_column, old_maximum;
|
||||
|
||||
oldcol = ctl->col;
|
||||
oldmax = ctl->maxcol;
|
||||
flushln(ctl, tcs);
|
||||
setcol(ctl, oldcol);
|
||||
ctl->maxcol = oldmax;
|
||||
old_column = ctl->column;
|
||||
old_maximum = ctl->max_column;
|
||||
flush_line(ctl, tcs);
|
||||
set_column(ctl, old_column);
|
||||
ctl->max_column = old_maximum;
|
||||
}
|
||||
|
||||
static void reverse(struct ul_ctl *ctl, struct term_caps const *const tcs)
|
||||
{
|
||||
ctl->upln++;
|
||||
fwd(ctl, tcs);
|
||||
print_out(tcs->curs_up);
|
||||
print_out(tcs->curs_up);
|
||||
ctl->upln++;
|
||||
ctl->up_line++;
|
||||
forward(ctl, tcs);
|
||||
print_line(tcs->curs_up);
|
||||
print_line(tcs->curs_up);
|
||||
ctl->up_line++;
|
||||
}
|
||||
|
||||
static int handle_escape(struct ul_ctl *ctl, struct term_caps const *const tcs, FILE *f)
|
||||
|
|
@ -445,27 +447,27 @@ static int handle_escape(struct ul_ctl *ctl, struct term_caps const *const tcs,
|
|||
|
||||
switch (c = getwc(f)) {
|
||||
case HREV:
|
||||
if (ctl->halfpos == 0) {
|
||||
if (ctl->half_position == 0) {
|
||||
ctl->mode |= SUPERSCRIPT;
|
||||
ctl->halfpos--;
|
||||
} else if (ctl->halfpos > 0) {
|
||||
ctl->half_position--;
|
||||
} else if (ctl->half_position > 0) {
|
||||
ctl->mode &= ~SUBSCRIPT;
|
||||
ctl->halfpos--;
|
||||
ctl->half_position--;
|
||||
} else {
|
||||
ctl->halfpos = 0;
|
||||
ctl->half_position = 0;
|
||||
reverse(ctl, tcs);
|
||||
}
|
||||
return 0;
|
||||
case HFWD:
|
||||
if (ctl->halfpos == 0) {
|
||||
if (ctl->half_position == 0) {
|
||||
ctl->mode |= SUBSCRIPT;
|
||||
ctl->halfpos++;
|
||||
} else if (ctl->halfpos < 0) {
|
||||
ctl->half_position++;
|
||||
} else if (ctl->half_position < 0) {
|
||||
ctl->mode &= ~SUPERSCRIPT;
|
||||
ctl->halfpos++;
|
||||
ctl->half_position++;
|
||||
} else {
|
||||
ctl->halfpos = 0;
|
||||
fwd(ctl, tcs);
|
||||
ctl->half_position = 0;
|
||||
forward(ctl, tcs);
|
||||
}
|
||||
return 0;
|
||||
case FREV:
|
||||
|
|
@ -481,18 +483,18 @@ static int handle_escape(struct ul_ctl *ctl, struct term_caps const *const tcs,
|
|||
static void filter(struct ul_ctl *ctl, struct term_caps const *const tcs, FILE *f)
|
||||
{
|
||||
wint_t c;
|
||||
int i, w;
|
||||
int i, width;
|
||||
|
||||
while ((c = getwc(f)) != WEOF) {
|
||||
switch (c) {
|
||||
case '\b':
|
||||
setcol(ctl, ctl->col - 1);
|
||||
set_column(ctl, ctl->column - 1);
|
||||
continue;
|
||||
case '\t':
|
||||
setcol(ctl, (ctl->col + 8) & ~07);
|
||||
set_column(ctl, (ctl->column + 8) & ~07);
|
||||
continue;
|
||||
case '\r':
|
||||
setcol(ctl, 0);
|
||||
set_column(ctl, 0);
|
||||
continue;
|
||||
case SO:
|
||||
ctl->mode |= ALTERNATIVE_CHARSET;
|
||||
|
|
@ -500,78 +502,78 @@ static void filter(struct ul_ctl *ctl, struct term_caps const *const tcs, FILE *
|
|||
case SI:
|
||||
ctl->mode &= ~ALTERNATIVE_CHARSET;
|
||||
continue;
|
||||
case IESC:
|
||||
case ESC:
|
||||
if (handle_escape(ctl, tcs, f)) {
|
||||
c = getwc(f);
|
||||
errx(EXIT_FAILURE,
|
||||
_("unknown escape sequence in input: %o, %o"), IESC, c);
|
||||
_("unknown escape sequence in input: %o, %o"), ESC, c);
|
||||
}
|
||||
continue;
|
||||
case '_':
|
||||
if (ctl->obuf[ctl->col].c_char || ctl->obuf[ctl->col].c_width < 0) {
|
||||
while (ctl->col > 0 && ctl->obuf[ctl->col].c_width < 0)
|
||||
ctl->col--;
|
||||
w = ctl->obuf[ctl->col].c_width;
|
||||
for (i = 0; i < w; i++)
|
||||
ctl->obuf[ctl->col++].c_mode |= UNDERLINE | ctl->mode;
|
||||
setcol(ctl, ctl->col);
|
||||
if (ctl->buf[ctl->column].c_char || ctl->buf[ctl->column].c_width < 0) {
|
||||
while (ctl->column > 0 && ctl->buf[ctl->column].c_width < 0)
|
||||
ctl->column--;
|
||||
width = ctl->buf[ctl->column].c_width;
|
||||
for (i = 0; i < width; i++)
|
||||
ctl->buf[ctl->column++].c_mode |= UNDERLINE | ctl->mode;
|
||||
set_column(ctl, ctl->column);
|
||||
continue;
|
||||
}
|
||||
ctl->obuf[ctl->col].c_char = '_';
|
||||
ctl->obuf[ctl->col].c_width = 1;
|
||||
ctl->buf[ctl->column].c_char = '_';
|
||||
ctl->buf[ctl->column].c_width = 1;
|
||||
/* fallthrough */
|
||||
case ' ':
|
||||
setcol(ctl, ctl->col + 1);
|
||||
set_column(ctl, ctl->column + 1);
|
||||
continue;
|
||||
case '\n':
|
||||
flushln(ctl, tcs);
|
||||
flush_line(ctl, tcs);
|
||||
continue;
|
||||
case '\f':
|
||||
flushln(ctl, tcs);
|
||||
flush_line(ctl, tcs);
|
||||
putwchar('\f');
|
||||
continue;
|
||||
default:
|
||||
if (!iswprint(c))
|
||||
/* non printable */
|
||||
continue;
|
||||
w = wcwidth(c);
|
||||
needcol(ctl, ctl->col + w);
|
||||
if (ctl->obuf[ctl->col].c_char == '\0') {
|
||||
ctl->obuf[ctl->col].c_char = c;
|
||||
for (i = 0; i < w; i++)
|
||||
ctl->obuf[ctl->col + i].c_mode = ctl->mode;
|
||||
ctl->obuf[ctl->col].c_width = w;
|
||||
for (i = 1; i < w; i++)
|
||||
ctl->obuf[ctl->col + i].c_width = -1;
|
||||
} else if (ctl->obuf[ctl->col].c_char == '_') {
|
||||
ctl->obuf[ctl->col].c_char = c;
|
||||
for (i = 0; i < w; i++)
|
||||
ctl->obuf[ctl->col + i].c_mode |= UNDERLINE | ctl->mode;
|
||||
ctl->obuf[ctl->col].c_width = w;
|
||||
for (i = 1; i < w; i++)
|
||||
ctl->obuf[ctl->col + i].c_width = -1;
|
||||
} else if ((wint_t) ctl->obuf[ctl->col].c_char == c) {
|
||||
for (i = 0; i < w; i++)
|
||||
ctl->obuf[ctl->col + i].c_mode |= BOLD | ctl->mode;
|
||||
width = wcwidth(c);
|
||||
need_column(ctl, ctl->column + width);
|
||||
if (ctl->buf[ctl->column].c_char == '\0') {
|
||||
ctl->buf[ctl->column].c_char = c;
|
||||
for (i = 0; i < width; i++)
|
||||
ctl->buf[ctl->column + i].c_mode = ctl->mode;
|
||||
ctl->buf[ctl->column].c_width = width;
|
||||
for (i = 1; i < width; i++)
|
||||
ctl->buf[ctl->column + i].c_width = -1;
|
||||
} else if (ctl->buf[ctl->column].c_char == '_') {
|
||||
ctl->buf[ctl->column].c_char = c;
|
||||
for (i = 0; i < width; i++)
|
||||
ctl->buf[ctl->column + i].c_mode |= UNDERLINE | ctl->mode;
|
||||
ctl->buf[ctl->column].c_width = width;
|
||||
for (i = 1; i < width; i++)
|
||||
ctl->buf[ctl->column + i].c_width = -1;
|
||||
} else if ((wint_t) ctl->buf[ctl->column].c_char == c) {
|
||||
for (i = 0; i < width; i++)
|
||||
ctl->buf[ctl->column + i].c_mode |= BOLD | ctl->mode;
|
||||
} else {
|
||||
w = ctl->obuf[ctl->col].c_width;
|
||||
for (i = 0; i < w; i++)
|
||||
ctl->obuf[ctl->col + i].c_mode = ctl->mode;
|
||||
width = ctl->buf[ctl->column].c_width;
|
||||
for (i = 0; i < width; i++)
|
||||
ctl->buf[ctl->column + i].c_mode = ctl->mode;
|
||||
}
|
||||
setcol(ctl, ctl->col + w);
|
||||
set_column(ctl, ctl->column + width);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (ctl->maxcol)
|
||||
flushln(ctl, tcs);
|
||||
if (ctl->max_column)
|
||||
flush_line(ctl, tcs);
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
int c, ret, tflag = 0;
|
||||
int c, ret, opt_terminal = 0;
|
||||
char *termtype;
|
||||
struct term_caps tcs = { 0 };
|
||||
struct ul_ctl ctl = { .curmode = NORMAL_CHARSET };
|
||||
struct ul_ctl ctl = { .current_mode = NORMAL_CHARSET };
|
||||
FILE *f;
|
||||
|
||||
static const struct option longopts[] = {
|
||||
|
|
@ -599,10 +601,10 @@ int main(int argc, char **argv)
|
|||
case 'T':
|
||||
/* for nroff compatibility */
|
||||
termtype = optarg;
|
||||
tflag = 1;
|
||||
opt_terminal = 1;
|
||||
break;
|
||||
case 'i':
|
||||
ctl.iflag = 1;
|
||||
ctl.indicated_opt = 1;
|
||||
break;
|
||||
|
||||
case 'V':
|
||||
|
|
@ -623,15 +625,15 @@ int main(int argc, char **argv)
|
|||
/* fallthrough */
|
||||
|
||||
case 0:
|
||||
if (tflag)
|
||||
if (opt_terminal)
|
||||
warnx(_("terminal `%s' is not known, defaulting to `dumb'"),
|
||||
termtype);
|
||||
setupterm("dumb", STDOUT_FILENO, (int *)0);
|
||||
break;
|
||||
}
|
||||
|
||||
initinfo(&ctl, &tcs);
|
||||
initbuf(&ctl);
|
||||
init_term_caps(&ctl, &tcs);
|
||||
init_buffer(&ctl);
|
||||
if (optind == argc)
|
||||
filter(&ctl, &tcs, stdin);
|
||||
else
|
||||
|
|
@ -642,7 +644,7 @@ int main(int argc, char **argv)
|
|||
filter(&ctl, &tcs, f);
|
||||
fclose(f);
|
||||
}
|
||||
free(ctl.obuf);
|
||||
free(ctl.buf);
|
||||
del_curterm(cur_term);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue