From 867488d6bf2c3f868b329a8bcb5f08e2041f599b Mon Sep 17 00:00:00 2001 From: "B. Watson" Date: Mon, 31 Mar 2025 21:02:09 -0400 Subject: a8cat: library-ize the conversion logic so we can use it in listbas and listamsb eventually. --- Makefile | 4 +- a8cat.c | 130 +++++++++++--------------------------------------------------- atascii.c | 115 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ atascii.h | 42 ++++++++++++++++++++ 4 files changed, 183 insertions(+), 108 deletions(-) create mode 100644 atascii.c create mode 100644 atascii.h diff --git a/Makefile b/Makefile index c66b48e..c46103e 100644 --- a/Makefile +++ b/Makefile @@ -56,6 +56,8 @@ RST2MAN=rst2man all: $(BINS) manpages symlinks subdirs $(TTF) amsb40.txt +atest: atest.c atascii.c atables.c wtable.c + intbas: bas.o unprotbas: bas.o @@ -83,7 +85,7 @@ wtable.o: wtable.c wtable.h atables.o: atables.c atables.h -a8cat: a8cat.c atables.o wtable.o +a8cat: a8cat.c atables.o wtable.o atascii.o a8xd: a8xd.c atables.o diff --git a/a8cat.c b/a8cat.c index 3c58510..92eae9f 100644 --- a/a8cat.c +++ b/a8cat.c @@ -6,24 +6,12 @@ #include #include -#include "atables.h" +#include "atascii.h" #include "wtable.h" -const char **table = ata2utf; +int reverse = 0, verbose = 0; -/* XXX: hard-coded ANSI/vt100 escape sequences. would be - better but more complex to use terminfo to support any ol' - terminal... */ -/* 20250316 bkw: used to use this: -const char *inverse_off = "\x1b[0m"; - ...but 27m is widely supported, and makes it easier for - colorize-amsb to postprocess a8cat's output. */ -const char *inverse_on = "\x1b[7m"; -const char *inverse_off = "\x1b[27m"; - -int verbose = 0; -int underline = 0, reverse = 0, textmode = 0, ics = 0; -int magazine = 0, stripinv = 0; +atascii_ctx actx; const char *self; @@ -77,9 +65,9 @@ int handle_escape_seq(int inv, FILE *input, const char *file, int line) { buf[count] = c; /* FIXME: might be a wide char! */ } - if(strcmp(inverse_on, buf) == 0) { + if(strcmp(atascii_inverse_on, buf) == 0) { return 0x80; - } else if(strcmp(inverse_off, buf) == 0) { + } else if(strcmp(atascii_inverse_off, buf) == 0) { return 0; } else { fprintf(stderr, "%s: warning: %s:%d: unrecognized ANSI escape sequence.\n", self, file, line); @@ -112,7 +100,7 @@ int a8revcat(const char *file) { } else if(c < 0x80) { putchar(c | inv); } else { - d = wchar2atascii(c, ics); + d = wchar2atascii(c, actx.flags & ATA_FLAG_ICS); if(d == -1) { fprintf(stderr, "%s: warning: %s:%d: unrecognized Unicode character %04x.\n", self, file, line, c); } else { @@ -128,103 +116,24 @@ int a8revcat(const char *file) { return 0; } -void inverse(int onoff) { - fputs((onoff ? inverse_on : inverse_off ), stdout); -} - int a8cat(const char *file) { FILE *input; - int c, inv = 0, line = 1; + int c; + char converted[20]; if( !(input = open_input(file)) ) return 1; while( (c = fgetc(input)) != EOF ) { - if(c == 0x9b) { - putchar('\n'); - line++; - continue; - } - - if(stripinv) c &= 0x7f; - - if(textmode) { - switch(c) { - case 0x7f: /* tab */ - putchar('\t'); - continue; - case 0xfd: /* bell */ - putchar('\a'); - continue; - case 0x7e: /* backspace */ - putchar('\b'); - continue; - default: break; - } - } - - if(!underline) { - /* strings of inverse chars only get one "inverse on" ANSI - sequence, and one "inverse off" afterwards. */ - if(c & 0x80) { - if(!inv) { - inv = 1; - if(magazine) - fputs("{inv}", stdout); - else - inverse(1); - } - } else { - if(inv) { - inv = 0; - if(magazine) - fputs("{norm}", stdout); - else - inverse(0); - } - } - } - - if(magazine) { - /* special cases: control codes with bit 7 set can't go - in the table since it's only got 128 entries. */ - switch(c) { - case 0x9c: - fputs("{del-line}", stdout); continue; - case 0x9d: - fputs("{ins-line}", stdout); continue; - case 0x9e: - fputs("{clr-tab}", stdout); continue; - case 0x9f: - fputs("{set-tab}", stdout); continue; - case 0xfd: - fputs("{bell}", stdout); continue; - case 0xfe: - fputs("{del-char}", stdout); continue; - case 0xff: - fputs("{ins-char}", stdout); continue; - } - } - - fputs(table[c & 0x7f], stdout); - - if(underline && (c & 0x80)) { - putchar('\b'); - putchar('_'); - } + fputs(atascii_a2utf(&actx, c, converted), stdout); } /* gotta turn off inverse, so if there's another file after this one, it doesn't start out being printed in inverse. */ - if(inv && !underline) { - if(magazine) - fputs("{norm}", stdout); - else - inverse(0); - } + fputs(atascii_a2utf(&actx, ATA_CHR_FINISH, converted), stdout); if(verbose) - fprintf(stderr, "%s: %s: converted %d lines, closing file.\n", self, file, line - 1); + fprintf(stderr, "%s: %s: converted %d lines, closing file.\n", self, file, actx.lines - 1); fclose(input); return 0; @@ -232,6 +141,7 @@ int a8cat(const char *file) { int main(int argc, char **argv) { int opt, result = 0; + int mode = ATA_MODE_UTF8, flags = 0; set_self(argv[0]); @@ -247,36 +157,42 @@ int main(int argc, char **argv) { while( (opt = getopt(argc, argv, "ihurtmsv")) != -1) { switch(opt) { - case 'i': table = ics2utf; ics = 1; break; + case 'i': flags |= ATA_FLAG_ICS; break; case 'h': print_help(); exit(0); break; - case 'u': underline = 1; break; + case 'u': flags |= ATA_FLAG_UNDERLINE; break; case 'r': reverse = 1; break; - case 't': textmode = 1; break; - case 'm': table = ata2mag; magazine = 1; break; - case 's': stripinv = 1; break; + case 't': flags |= ATA_FLAG_TEXTMODE; break; + case 'm': mode = ATA_MODE_MAGAZINE; break; + case 's': flags |= ATA_FLAG_STRIP_INVERSE; break; case 'v': verbose = 1; break; default: print_help(); exit(1); break; } } + atascii_context_init(&actx, mode, flags); + if(reverse) { if(isatty(fileno(stdout))) die("Refusing to write ATASCII to a terminal."); + /* if(underline || textmode || stripinv || magazine) { die("-t, -u, -m, -s options don't make sense with -r.\n"); } + */ /* the language_country part of the locale doesn't matter, since we aren't doing localization. the encoding *has* to be UTF-8. */ setlocale(LC_CTYPE, "en_US.UTF-8"); } + /* if(magazine) { if(ics || stripinv || underline) { die("-i, -s, -u options don't make sense with -m.\n"); } } + */ if(optind >= argc) { result = (reverse ? a8revcat("-") : a8cat("-")); diff --git a/atascii.c b/atascii.c new file mode 100644 index 0000000..d1d1243 --- /dev/null +++ b/atascii.c @@ -0,0 +1,115 @@ +#include "atascii.h" + +const char *atascii_inverse_on = "\x1b[7m"; +const char *atascii_inverse_off = "\x1b[27m"; + +int atascii_context_init(atascii_ctx *ctx, int mode, int flags) { + memset(ctx, 0, sizeof(atascii_ctx)); + + switch(mode) { + case ATA_MODE_UTF8: + if(flags & ATA_FLAG_ICS) + ctx->table = ics2utf; + else + ctx->table = ata2utf; + break; + case ATA_MODE_MAGAZINE: + ctx->flags &= ~ATA_FLAG_UNDERLINE; + ctx->table = ata2mag; + break; + default: + return 0; + } + + ctx->mode = mode; + ctx->flags = flags; + + return 1; +} + +char *atascii_a2utf(atascii_ctx *ctx, int src, char *dest) { + dest[0] = 0; + + if(src == ATA_CHR_FINISH) { + if(ctx->inv) + strcpy(dest, atascii_inverse_off); + return dest; + } + + if(src == 0x9b) { + strcpy(dest, "\n"); + ctx->lines++; + return dest; + } + + if(ctx->flags & ATA_FLAG_TEXTMODE) { + switch(src) { + case 0x7f: /* tab */ + strcpy(dest, "\t"); + return dest; + case 0xfd: /* bell */ + strcpy(dest, "\a"); + return dest; + case 0x7e: /* backspace */ + strcpy(dest, "\b"); + return dest; + default: break; + } + } + + if(ctx->flags & ATA_FLAG_STRIP_INVERSE) src &= 0x7f; + + if(!(ctx->flags & ATA_FLAG_UNDERLINE)) { + /* strings of inverse chars only get one "inverse on" ANSI + sequence, and one "inverse off" afterwards. */ + if(src & 0x80) { + if(!ctx->inv) { + ctx->inv = 1; + if(ctx->mode == ATA_MODE_MAGAZINE) { + strcpy(dest, "{inv}"); + } else { + strcpy(dest, atascii_inverse_on); + } + } + } else { + if(ctx->inv) { + ctx->inv = 0; + if(ctx->mode == ATA_MODE_MAGAZINE) { + strcpy(dest, "{norm}"); + } else { + strcpy(dest, atascii_inverse_off); + } + } + } + } + + if(ctx->mode == ATA_MODE_MAGAZINE) { + /* special cases: control codes with bit 7 set can't go + in the table since it's only got 128 entries. */ + switch(src) { + case 0x9c: + strcat(dest, "{del-line}"); return dest; + case 0x9d: + strcat(dest, "{ins-line}"); return dest; + case 0x9e: + strcat(dest, "{clr-tab}"); return dest; + case 0x9f: + strcat(dest, "{set-tab}"); return dest; + case 0xfd: + strcat(dest, "{bell}"); return dest; + case 0xfe: + strcat(dest, "{del-char}"); return dest; + case 0xff: + strcat(dest, "{ins-char}"); return dest; + default: break; + } + } + + strcat(dest, ctx->table[src & 0x7f]); + + if((ctx->flags & ATA_FLAG_UNDERLINE) && (src & 0x80)) { + strcat(dest, "\b_"); + } + + return dest; +} diff --git a/atascii.h b/atascii.h new file mode 100644 index 0000000..ffa5d32 --- /dev/null +++ b/atascii.h @@ -0,0 +1,42 @@ +#ifndef ATASCII_H +#define ATASCII_H + +#include +#include +#include "atables.h" + +#define ATA_MODE_UTF8 0 /* default */ +#define ATA_MODE_MAGAZINE 1 +/* TODO: #define ATA_MODE_DOTS 2 */ + +#define ATA_FLAG_NONE 0 /* default */ +#define ATA_FLAG_UNDERLINE 1 +#define ATA_FLAG_ICS 2 +#define ATA_FLAG_TEXTMODE 4 +#define ATA_FLAG_STRIP_INVERSE 8 + +#define ATA_CHR_FINISH -1 + +extern const char *atascii_inverse_on; +extern const char *atascii_inverse_off; + +typedef struct { + int mode; + int flags; + int inv; + int lines; + const char **table; +} atascii_ctx; + +/* returns true if mode and flags are valid, 0 otherwise. */ +extern int atascii_context_init(atascii_ctx *ctx, int mode, int flags); + +/* obeys all the flags and modes. + result goes in dest, which needs to be 9 bytes in utf-8 mode (big + enough to handle up to 4 bytes of UTF-8 plus 4 bytes of ANSI escape + code plus a terminating null), or 12 bytes in magazine mode. + the return value is dest. + */ +extern char *atascii_a2utf(atascii_ctx *ctx, int src, char *dest); + +#endif -- cgit v1.2.3