a8cat: library-ize the conversion logic so we can use it in listbas and listamsb eventually.

4 files changed, 183 insertions, 108 deletions

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 <wchar.h>
 #include <errno.h>
 
-#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 <stdio.h>
+#include <string.h>
+#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