aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--bas2aplus.115
-rw-r--r--bas2aplus.c91
-rw-r--r--bas2aplus.rst15
3 files changed, 92 insertions, 29 deletions
diff --git a/bas2aplus.1 b/bas2aplus.1
index 48d8f2a..46eb8cf 100644
--- a/bas2aplus.1
+++ b/bas2aplus.1
@@ -42,6 +42,12 @@ All Atari BASIC programs can be successfully converted. Some BASIC
XL/XE tokens have no equivalent in BASIC/A+, so programs using these
can\(aqt be converted (you will see messages on standard error, in that
case).
+.sp
+Turbo BASIC is not supported.
+.sp
+Trying to convert a program that is already BASIC/A+ will appear to
+succeed, but the resulting program will be gibberish and will likely
+crash BASIC/A+ when \fBRUN\fP\&.
.SH OPTIONS
.SS General Options
.INDENT 0.0
@@ -116,6 +122,10 @@ Also, BASIC XL supports hex constants, with a leading \fB$\fP\&. A+
doesn\(aqt support these, so they get converted to the equivalent decimal
constant. This is basically a cosmetic change; \fBA=$0600\fP assigns the
same value as \fBA=1536\fP\&.
+.sp
+BASIC XL also allows some syntax that\(aqs not valid in BASIC
+A+. For instance, \fBDIR\fP is allowed with no argument in XL.
+\fBbas2aplus\fP doesn\(aqt detect these constructs.
.SH BASIC XE
.sp
BASIC XE is the last in the series of OSS BASIC interpreters. It adds
@@ -129,6 +139,11 @@ program anyway.
.B \fBHITCLR\fP, \fBINVERSE\fP, \fBNORMAL\fP, \fBBLOAD\fP, \fBBSAVE\fP
Not supported in either A+ or XL.
.UNINDENT
+.sp
+BASIC XE also allows some syntax that\(aqs not valid in either BASIC
+XL or A+. For instance, \fBIF <condition>\fP can appear as the last
+statement on a line, and \fBLVAR\fP no longer requires an argument.
+\fBbas2aplus\fP doesn\(aqt detect these constructs.
.SH TURBO BASIC
.sp
Not supported. It\(aqs also an extended version of Atari BASIC (by
diff --git a/bas2aplus.c b/bas2aplus.c
index d7768cd..ee71130 100644
--- a/bas2aplus.c
+++ b/bas2aplus.c
@@ -9,11 +9,10 @@
#undef DUMP_TABLES
-#ifdef DUMP_TABLES
#include "tokens.c"
#include "aplus_tokens.c"
#include "bxl_tokens.c"
-#endif
+#include "bxe_tokens.c"
/* there are a few more BXL commands past 0x55, but they have no
A+ equivalents. */
@@ -66,10 +65,11 @@ unsigned char cmd_table[] = {
...though BUMP( and FIND( do have A+ equivalents (they just need
a left paren inserted after) */
unsigned char op_table[] = {
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0,
- 0x0e, /* convert BXL hex const to decimal */
- 0, 0, 0, 0,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* not used: 0x00-0x07 */
+ 0xff, 0xff, 0xff, 0xff, 0xff, /* not used: 0x08-0x0c */
+ 0x0e, /* convert BXL hex const to decimal */
+ 0x0e, 0x0f, /* numeric and string consts are the same */
+ 0xff, 0xff, /* these 2 not used: 0x10-0x11 */
/* these are the same, 0x12-0x1b */
0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
@@ -171,39 +171,72 @@ void parse_args(int argc, char **argv) {
die("Only one input and one output file allowed.");
}
-CALLBACK(conv_cmd) {
- if(tok > LAST_BXL_CMD) {
- fprintf(stderr, "%s: Invalid cmd token %02x at line %d, pos %04x, skipping.\n",
- self, tok, lineno, pos);
- return;
+const char *get_tok_name(unsigned char tok, int is_cmd) {
+ if(is_cmd) {
+ if(tok <= last_command) {
+ return commands[tok];
+ } else if(tok == 0x5a) {
+ return "BASIC XL LOCAL/EXIT/PROCEDURE/CALL/SORTUP/SORTDOWN";
+ } else if(tok == 0x59 || (tok > 0x5a && tok < 0x65)) {
+ return bxe_cmds[tok - 0x57];
+ } else if(tok > last_command && tok <= 0x58) {
+ return bxl_cmds[tok - 0x38];
+ } else {
+ return "(maybe Turbo BASIC?)";
+ }
+ } else {
+ if(tok < 0x12) return "";
+ if(tok <= last_operator) {
+ return operators[tok];
+ } else if(tok <= 0x68) {
+ return bxl_ops[tok - 0x55];
+ } else {
+ return "(maybe Turbo BASIC?)";
+ }
}
+}
- program[pos] = cmd_table[tok];
- if(verbose)
- fprintf(stderr, "cmd tok %02x converted to %02x at line %d, pos %04x\n", tok, program[pos], lineno, pos);
+void unsupported_msg(unsigned char tok, int lineno, int is_cmd) {
+ fprintf(stderr, "%s: Invalid %s \"%s\" (%02x) at line %d, not converted.\n",
+ self, is_cmd ? "command" : "operator", get_tok_name(tok, is_cmd), tok, lineno);
}
-CALLBACK(conv_op) {
- unsigned char newtok;
+int is_supported_cmd(unsigned char tok, int lineno) {
+ if(tok > LAST_BXL_CMD) {
+ unsupported_msg(tok, lineno, 1);
+ return 0;
+ }
+ return 1;
+}
- if(tok < 0x12 && tok != OP_HEXCONST) return;
+int is_supported_op(unsigned char tok, int lineno) {
+ if(tok > LAST_BXL_OP || op_table[tok] == 0xff) {
+ unsupported_msg(tok, lineno, 0);
+ return 0;
+ }
+ return 1;
+}
- if(tok > LAST_BXL_OP) {
- fprintf(stderr, "%s: Invalid op token %02x at line %d, pos %04x, skipping.\n",
- self, tok, lineno, pos);
+CALLBACK(conv_cmd) {
+ if(!is_supported_cmd(tok, lineno))
return;
- }
- newtok = op_table[tok];
- if(newtok == 0xff) {
- fprintf(stderr, "%s: BXL op token %02x at line %d, pos %04x, has no A+ equivalent, skipping.\n",
- self, tok, lineno, pos);
+ program[pos] = cmd_table[tok];
+
+ if(verbose && tok != program[pos])
+ fprintf(stderr, "cmd tok \"%s\" ($%02x) converted to $%02x at line %d, pos $%04x\n",
+ get_tok_name(tok, 1), tok, program[pos], lineno, pos);
+}
+
+CALLBACK(conv_op) {
+ if(!is_supported_op(tok, lineno))
return;
- }
- program[pos] = newtok;
- if(verbose)
- fprintf(stderr, "op tok %02x converted to %02x at line %d, pos %04x\n", tok, program[pos], lineno, pos);
+ program[pos] = op_table[tok];
+
+ if(verbose && tok != program[pos])
+ fprintf(stderr, "op tok \"%s\" ($%02x) converted to $%02x at line %d, pos $%04x\n",
+ get_tok_name(tok, 0), tok, program[pos], lineno, pos);
}
int main(int argc, char **argv) {
diff --git a/bas2aplus.rst b/bas2aplus.rst
index 2ea77d4..0358091 100644
--- a/bas2aplus.rst
+++ b/bas2aplus.rst
@@ -24,6 +24,12 @@ XL/XE tokens have no equivalent in BASIC/A+, so programs using these
can't be converted (you will see messages on standard error, in that
case).
+Turbo BASIC is not supported.
+
+Trying to convert a program that is already BASIC/A+ will appear to
+succeed, but the resulting program will be gibberish and will likely
+crash BASIC/A+ when **RUN**.
+
OPTIONS
=======
@@ -91,6 +97,10 @@ doesn't support these, so they get converted to the equivalent decimal
constant. This is basically a cosmetic change; **A=$0600** assigns the
same value as **A=1536**.
+BASIC XL also allows some syntax that's not valid in BASIC
+A+. For instance, **DIR** is allowed with no argument in XL.
+**bas2aplus** doesn't detect these constructs.
+
BASIC XE
========
@@ -104,6 +114,11 @@ a few keywords to BASIC XL, which also don't exist in A+. These are:
**HITCLR**, **INVERSE**, **NORMAL**, **BLOAD**, **BSAVE**
Not supported in either A+ or XL.
+BASIC XE also allows some syntax that's not valid in either BASIC
+XL or A+. For instance, **IF <condition>** can appear as the last
+statement on a line, and **LVAR** no longer requires an argument.
+**bas2aplus** doesn't detect these constructs.
+
TURBO BASIC
===========