#define HREV '8'
#define FREV '7'
-#define NORMAL 000
-#define ALTSET 001 /* Reverse */
-#define SUPERSC 002 /* Dim */
-#define SUBSC 004 /* Dim | Ul */
-#define UNDERL 010 /* Ul */
-#define BOLD 020 /* Bold */
+enum {
+ NORMAL = 0, /* Must be zero, see initbuf() */
+ ALTSET = 1 << 0, /* Reverse */
+ SUPERSC = 1 << 1, /* Dim */
+ SUBSC = 1 << 2, /* Dim | Ul */
+ UNDERL = 1 << 3, /* Ul */
+ BOLD = 1 << 4, /* Bold */
+};
struct term_caps {
char *curs_up;
char *exit_attributes;
};
-struct CHAR {
- char c_mode;
+struct ul_char {
wchar_t c_char;
int c_width;
+ char c_mode;
};
-static struct CHAR *obuf;
-static int obuflen;
-static int col, maxcol;
-static int mode;
-static int halfpos;
-static int upln;
-static int iflag;
-static int must_use_uc, must_overstrike;
-
-static int curmode = 0;
+struct ul_ctl {
+ int obuflen;
+ int col;
+ int maxcol;
+ int mode;
+ int halfpos;
+ int upln;
+ int curmode;
+ struct ul_char *obuf;
+ unsigned int
+ iflag:1,
+ must_use_uc:1,
+ must_overstrike:1;
+};
static void __attribute__((__noreturn__)) usage(void)
{
exit(EXIT_SUCCESS);
}
-static void needcol(int acol)
+static void needcol(struct ul_ctl *ctl, int acol)
{
- maxcol = acol;
+ ctl->maxcol = acol;
/* If col >= obuflen, expand obuf until obuflen > col. */
- while (acol >= obuflen) {
+ while (acol >= ctl->obuflen) {
/* Paranoid check for obuflen == INT_MAX. */
- if (obuflen == INT_MAX)
+ if (ctl->obuflen == INT_MAX)
errx(EXIT_FAILURE, _("Input line too long."));
/* Similar paranoia: double only up to INT_MAX. */
- if (obuflen < (INT_MAX / 2))
- obuflen *= 2;
+ if (ctl->obuflen < (INT_MAX / 2))
+ ctl->obuflen *= 2;
else
- obuflen = INT_MAX;
+ ctl->obuflen = INT_MAX;
/* Now we can try to expand obuf. */
- obuf = xrealloc(obuf, sizeof(struct CHAR) * obuflen);
+ ctl->obuf = xrealloc(ctl->obuf, sizeof(struct ul_char) * ctl->obuflen);
}
}
-static void setcol(int newcol)
+static void setcol(struct ul_ctl *ctl, int newcol)
{
- col = newcol;
+ ctl->col = newcol;
- if (col < 0)
- col = 0;
- else if (col > maxcol)
- needcol(col);
+ if (ctl->col < 0)
+ ctl->col = 0;
+ else if (ctl->col > ctl->maxcol)
+ needcol(ctl, ctl->col);
}
-static void initbuf(void)
+static void initbuf(struct ul_ctl *ctl)
{
- if (obuf == NULL) {
+ if (ctl->obuf == NULL) {
/* First time. */
- obuflen = BUFSIZ;
- obuf = xcalloc(obuflen, sizeof(struct CHAR));
+ ctl->obuflen = BUFSIZ;
+ ctl->obuf = xcalloc(ctl->obuflen, sizeof(struct ul_char));
} else
/* assumes NORMAL == 0 */
- memset(obuf, 0, sizeof(struct CHAR) * maxcol);
+ memset(ctl->obuf, 0, sizeof(struct ul_char) * ctl->maxcol);
- setcol(0);
- maxcol = 0;
- mode &= ALTSET;
+ setcol(ctl, 0);
+ ctl->maxcol = 0;
+ ctl->mode &= ALTSET;
}
-static void initinfo(struct term_caps *const tcs)
+static void initinfo(struct ul_ctl *ctl, struct term_caps *const tcs)
{
tcs->curs_up = tigetstr("cuu1");
tcs->curs_right = tigetstr("cuf1");
* letters the 37 has.
*/
tcs->under_char = tigetstr("uc");
- must_use_uc = (tcs->under_char && !tcs->enter_underline);
+ ctl->must_use_uc = (tcs->under_char && !tcs->enter_underline);
if ((tigetflag("os") && tcs->enter_bold == NULL) ||
(tigetflag("ul") && tcs->enter_underline == NULL && tcs->under_char == NULL))
- must_overstrike = 1;
+ ctl->must_overstrike = 1;
}
static void sig_handler(int signo __attribute__((__unused__)))
putwp(line);
}
-static void xsetmode(struct term_caps const *const tcs, int newmode)
+static void xsetmode(struct ul_ctl *ctl, struct term_caps const *const tcs, int newmode)
{
- if (!iflag) {
- if (curmode != NORMAL && newmode != NORMAL)
- xsetmode(tcs, NORMAL);
+ if (!ctl->iflag) {
+ if (ctl->curmode != NORMAL && newmode != NORMAL)
+ xsetmode(ctl, tcs, NORMAL);
switch (newmode) {
case NORMAL:
- switch (curmode) {
+ switch (ctl->curmode) {
case NORMAL:
break;
case UNDERL:
break;
}
}
- curmode = newmode;
+ ctl->curmode = newmode;
}
-static void iattr(void)
+static void iattr(struct ul_ctl *ctl)
{
int i;
- wchar_t *lbuf = xcalloc(maxcol + 1, sizeof(wchar_t));
+ wchar_t *lbuf = xcalloc(ctl->maxcol + 1, sizeof(wchar_t));
wchar_t *cp = lbuf;
- for (i = 0; i < maxcol; i++)
- switch (obuf[i].c_mode) {
+ for (i = 0; i < ctl->maxcol; i++)
+ switch (ctl->obuf[i].c_mode) {
case NORMAL: *cp++ = ' '; break;
case ALTSET: *cp++ = 'g'; break;
case SUPERSC: *cp++ = '^'; break;
free(lbuf);
}
-static void outc(struct term_caps const *const tcs, wint_t c, int width)
+static void outc(struct ul_ctl *ctl, struct term_caps const *const tcs, wint_t c, int width)
{
int i;
putwchar(c);
- if (must_use_uc && (curmode & UNDERL)) {
+ if (ctl->must_use_uc && (ctl->curmode & UNDERL)) {
for (i = 0; i < width; i++)
print_out(tcs->curs_left);
for (i = 0; i < width; i++)
* For terminals that can overstrike, overstrike underlines and bolds.
* We don't do anything with halfline ups and downs, or Greek.
*/
-static void overstrike(void)
+static void overstrike(struct ul_ctl *ctl)
{
int i;
- wchar_t *lbuf = xcalloc(maxcol + 1, sizeof(wchar_t));
+ wchar_t *lbuf = xcalloc(ctl->maxcol + 1, sizeof(wchar_t));
wchar_t *cp = lbuf;
int hadbold = 0;
/* Set up overstrike buffer */
- for (i = 0; i < maxcol; i++)
- switch (obuf[i].c_mode) {
+ for (i = 0; i < ctl->maxcol; i++)
+ switch (ctl->obuf[i].c_mode) {
case NORMAL:
default:
*cp++ = ' ';
*cp++ = '_';
break;
case BOLD:
- *cp++ = obuf[i].c_char;
- if (obuf[i].c_width > 1)
- i += obuf[i].c_width - 1;
+ *cp++ = ctl->obuf[i].c_char;
+ if (ctl->obuf[i].c_width > 1)
+ i += ctl->obuf[i].c_width - 1;
hadbold = 1;
break;
}
free(lbuf);
}
-static void flushln(struct term_caps const *const tcs)
+static void flushln(struct ul_ctl *ctl, struct term_caps const *const tcs)
{
int lastmode;
int i;
int hadmodes = 0;
lastmode = NORMAL;
- for (i = 0; i < maxcol; i++) {
- if (obuf[i].c_mode != lastmode) {
+ for (i = 0; i < ctl->maxcol; i++) {
+ if (ctl->obuf[i].c_mode != lastmode) {
hadmodes++;
- xsetmode(tcs, obuf[i].c_mode);
- lastmode = obuf[i].c_mode;
+ xsetmode(ctl, tcs, ctl->obuf[i].c_mode);
+ lastmode = ctl->obuf[i].c_mode;
}
- if (obuf[i].c_char == '\0') {
- if (upln)
+ if (ctl->obuf[i].c_char == '\0') {
+ if (ctl->upln)
print_out(tcs->curs_right);
else
- outc(tcs, ' ', 1);
+ outc(ctl, tcs, ' ', 1);
} else
- outc(tcs, obuf[i].c_char, obuf[i].c_width);
- if (obuf[i].c_width > 1)
- i += obuf[i].c_width - 1;
+ 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;
}
if (lastmode != NORMAL)
- xsetmode(tcs, NORMAL);
- if (must_overstrike && hadmodes)
- overstrike();
+ xsetmode(ctl, tcs, NORMAL);
+ if (ctl->must_overstrike && hadmodes)
+ overstrike(ctl);
putwchar('\n');
- if (iflag && hadmodes)
- iattr();
+ if (ctl->iflag && hadmodes)
+ iattr(ctl);
fflush(stdout);
- if (upln)
- upln--;
- initbuf();
+ if (ctl->upln)
+ ctl->upln--;
+ initbuf(ctl);
}
-static void fwd(struct term_caps const *const tcs)
+static void fwd(struct ul_ctl *ctl, struct term_caps const *const tcs)
{
int oldcol, oldmax;
- oldcol = col;
- oldmax = maxcol;
- flushln(tcs);
- setcol(oldcol);
- maxcol = oldmax;
+ oldcol = ctl->col;
+ oldmax = ctl->maxcol;
+ flushln(ctl, tcs);
+ setcol(ctl, oldcol);
+ ctl->maxcol = oldmax;
}
-static void reverse(struct term_caps const *const tcs)
+static void reverse(struct ul_ctl *ctl, struct term_caps const *const tcs)
{
- upln++;
- fwd(tcs);
+ ctl->upln++;
+ fwd(ctl, tcs);
print_out(tcs->curs_up);
print_out(tcs->curs_up);
- upln++;
+ ctl->upln++;
}
-static int handle_escape(struct term_caps const *const tcs, FILE *f)
+static int handle_escape(struct ul_ctl *ctl, struct term_caps const *const tcs, FILE *f)
{
wint_t c;
switch (c = getwc(f)) {
case HREV:
- if (halfpos == 0) {
- mode |= SUPERSC;
- halfpos--;
- } else if (halfpos > 0) {
- mode &= ~SUBSC;
- halfpos--;
+ if (ctl->halfpos == 0) {
+ ctl->mode |= SUPERSC;
+ ctl->halfpos--;
+ } else if (ctl->halfpos > 0) {
+ ctl->mode &= ~SUBSC;
+ ctl->halfpos--;
} else {
- halfpos = 0;
- reverse(tcs);
+ ctl->halfpos = 0;
+ reverse(ctl, tcs);
}
return 0;
case HFWD:
- if (halfpos == 0) {
- mode |= SUBSC;
- halfpos++;
- } else if (halfpos < 0) {
- mode &= ~SUPERSC;
- halfpos++;
+ if (ctl->halfpos == 0) {
+ ctl->mode |= SUBSC;
+ ctl->halfpos++;
+ } else if (ctl->halfpos < 0) {
+ ctl->mode &= ~SUPERSC;
+ ctl->halfpos++;
} else {
- halfpos = 0;
- fwd(tcs);
+ ctl->halfpos = 0;
+ fwd(ctl, tcs);
}
return 0;
case FREV:
- reverse(tcs);
+ reverse(ctl, tcs);
return 0;
default:
/* unknown escape */
}
}
-static void filter(struct term_caps const *const tcs, FILE *f)
+static void filter(struct ul_ctl *ctl, struct term_caps const *const tcs, FILE *f)
{
wint_t c;
int i, w;
while ((c = getwc(f)) != WEOF) {
switch (c) {
case '\b':
- setcol(col - 1);
+ setcol(ctl, ctl->col - 1);
continue;
case '\t':
- setcol((col + 8) & ~07);
+ setcol(ctl, (ctl->col + 8) & ~07);
continue;
case '\r':
- setcol(0);
+ setcol(ctl, 0);
continue;
case SO:
- mode |= ALTSET;
+ ctl->mode |= ALTSET;
continue;
case SI:
- mode &= ~ALTSET;
+ ctl->mode &= ~ALTSET;
continue;
case IESC:
- if (handle_escape(tcs, f)) {
+ if (handle_escape(ctl, tcs, f)) {
c = getwc(f);
errx(EXIT_FAILURE,
_("unknown escape sequence in input: %o, %o"), IESC, c);
}
continue;
case '_':
- if (obuf[col].c_char || obuf[col].c_width < 0) {
- while (col > 0 && obuf[col].c_width < 0)
- col--;
- w = obuf[col].c_width;
+ 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++)
- obuf[col++].c_mode |= UNDERL | mode;
- setcol(col);
+ ctl->obuf[ctl->col++].c_mode |= UNDERL | ctl->mode;
+ setcol(ctl, ctl->col);
continue;
}
- obuf[col].c_char = '_';
- obuf[col].c_width = 1;
+ ctl->obuf[ctl->col].c_char = '_';
+ ctl->obuf[ctl->col].c_width = 1;
/* fallthrough */
case ' ':
- setcol(col + 1);
+ setcol(ctl, ctl->col + 1);
continue;
case '\n':
- flushln(tcs);
+ flushln(ctl, tcs);
continue;
case '\f':
- flushln(tcs);
+ flushln(ctl, tcs);
putwchar('\f');
continue;
default:
/* non printable */
continue;
w = wcwidth(c);
- needcol(col + w);
- if (obuf[col].c_char == '\0') {
- obuf[col].c_char = 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++)
- obuf[col + i].c_mode = mode;
- obuf[col].c_width = w;
+ ctl->obuf[ctl->col + i].c_mode = ctl->mode;
+ ctl->obuf[ctl->col].c_width = w;
for (i = 1; i < w; i++)
- obuf[col + i].c_width = -1;
- } else if (obuf[col].c_char == '_') {
- obuf[col].c_char = c;
+ 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++)
- obuf[col + i].c_mode |= UNDERL | mode;
- obuf[col].c_width = w;
+ ctl->obuf[ctl->col + i].c_mode |= UNDERL | ctl->mode;
+ ctl->obuf[ctl->col].c_width = w;
for (i = 1; i < w; i++)
- obuf[col + i].c_width = -1;
- } else if ((wint_t) obuf[col].c_char == c) {
+ 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++)
- obuf[col + i].c_mode |= BOLD | mode;
+ ctl->obuf[ctl->col + i].c_mode |= BOLD | ctl->mode;
} else {
- w = obuf[col].c_width;
+ w = ctl->obuf[ctl->col].c_width;
for (i = 0; i < w; i++)
- obuf[col + i].c_mode = mode;
+ ctl->obuf[ctl->col + i].c_mode = ctl->mode;
}
- setcol(col + w);
+ setcol(ctl, ctl->col + w);
continue;
}
}
- if (maxcol)
- flushln(tcs);
+ if (ctl->maxcol)
+ flushln(ctl, tcs);
}
int main(int argc, char **argv)
int c, ret, tflag = 0;
char *termtype;
struct term_caps tcs = { 0 };
+ struct ul_ctl ctl = { .curmode = NORMAL };
FILE *f;
static const struct option longopts[] = {
tflag = 1;
break;
case 'i':
- iflag = 1;
+ ctl.iflag = 1;
break;
case 'V':
break;
}
- initinfo(&tcs);
- initbuf();
+ initinfo(&ctl, &tcs);
+ initbuf(&ctl);
if (optind == argc)
- filter(&tcs, stdin);
+ filter(&ctl, &tcs, stdin);
else
for (; optind < argc; optind++) {
f = fopen(argv[optind], "r");
if (!f)
err(EXIT_FAILURE, _("cannot open %s"), argv[optind]);
- filter(&tcs, f);
+ filter(&ctl, &tcs, f);
fclose(f);
}
- free(obuf);
+ free(ctl.obuf);
return EXIT_SUCCESS;
}
projects / thirdparty / util-linux.git / commitdiff
