listamsb: rewrite next_line() in terms of read_token() expand_token() etc.

1 files changed, 44 insertions, 54 deletions

diff --git a/listamsb.c b/listamsb.c
index 74d01c3..6fdaeb7 100644
--- a/listamsb.c
+++ b/listamsb.c
@@ -275,22 +275,29 @@ void read_header(void) {
 	header_read = 1;
 }
 
-void unknown_token(unsigned char byte, int ext) {
+void unknown_token(int tok) {
+	int ext;
 	if(!printing) return;
+	ext = (tok > 0xff);
+	tok &= 0xff;
 	fprintf(outfile, "<unknown %stoken ", (ext ? "extended " : ""));
-	fprintf(outfile, "%s%02x>", (ext ? "$ff ": ""), byte);
+	fprintf(outfile, "%s%02x>", (ext ? "$ff ": ""), tok);
 }
 
 void list_char(unsigned char c) {
 	if(printing) fputc(c, outfile);
 }
 
-void list_token(unsigned char c) {
-	if(printing) fputs(std_tokens[c - MIN_STD_TOK], outfile);
-}
+int expand_token(int t, unsigned char *buf);
 
-void list_ext_token(unsigned char c) {
-	if(printing) fputs(ext_tokens[c - MIN_EXT_TOK], outfile);
+int list_token(int tok) {
+	unsigned char text[10];
+	if(!expand_token(tok, text)) {
+		unknown_token(tok);
+		return 0;
+	}
+	if(printing) fputs((char *)text, outfile);
+	return 1;
 }
 
 void list_lineno(int l) {
@@ -304,14 +311,15 @@ void start_listing(void) {
 	if(initial_eol) fputc(EOL, outfile);
 }
 
+int read_token(int literal);
+
 /* meat and potatoes. does the actual detokenizing. gets called once
    per line of code. returns false when it hits the last line, or
    true if there are more lines. */
 int next_line(void) {
 	static int last_lineno = -1;
 	static int last_ptr = -1;
-	int ptr, lineno, was_ff, was_colon, in_string, in_comment, offset, len;
-	unsigned char byte;
+	int tok, ptr, lineno, was_colon = 0, in_string = 0, in_comment = 0, offset, len;
 
 	offset = bytes_read;
 
@@ -353,86 +361,68 @@ int next_line(void) {
 
 	list_lineno(lineno);
 
-	was_ff     = 0;
-	was_colon  = 0;
-	in_string  = 0;
-	in_comment = 0;
-
 	/* walk and print the tokens. when we hit a null byte, break out of the
 	   loop, we're done with this line. */
 	while(1) {
-		byte = read_prog_byte();
+		tok = read_token(in_string || in_comment);
 
 		if(in_string) {
-			if(byte == 0x00) {
+			if(tok == 0x00) {
 				/* null byte ends both the string and the line of code.
 				   don't print a closing quote because AMSB doesn't. */
 				break;
-			} else if(byte == '|') {
+			} else if(tok == '|') {
 				/* pipe is how AMSB stores the closing quote. end the string
 				   but not the line of code, and print a " character. */
 				in_string = 0;
 				list_char('"');
 			} else {
 				/* normal string character. */
-				list_char(byte);
+				list_char(tok);
 				/* one " character embedded in a string gets printed as "" */
-				if(byte == '"') list_char(byte);
+				if(tok == '"') list_char(tok);
 			}
 			continue;
 		} else if(in_comment) {
 			/* null byte ends both the comment and the line of code. */
-			if(byte == 0x00) break;
-			list_char(byte);
+			if(tok == 0x00) break;
+			list_char(tok);
 			continue;
 		}
 
 		if(was_colon) {
-			if(byte != TOK_SQUOTE && byte != TOK_BANG && byte != TOK_ELSE) {
+			if(tok != TOK_SQUOTE && tok != TOK_BANG && tok != TOK_ELSE) {
 				list_char(':');
 			}
 			was_colon = 0;
 		}
 
-		if(byte == ':') {
+		if(tok == ':') {
 			/* statement separator. don't print the colon yet, the next token
-			   might be a ! or ' for a comment */
+			   might be ELSE or a ! or ' for a comment */
 			was_colon = 1;
-		} else if(byte == '"') {
+		} else if(tok == '"') {
 			/* begin string. strings start but *don't end* with a double-quote */
 			in_string = 1;
-			list_char(byte);
-		} else if(was_ff) {
-			/* previous token was $ff, so this is a function token */
-			if(byte >= MIN_EXT_TOK && byte <= MAX_EXT_TOK) {
-				list_ext_token(byte);
-			} else {
-				unknown_token(byte, 1);
-				warn("unknown extended token $ff $%02x at line %d", byte, lineno);
-			}
-			was_ff = 0;
-		} else if(byte == 0xff) {
-			/* next token will be a function token */
-			was_ff = 1;
-		} else if(byte >= MIN_STD_TOK && byte <= MAX_STD_TOK) {
-			/* statement token */
-			list_token(byte);
-			if(is_comment_start(byte))
-				in_comment = 1;
-		} else if(byte >= 0x80) {
-			/* invalid token */
-			unknown_token(byte, 0);
-			warn("unknown token $%02x at line %d", byte, lineno);
+			list_char(tok);
+		} else if(tok >= 0x80) {
+			if(!list_token(tok))
+				warn("unknown %stoken %s$%02x at line %d",
+						(tok > 0xff ? "extended " : ""),
+						(tok > 0xff ? "$ff " : ""),
+						tok & 0xff,
+						lineno);
+			if(is_comment_start(tok)) in_comment = 1;
 		} else {
 			/* null byte means the line of code is done */
-			if(!byte) break;
-			if(byte < 0x20) {
+			if(!tok) break;
+			if(tok < 0x20) {
 				/* ATASCII graphics outside of a string */
 				warn("line %d has character %d outside of a string, maybe Atari BASIC?",
-						lineno, byte);
+						lineno, tok);
 			}
-			if(byte == ' ') spacecount++;
-			list_char(byte);
+			if(tok == ' ') spacecount++;
+			list_char(tok);
 		}
 	}
 
@@ -558,7 +548,6 @@ int crunch_line(void) {
 	return codelen;
 }
 
-/* only called during decrunching. */
 int expand_token(int t, unsigned char *buf) {
 	const char *result;
 
@@ -585,7 +574,8 @@ int expand_token(int t, unsigned char *buf) {
 
 int read_token(int literal) {
 	int tok = read_prog_byte();
-	if((!literal) && (tok == 0xff)) {
+	if(literal) return tok;
+	if(tok == 0xff) {
 		tok <<= 8;
 		tok |= read_prog_byte();
 	}