aboutsummaryrefslogtreecommitdiff
path: root/bas2tap.c
diff options
context:
space:
mode:
authorJuan J. Martinez <jjm@usebox.net>2023-07-29 08:12:16 +0100
committerJuan J. Martinez <jjm@usebox.net>2023-07-29 08:25:22 +0100
commitf569f70654def8f2b590fca62dbfa3e7b2b5dd8c (patch)
treeea33632775a75e9ac1caf3f12cbf09763f30dcc3 /bas2tap.c
downloadsinclair-basic-f569f70654def8f2b590fca62dbfa3e7b2b5dd8c.tar.gz
sinclair-basic-f569f70654def8f2b590fca62dbfa3e7b2b5dd8c.zip
Initial importHEADmain
Diffstat (limited to 'bas2tap.c')
-rw-r--r--bas2tap.c3286
1 files changed, 3286 insertions, 0 deletions
diff --git a/bas2tap.c b/bas2tap.c
new file mode 100644
index 0000000..f34e687
--- /dev/null
+++ b/bas2tap.c
@@ -0,0 +1,3286 @@
+/**********************************************************************************************************************************/
+/* Module : BAS2TAP.C */
+/* Executable : BAS2TAP.EXE */
+/* Doc file : BAS2TAP.DOC */
+/* Version type : Single file */
+/* Last changed : 13-06-2003 12:00 */
+/* Update count : 14 */
+/* OS type : Generic */
+/* Watcom C = wcl386 -mf -fp3 -fpi -3r -oxnt -w4 -we bas2tap.c */
+/* MS C = cl /Ox /G2 /AS bas2tap.c /F 1000 */
+/* gcc = gcc -Wall -O2 bas2tap.c -o bas2tap -lm ; strip bas2tap */
+/* SAS/C = sc link math=ieee bas2tap.c */
+/* Libs needed : math */
+/* Description : Convert ASCII BASIC file to TAP tape image emulator file */
+/* */
+/* Notes : There's a check for a define "__DEBUG__", which generates tons of output if defined. */
+/* */
+/* Written in 1998-2003 by M. van der Heide of ThunderWare Research Center. */
+/**********************************************************************************************************************************/
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+
+/**********************************************************************************************************************************/
+/* Some compilers don't define the following things, so I define them here... */
+/**********************************************************************************************************************************/
+
+#ifdef __WATCOMC__
+#define x_strnicmp(_S1,_S2,_Len) strnicmp (_S1, _S2, _Len)
+#define x_log2(_X) log2 (_X)
+#else
+int x_strnicmp (char *_S1, char *_S2, int _Len) /* Case independant partial string compare */
+{
+ for ( ; _Len && *_S1 && *_S2 && toupper (*_S1) == toupper (*_S2) ; _S1 ++, _S2 ++, _Len --)
+ ;
+ return (_Len ? (int)toupper (*_S1) - (int)toupper (*_S2) : 0);
+}
+#define x_log2(_X) (log (_X) / log (2.0)) /* If your compiler doesn't know the 'log2' function */
+#endif
+
+typedef unsigned char byte;
+#ifndef FALSE
+typedef unsigned char bool; /* If your compiler doesn't know this variable type yet */
+#define TRUE 1
+#define FALSE 0
+#endif
+
+/**********************************************************************************************************************************/
+/* Define the global variables */
+/**********************************************************************************************************************************/
+
+struct TokenMap_s
+{
+ char *Token;
+ byte TokenType;
+ /* Type 0 = No special meaning */
+ /* Type 1 = Always keyword */
+ /* Type 2 = Can be both keyword and non-keyword (colour parameters) */
+ /* Type 3 = Numeric expression token */
+ /* Type 4 = String expression token */
+ /* Type 5 = May only appear in (L)PRINT statements (AT and TAB) */
+ /* Type 6 = Type-less (normal ASCII or expression token) */
+ byte KeywordClass[8]; /* The class this keyword belongs to, as defined in the Spectrum ROM */
+ /* This table is used by expression tokens as well. Class 12 was added for this purpose */
+ /* Class 0 = No further operands */
+ /* Class 1 = Used in LET. A variable is required */
+ /* Class 2 = Used in LET. An expression, numeric or string, must follow */
+ /* Class 3 = A numeric expression may follow. Zero to be used in case of default */
+ /* Class 4 = A single character variable must follow */
+ /* Class 5 = A set of items may be given */
+ /* Class 6 = A numeric expression must follow */
+ /* Class 7 = Handles colour items */
+ /* Class 8 = Two numeric expressions, separated by a comma, must follow */
+ /* Class 9 = As for class 8 but colour items may precede the expression */
+ /* Class 10 = A string expression must follow */
+ /* Class 11 = Handles cassette routines */
+ /* The following classes are not available in the ROM but were needed */
+ /* Class 12 = One or more string expressions, separated by commas, must follow */
+ /* Class 13 = One or more expressions, separated by commas, must follow */
+ /* Class 14 = One or more variables, separated by commas, must follow (READ) */
+ /* Class 15 = DEF FN */
+} TokenMap[256] = {
+
+ /* Everything below ASCII 32 */
+ {NULL, 6, { 0 }}, {NULL, 6, { 0 }}, {NULL, 6, { 0 }}, {NULL, 6, { 0 }}, {NULL, 6, { 0 }},
+ {NULL, 6, { 0 }}, /* Print ' */
+ {NULL, 6, { 0 }}, {NULL, 6, { 0 }}, {NULL, 6, { 0 }}, {NULL, 6, { 0 }}, {NULL, 6, { 0 }}, {NULL, 6, { 0 }}, {NULL, 6, { 0 }},
+ {"(eoln)", 6, { 0 }}, /* CR */
+ {NULL, 6, { 0 }}, /* Number */
+ {NULL, 6, { 0 }},
+ {NULL, 6, { 0 }}, /* INK */
+ {NULL, 6, { 0 }}, /* PAPER */
+ {NULL, 6, { 0 }}, /* FLASH */
+ {NULL, 6, { 0 }}, /* BRIGHT */
+ {NULL, 6, { 0 }}, /* INVERSE */
+ {NULL, 6, { 0 }}, /* OVER */
+ {NULL, 6, { 0 }}, /* AT */
+ {NULL, 6, { 0 }}, /* TAB */
+ {NULL, 6, { 0 }}, {NULL, 6, { 0 }}, {NULL, 6, { 0 }}, {NULL, 6, { 0 }}, {NULL, 6, { 0 }}, {NULL, 6, { 0 }}, {NULL, 6, { 0 }},
+ {NULL, 6, { 0 }},
+
+ /* Normal ASCII set */
+ {"\x20", 6, { 0 }}, {"\x21", 6, { 0 }}, {"\x22", 6, { 0 }}, {"\x23", 6, { 0 }}, {"\x24", 6, { 0 }}, {"\x25", 6, { 0 }},
+ {"\x26", 6, { 0 }}, {"\x27", 6, { 0 }}, {"\x28", 6, { 0 }}, {"\x29", 6, { 0 }}, {"\x2A", 6, { 0 }}, {"\x2B", 6, { 0 }},
+ {"\x2C", 6, { 0 }}, {"\x2D", 6, { 0 }}, {"\x2E", 6, { 0 }}, {"\x2F", 6, { 0 }}, {"\x30", 6, { 0 }}, {"\x31", 6, { 0 }},
+ {"\x32", 6, { 0 }}, {"\x33", 6, { 0 }}, {"\x34", 6, { 0 }}, {"\x35", 6, { 0 }}, {"\x36", 6, { 0 }}, {"\x37", 6, { 0 }},
+ {"\x38", 6, { 0 }}, {"\x39", 6, { 0 }}, {"\x3A", 2, { 0 }}, {"\x3B", 6, { 0 }}, {"\x3C", 6, { 0 }}, {"\x3D", 6, { 0 }},
+ {"\x3E", 6, { 0 }}, {"\x3F", 6, { 0 }}, {"\x40", 6, { 0 }}, {"\x41", 6, { 0 }}, {"\x42", 6, { 0 }}, {"\x43", 6, { 0 }},
+ {"\x44", 6, { 0 }}, {"\x45", 6, { 0 }}, {"\x46", 6, { 0 }}, {"\x47", 6, { 0 }}, {"\x48", 6, { 0 }}, {"\x49", 6, { 0 }},
+ {"\x4A", 6, { 0 }}, {"\x4B", 6, { 0 }}, {"\x4C", 6, { 0 }}, {"\x4D", 6, { 0 }}, {"\x4E", 6, { 0 }}, {"\x4F", 6, { 0 }},
+ {"\x50", 6, { 0 }}, {"\x51", 6, { 0 }}, {"\x52", 6, { 0 }}, {"\x53", 6, { 0 }}, {"\x54", 6, { 0 }}, {"\x55", 6, { 0 }},
+ {"\x56", 6, { 0 }}, {"\x57", 6, { 0 }}, {"\x58", 6, { 0 }}, {"\x59", 6, { 0 }}, {"\x5A", 6, { 0 }}, {"\x5B", 6, { 0 }},
+ {"\x5C", 6, { 0 }}, {"\x5D", 6, { 0 }}, {"\x5E", 6, { 0 }}, {"\x5F", 6, { 0 }}, {"\x60", 6, { 0 }}, {"\x61", 6, { 0 }},
+ {"\x62", 6, { 0 }}, {"\x63", 6, { 0 }}, {"\x64", 6, { 0 }}, {"\x65", 6, { 0 }}, {"\x66", 6, { 0 }}, {"\x67", 6, { 0 }},
+ {"\x68", 6, { 0 }}, {"\x69", 6, { 0 }}, {"\x6A", 6, { 0 }}, {"\x6B", 6, { 0 }}, {"\x6C", 6, { 0 }}, {"\x6D", 6, { 0 }},
+ {"\x6E", 6, { 0 }}, {"\x6F", 6, { 0 }}, {"\x70", 6, { 0 }}, {"\x71", 6, { 0 }}, {"\x72", 6, { 0 }}, {"\x73", 6, { 0 }},
+ {"\x74", 6, { 0 }}, {"\x75", 6, { 0 }}, {"\x76", 6, { 0 }}, {"\x77", 6, { 0 }}, {"\x78", 6, { 0 }}, {"\x79", 6, { 0 }},
+ {"\x7A", 6, { 0 }}, {"\x7B", 6, { 0 }}, {"\x7C", 6, { 0 }}, {"\x7D", 6, { 0 }}, {"\x7E", 6, { 0 }}, {"\x7F", 6, { 0 }},
+
+ /* Block graphics without shift */
+ {"\x80", 6, { 0 }}, {"\x81", 6, { 0 }}, {"\x82", 6, { 0 }}, {"\x83", 6, { 0 }}, {"\x84", 6, { 0 }}, {"\x85", 6, { 0 }},
+ {"\x86", 6, { 0 }}, {"\x87", 6, { 0 }},
+
+ /* Block graphics with shift */
+ {"\x88", 6, { 0 }}, {"\x89", 6, { 0 }}, {"\x8A", 6, { 0 }}, {"\x8B", 6, { 0 }}, {"\x8C", 6, { 0 }}, {"\x8D", 6, { 0 }},
+ {"\x8E", 6, { 0 }}, {"\x8F", 6, { 0 }},
+
+ /* UDGs */
+ {"\x90", 6, { 0 }}, {"\x91", 6, { 0 }}, {"\x92", 6, { 0 }}, {"\x93", 6, { 0 }}, {"\x94", 6, { 0 }}, {"\x95", 6, { 0 }},
+ {"\x96", 6, { 0 }}, {"\x97", 6, { 0 }}, {"\x98", 6, { 0 }}, {"\x99", 6, { 0 }}, {"\x9A", 6, { 0 }}, {"\x9B", 6, { 0 }},
+ {"\x9C", 6, { 0 }}, {"\x9D", 6, { 0 }}, {"\x9E", 6, { 0 }}, {"\x9F", 6, { 0 }}, {"\xA0", 6, { 0 }}, {"\xA1", 6, { 0 }},
+ {"\xA2", 6, { 0 }},
+
+ {"SPECTRUM", 1, { 0 }}, /* For Spectrum 128 */
+ {"PLAY", 1, { 12 }},
+
+ /* BASIC tokens - expression */
+ {"RND", 3, { 0 }},
+ {"INKEY$", 4, { 0 }},
+ {"PI", 3, { 0 }},
+ {"FN", 3, { 1, '(', 13, ')', 0 }},
+ {"POINT", 3, { '(', 8, ')', 0 }},
+ {"SCREEN$", 4, { '(', 8, ')', 0 }},
+ {"ATTR", 3, { '(', 8, ')', 0 }},
+ {"AT", 5, { 8, 0 }},
+ {"TAB", 5, { 6, 0 }},
+ {"VAL$", 4, { 10, 0 }},
+ {"CODE", 3, { 10, 0 }},
+ {"VAL", 3, { 10, 0 }},
+ {"LEN", 3, { 10, 0 }},
+ {"SIN", 3, { 6, 0 }},
+ {"COS", 3, { 6, 0 }},
+ {"TAN", 3, { 6, 0 }},
+ {"ASN", 3, { 6, 0 }},
+ {"ACS", 3, { 6, 0 }},
+ {"ATN", 3, { 6, 0 }},
+ {"LN", 3, { 6, 0 }},
+ {"EXP", 3, { 6, 0 }},
+ {"INT", 3, { 6, 0 }},
+ {"SQR", 3, { 6, 0 }},
+ {"SGN", 3, { 6, 0 }},
+ {"ABS", 3, { 6, 0 }},
+ {"PEEK", 3, { 6, 0 }},
+ {"IN", 3, { 6, 0 }},
+ {"USR", 3, { 6, 0 }},
+ {"STR$", 4, { 6, 0 }},
+ {"CHR$", 4, { 6, 0 }},
+ {"NOT", 3, { 6, 0 }},
+ {"BIN", 3, { 3, 0 }},
+ {"OR", 6, { 5, 0 }}, /* -\ */
+ {"AND", 6, { 5, 0 }}, /* | */
+ {"<=", 6, { 5, 0 }}, /* | These are handled directly within ScanExpression */
+ {">=", 6, { 5, 0 }}, /* | */
+ {"<>", 6, { 5, 0 }}, /* -/ */
+ {"LINE", 6, { 0 }},
+ {"THEN", 6, { 0 }},
+ {"TO", 6, { 0 }},
+ {"STEP", 6, { 0 }},
+
+ /* BASIC tokens - keywords */
+ {"DEF FN", 1, { 15, 0 }}, /* Special treatment - insertion of call-by-value room required for the evaluator */
+ {"CAT", 1, { 11, 0 }},
+ {"FORMAT", 1, { 11, 0 }},
+ {"MOVE", 1, { 11, 0 }},
+ {"ERASE", 1, { 11, 0 }},
+ {"OPEN #", 1, { 11, 0 }},
+ {"CLOSE #", 1, { 11, 0 }},
+ {"MERGE", 1, { 11, 0 }},
+ {"VERIFY", 1, { 11, 0 }},
+ {"BEEP", 1, { 8, 0 }},
+ {"CIRCLE", 1, { 9, ',', 6, 0 }},
+ {"INK", 2, { 7, 0 }},
+ {"PAPER", 2, { 7, 0 }},
+ {"FLASH", 2, { 7, 0 }},
+ {"BRIGHT", 2, { 7, 0 }},
+ {"INVERSE", 2, { 7, 0 }},
+ {"OVER", 2, { 7, 0 }},
+ {"OUT", 1, { 8, 0 }},
+ {"LPRINT", 1, { 5, 0 }},
+ {"LLIST", 1, { 3, 0 }},
+ {"STOP", 1, { 0 }},
+ {"READ", 1, { 14, 0 }},
+ {"DATA", 2, { 13, 0 }},
+ {"RESTORE", 1, { 3, 0 }},
+ {"NEW", 1, { 0 }},
+ {"BORDER", 1, { 6, 0 }},
+ {"CONTINUE", 1, { 0 }},
+ {"DIM", 1, { 1, '(', 13, ')', 0 }},
+ {"REM", 1, { 5, 0 }}, /* (Special: taken out separately) */
+ {"FOR", 1, { 4, '=', 6, 0xCC, 6, 0xCD, 6, 0 }}, /* (Special: STEP (0xCD) is not required) */
+ {"GO TO", 1, { 6, 0 }},
+ {"GO SUB", 1, { 6, 0 }},
+ {"INPUT", 1, { 5, 0 }},
+ {"LOAD", 1, { 11, 0 }},
+ {"LIST", 1, { 3, 0 }},
+ {"LET", 1, { 1, '=', 2, 0 }},
+ {"PAUSE", 1, { 6, 0 }},
+ {"NEXT", 1, { 4, 0 }},
+ {"POKE", 1, { 8, 0 }},
+ {"PRINT", 1, { 5, 0 }},
+ {"PLOT", 1, { 9, 0 }},
+ {"RUN", 1, { 3, 0 }},
+ {"SAVE", 1, { 11, 0 }},
+ {"RANDOMIZE", 1, { 3, 0 }},
+ {"IF", 1, { 6, 0xCB, 0 }},
+ {"CLS", 1, { 0 }},
+ {"DRAW", 1, { 9, ',', 6, 0 }},
+ {"CLEAR", 1, { 3, 0 }},
+ {"RETURN", 1, { 0 }},
+ {"COPY", 1, { 0 }}};
+
+#define MAXLINELENGTH 1024
+
+char ConvertedSpectrumLine[MAXLINELENGTH + 1];
+byte ResultingLine[MAXLINELENGTH + 1];
+
+struct TapeHeader_s
+{
+ byte LenLo1;
+ byte LenHi1;
+ byte Flag1;
+ byte HType;
+ char HName[10];
+ byte HLenLo;
+ byte HLenHi;
+ byte HStartLo;
+ byte HStartHi;
+ byte HBasLenLo;
+ byte HBasLenHi;
+ byte Parity1;
+ byte LenLo2;
+ byte LenHi2;
+ byte Flag2;
+} TapeHeader = {19, 0, /* Len header */
+ 0, /* Flag header */
+ 0, {32, 32, 32, 32, 32, 32, 32, 32, 32, 32}, 0, 0, 0, 128, 0, 0, /* The header itself */
+ 0, /* Parity header */
+ 0, 0, /* Len converted BASIC */
+ 255}; /* Flag converted BASIC */
+
+int Is48KProgram = -1; /* -1 = unknown */
+ /* 1 = 48K */
+ /* 0 = 128K */
+int UsesInterface1 = -1; /* -1 = unknown */
+ /* 0 = either Interface1 or Opus Discovery */
+ /* 1 = Interface1 */
+ /* 2 = Opus Discovery */
+bool CaseIndependant = FALSE;
+bool Quiet = FALSE; /* Suppress banner and progress indication if TRUE */
+bool NoWarnings = FALSE; /* Suppress warnings if TRUE */
+bool DoCheckSyntax = TRUE;
+bool TokenBracket = FALSE;
+bool HandlingDEFFN = FALSE; /* Exceptional instruction */
+bool InsideDEFFN = FALSE;
+#define DEFFN 0xCE
+FILE *ErrStream;
+
+/**********************************************************************************************************************************/
+/* Let's be lazy and define a very commonly used error message.... */
+/**********************************************************************************************************************************/
+
+#define BADTOKEN(_Exp,_Got) fprintf (ErrStream, "ERROR in line %d, statement %d - Expected %s, but got \"%s\"\n", \
+ BasicLineNo, StatementNo, _Exp, _Got)
+
+/**********************************************************************************************************************************/
+/* And let's generate tons of debugging info too.... */
+/**********************************************************************************************************************************/
+
+#ifdef __DEBUG__
+ char ListSpaces[20];
+ int RecurseLevel;
+#endif
+
+/**********************************************************************************************************************************/
+/* Prototype all functions */
+/**********************************************************************************************************************************/
+
+int GetLineNumber (char **FirstAfter);
+int MatchToken (int BasicLineNo, bool WantKeyword, char **LineIndex, byte *Token);
+int HandleNumbers (int BasicLineNo, char **BasicLine, byte **SpectrumLine);
+int ExpandSequences (int BasicLineNo, char **BasicLine, byte **SpectrumLine, bool StripSpaces);
+int PrepareLine (char *LineIn, int FileLineNo, char **FirstToken);
+bool ScanVariable (int BasicLineNo, int StatementNo, int Keyword, byte **Index, bool *Type, int *NameLen, int AllowSlicing);
+bool SliceDirectString (int BasicLineNo, int StatementNo, int Keyword, byte **Index);
+bool ScanStream (int BasicLineNo, int StatementNo, int Keyword, byte **Index);
+bool ScanChannel (int BasicLineNo, int StatementNo, int Keyword, byte **Index, byte *WhichChannel);
+bool SignalInterface1 (int BasicLineNo, int StatementNo, int NewMode);
+bool CheckEnd (int BasicLineNo, int StatementNo, byte **Index);
+bool ScanExpression (int BasicLineNo, int StatementNo, int Keyword, byte **Index, bool *Type, int Level);
+bool HandleClass01 (int BasicLineNo, int StatementNo, int Keyword, byte **Index, bool *Type);
+bool HandleClass02 (int BasicLineNo, int StatementNo, int Keyword, byte **Index, bool Type);
+bool HandleClass03 (int BasicLineNo, int StatementNo, int Keyword, byte **Index);
+bool HandleClass04 (int BasicLineNo, int StatementNo, int Keyword, byte **Index);
+bool HandleClass05 (int BasicLineNo, int StatementNo, int Keyword, byte **Index);
+bool HandleClass06 (int BasicLineNo, int StatementNo, int Keyword, byte **Index);
+bool HandleClass07 (int BasicLineNo, int StatementNo, int Keyword, byte **Index);
+bool HandleClass08 (int BasicLineNo, int StatementNo, int Keyword, byte **Index);
+bool HandleClass09 (int BasicLineNo, int StatementNo, int Keyword, byte **Index);
+bool HandleClass10 (int BasicLineNo, int StatementNo, int Keyword, byte **Index);
+bool HandleClass11 (int BasicLineNo, int StatementNo, int Keyword, byte **Index);
+bool HandleClass12 (int BasicLineNo, int StatementNo, int Keyword, byte **Index);
+bool HandleClass13 (int BasicLineNo, int StatementNo, int Keyword, byte **Index);
+bool HandleClass14 (int BasicLineNo, int StatementNo, int Keyword, byte **Index);
+bool HandleClass15 (int BasicLineNo, int StatementNo, int Keyword, byte **Index);
+bool CheckSyntax (int BasicLineNo, byte *Line);
+
+/**********************************************************************************************************************************/
+/* Start of the program */
+/**********************************************************************************************************************************/
+
+int GetLineNumber (char **FirstAfter)
+
+/**********************************************************************************************************************************/
+/* Pre : The line must have been prepared into (global) `ConvertedSpectrumLine'. */
+/* Post : The BASIC line number has been returned, or -1 if there was none. */
+/* Import: None. */
+/**********************************************************************************************************************************/
+
+{
+ int LineNo = 0;
+ char *LineIndex;
+ bool SkipSpaces = TRUE;
+ bool Continue = TRUE;
+
+ LineIndex = ConvertedSpectrumLine;
+ while (*LineIndex && Continue)
+ if (*LineIndex == ' ') /* Skip leading spaces */
+ {
+ if (SkipSpaces)
+ LineIndex ++;
+ else
+ Continue = FALSE;
+ }
+ else if (isdigit (*LineIndex)) /* Process number */
+ {
+ LineNo = LineNo * 10 + *(LineIndex ++) - '0';
+ SkipSpaces = FALSE;
+ }
+ else
+ Continue = FALSE;
+ *FirstAfter = LineIndex;
+ if (SkipSpaces) /* Nothing found yet ? */
+ return (-1);
+ else
+ while ((**FirstAfter) == ' ') /* Skip trailing spaces */
+ (*FirstAfter) ++;
+ return (LineNo);
+}
+
+int MatchToken (int BasicLineNo, bool WantKeyword, char **LineIndex, byte *Token)
+
+/**********************************************************************************************************************************/
+/* Pre : `WantKeyword' is TRUE if we need in keyword match, `LineIndex' holds the position to match. */
+/* Post : If there was a match, the token value is returned in `Token' and `LineIndex' is pointing after the string plus any */
+/* any trailing space. */
+/* The return value is 0 for no match, -2 for an error, -1 for a match of the wrong type, 1 for a good match. */
+/* Import: None. */
+/**********************************************************************************************************************************/
+
+{
+ int Cnt;
+ size_t Length;
+ size_t LongestMatch = 0;
+ bool Match = FALSE;
+ bool Match2;
+
+ if ((**LineIndex) == ':') /* Special exception */
+ {
+ LongestMatch = 1;
+ Match = TRUE;
+ *Token = ':';
+ }
+ else for (Cnt = 0xA3 ; Cnt <= 0xFF ; Cnt ++) /* (Keywords start after the UDGs) */
+ {
+ Length = strlen (TokenMap[Cnt].Token);
+ if (CaseIndependant)
+ Match2 = !x_strnicmp (*LineIndex, TokenMap[Cnt].Token, Length);
+ else
+ Match2 = !strncmp (*LineIndex, TokenMap[Cnt].Token, Length);
+ if (Match2)
+ if (Length > LongestMatch)
+ {
+ LongestMatch = Length;
+ Match = TRUE;
+ *Token = Cnt;
+ }
+ }
+ if (!Match)
+ return (0); /* Signal: no match */
+ if (isalpha (*(*LineIndex + LongestMatch - 1)) && isalpha (*(*LineIndex + LongestMatch))) /* Continueing alpha string ? */
+ return (0); /* Then there's no match after all! (eg. 'INT' must not match 'INTER') */
+ *LineIndex += LongestMatch; /* Go past the token */
+ while ((**LineIndex) == ' ') /* Skip trailing spaces */
+ (*LineIndex) ++;
+ if (*Token == 0xA3 || *Token == 0xA4) /* 'SPECTRUM' or 'PLAY' ? */
+ switch (Is48KProgram) /* Then the program must be 128K */
+ {
+ case -1 : Is48KProgram = 0; break; /* Set the flag */
+ case 1 : fprintf (ErrStream, "ERROR - Line %d contains a 128K keyword, but the program\n"
+ "also uses UDGs \'T\' and/or \'U\'\n", BasicLineNo);
+ return (-2);
+ case 0 : break;
+ }
+ if ((WantKeyword && TokenMap[*Token].TokenType == 0) || /* Wanted keyword but got something else */
+ (!WantKeyword && TokenMap[*Token].TokenType == 1)) /* Did not want a keyword but got one nonetheless */
+ return (-1); /* Signal: match, but of wrong type */
+ else
+ return (1); /* Signal: match! */
+}
+
+int HandleNumbers (int BasicLineNo, char **BasicLine, byte **SpectrumLine)
+
+/**********************************************************************************************************************************/
+/* Pre : `BasicLineNo' holds the current BASIC line number, `BasicLine' points into the line, `SpectrumLine' points to the */
+/* TAPped Spectrum line. */
+/* Post : If there was a (floating point) number at this position, it has been processed into `SpectrumLine' and `LineIndex' is */
+/* pointing after the number. */
+/* The return value is: 0 = no number, 1 = number done, -1 = number error (already reported). */
+/* Import: None. */
+/**********************************************************************************************************************************/
+
+{
+#define SHIFT31BITS (double)2147483648.0 /* (= 2^31) */
+ char *StartOfNumber;
+ double Value = 0.0;
+ double Divider = 1.0;
+ double Exp = 0.0;
+ int IntValue;
+ byte Sign = 0x00;
+ unsigned long Mantissa;
+
+ if (!isdigit (**BasicLine) && /* Current character is not a digit ? */
+ (**BasicLine) != '.') /* And not a decimal point (eg. '.5') ? */
+ return (0); /* Then it can hardly be a number */
+ StartOfNumber = *BasicLine;
+ while (isdigit (**BasicLine)) /* First read the integer part */
+ Value = Value * 10 + *((*BasicLine) ++) - '0';
+ if ((**BasicLine) == '.') /* Decimal point ? */
+ { /* Read the decimal part */
+ (*BasicLine) ++;
+ while (isdigit (**BasicLine))
+ Value = Value + (Divider /= 10) * (*((*BasicLine) ++) - '0');
+ }
+ if ((**BasicLine) == 'e' || (**BasicLine) == 'E') /* Exponent ? */
+ {
+ (*BasicLine) ++;
+ if ((**BasicLine) == '+') /* Both "Ex" and "E+x" do the same thing */
+ (*BasicLine) ++;
+ else if ((**BasicLine) == '-') /* Negative exponent */
+ {
+ Sign = 0xFF;
+ (*BasicLine) ++;
+ }
+ while (isdigit (**BasicLine)) /* Read the exponent value */
+ Exp = Exp * 10 + *((*BasicLine) ++) - '0';
+ if (Sign == 0x00) /* Raise the resulting value to the read exponent */
+ Value = Value * pow (10.0, Exp);
+ else
+ Value = Value / pow (10.0, Exp);
+ }
+ strncpy ((char *)*SpectrumLine, StartOfNumber, *BasicLine - StartOfNumber); /* Insert the ASCII value first */
+ (*SpectrumLine) += (*BasicLine - StartOfNumber);
+ IntValue = (int)floor (Value);
+ if (Value == IntValue && Value >= -65536 && Value < 65536) /* Small integer ? */
+ {
+ *((*SpectrumLine) ++) = 0x0E; /* Insert number marker */
+ *((*SpectrumLine) ++) = 0x00;
+ if (IntValue >= 0) /* Insert sign */
+ *((*SpectrumLine) ++) = 0x00;
+ else
+ {
+ *((*SpectrumLine) ++) = 0xFF;
+ IntValue += 65536; /* Maintain bug in Spectrum ROM - INT(-65536) will result in -1 */
+ }
+ *((*SpectrumLine) ++) = (byte)(IntValue & 0xFF);
+ *((*SpectrumLine) ++) = (byte)(IntValue >> 8);
+ *((*SpectrumLine) ++) = 0x00;
+ }
+ else /* Need to store in full floating point format */
+ {
+ if (Value < 0)
+ {
+ Sign = 0x80; /* Sign bit is high bit of byte 2 */
+ Value = -Value;
+ }
+ else
+ Sign = 0x00;
+ Exp = floor (x_log2 (Value));
+ if (Exp < -129 || Exp > 126)
+ {
+ fprintf (ErrStream, "ERROR - Number too big in line %d\n", BasicLineNo);
+ return (-1);
+ }
+ Mantissa = (unsigned long)floor ((Value / pow (2.0, Exp) - 1.0) * SHIFT31BITS + 0.5); /* Calculate mantissa */
+ *((*SpectrumLine) ++) = 0x0E; /* Insert number marker */
+ *((*SpectrumLine) ++) = (byte)Exp + 0x81; /* Insert exponent */
+ *((*SpectrumLine) ++) = (byte)((Mantissa >> 24) & 0x7F) | Sign; /* Insert mantissa */
+ *((*SpectrumLine) ++) = (byte)((Mantissa >> 16) & 0xFF); /* (Big endian!) */
+ *((*SpectrumLine) ++) = (byte)((Mantissa >> 8) & 0xFF);
+ *((*SpectrumLine) ++) = (byte)(Mantissa & 0xFF);
+ }
+ return (1);
+}
+
+int ExpandSequences (int BasicLineNo, char **BasicLine, byte **SpectrumLine, bool StripSpaces)
+
+/**********************************************************************************************************************************/
+/* Pre : `BasicLineNo' holds the current BASIC line number, `BasicLine' points into the line, `SpectrumLine' points to the */
+/* TAPped Spectrum line. */
+/* Post : If there was an expandable '{...}' sequence at this position, it has been processed into `SpectrumLine', `LineIndex' */
+/* is pointing after the sequence. Returned is -1 for error, 0 for no expansion, 1 for expansion. */
+/* Import: None. */
+/**********************************************************************************************************************************/
+
+{
+ char *StartOfSequence;
+ byte Attribute = 0;
+ byte AttributeLength = 0;
+ byte AttributeVal1 = 0;
+ byte AttributeVal2 = 0;
+ byte OldCharacter;
+ int Cnt;
+
+ if (**BasicLine != '{')
+ return (0);
+ StartOfSequence = (*BasicLine) + 1;
+ /* 'CODE' and 'CAT' were added for the sole purpuse of allowing them to be OPEN #'ed as channels! */
+ if (!x_strnicmp (StartOfSequence, "CODE}", 5)) /* Special: 'CODE' */
+ {
+ *((*SpectrumLine) ++) = 0xAF;
+ (*BasicLine) += 6;
+ return (1);
+ }
+ if (!x_strnicmp (StartOfSequence, "CAT}", 4)) /* Special: 'CAT' */
+ {
+ *((*SpectrumLine) ++) = 0xCF;
+ (*BasicLine) += 5;
+ return (1);
+ }
+ if (!x_strnicmp (StartOfSequence, "(C)}", 4))
+ { /* Form "{(C)}" -> copyright sign */
+ *((*SpectrumLine) ++) = 0x7F;
+ (*BasicLine) += 5;
+ if (StripSpaces)
+ while ((**BasicLine) == ' ') /* Skip trailing spaces */
+ (*BasicLine) ++;
+ return (1);
+ }
+ if (*StartOfSequence == '+' && *(StartOfSequence + 1) >= '1' && *(StartOfSequence + 1) <= '8' && *(StartOfSequence + 2) == '}')
+ { /* Form "{+X}" -> block graphics with shift */
+ *((*SpectrumLine) ++) = 0x88 + (((*(StartOfSequence + 1) - '0') % 8) ^ 7);
+ (*BasicLine) += 4;
+ if (StripSpaces)
+ while ((**BasicLine) == ' ')
+ (*BasicLine) ++;
+ return (1);
+ }
+ if (*StartOfSequence == '-' && *(StartOfSequence + 1) >= '1' && *(StartOfSequence + 1) <= '8' && *(StartOfSequence + 2) == '}')
+ { /* Form "{-X}" -> block graphics without shift */
+ *((*SpectrumLine) ++) = 0x80 + (*(StartOfSequence + 1) - '0') % 8;
+ (*BasicLine) += 4;
+ if (StripSpaces)
+ while ((**BasicLine) == ' ')
+ (*BasicLine) ++;
+ return (1);
+ }
+ if (toupper (*StartOfSequence) >= 'A' && toupper (*StartOfSequence) <= 'U' && *(StartOfSequence + 1) == '}')
+ { /* Form "{X}" -> UDG */
+ if (toupper (*StartOfSequence) == 'T' || toupper (*StartOfSequence) == 'U') /* 'T' or 'U' ? */
+ switch (Is48KProgram) /* Then the program must be 48K */
+ {
+ case -1 : Is48KProgram = 1; break; /* Set the flag */
+ case 0 : fprintf (ErrStream, "ERROR - Line %d contains UDGs \'T\' and/or \'U\'\n"
+ "but the program was already marked 128K\n", BasicLineNo);
+ return (-1);
+ case 1 : break;
+ }
+ *((*SpectrumLine) ++) = 0x90 + toupper (*StartOfSequence) - 'A';
+ (*BasicLine) += 3;
+ if (StripSpaces)
+ while ((**BasicLine) == ' ')
+ (*BasicLine) ++;
+ return (1);
+ }
+ if (isxdigit (*StartOfSequence) && isxdigit (*(StartOfSequence + 1)) && *(StartOfSequence + 2) == '}')
+ { /* Form "{XX}" -> below 32 */
+ if (*StartOfSequence <= '9')
+ (**SpectrumLine) = *StartOfSequence - '0';
+ else
+ (**SpectrumLine) = toupper (*StartOfSequence) - 'A' + 10;
+ if (*(StartOfSequence + 1) <= '9')
+ (**SpectrumLine) = (**SpectrumLine) * 16 + *(StartOfSequence + 1) - '0';
+ else
+ (**SpectrumLine) = (**SpectrumLine) * 16 + toupper (*(StartOfSequence + 1)) - 'A' + 10;
+ (*SpectrumLine) ++;
+ (*BasicLine) += 4;
+ if (StripSpaces)
+ while ((**BasicLine) == ' ')
+ (*BasicLine) ++;
+ return (1);
+ }
+ if (!x_strnicmp (StartOfSequence, "INK", 3))
+ {
+ Attribute = 0x10;
+ AttributeLength = 3;
+ }
+ else if (!x_strnicmp (StartOfSequence, "PAPER", 5))
+ {
+ Attribute = 0x11;
+ AttributeLength = 5;
+ }
+ else if (!x_strnicmp (StartOfSequence, "FLASH", 5))
+ {
+ Attribute = 0x12;
+ AttributeLength = 5;
+ }
+ else if (!x_strnicmp (StartOfSequence, "BRIGHT", 6))
+ {
+ Attribute = 0x13;
+ AttributeLength = 6;
+ }
+ else if (!x_strnicmp (StartOfSequence, "INVERSE", 7))
+ {
+ Attribute = 0x14;
+ AttributeLength = 7;
+ }
+ else if (!x_strnicmp (StartOfSequence, "OVER", 4))
+ {
+ Attribute = 0x15;
+ AttributeLength = 4;
+ }
+ else if (!x_strnicmp (StartOfSequence, "AT", 2))
+ {
+ Attribute = 0x16;
+ AttributeLength = 2;
+ }
+ else if (!x_strnicmp (StartOfSequence, "TAB", 3))
+ {
+ Attribute = 0x17;
+ AttributeLength = 3;
+ }
+ if (Attribute > 0)
+ {
+ StartOfSequence += AttributeLength;
+ while (*StartOfSequence == ' ')
+ StartOfSequence ++;
+ while (isdigit (*StartOfSequence))
+ AttributeVal1 = AttributeVal1 * 10 + *(StartOfSequence ++) - '0';
+ if (Attribute == 0x16 || Attribute == 0x17)
+ {
+ if (*StartOfSequence != ',')
+ Attribute = 0;
+ else
+ {
+ StartOfSequence ++; /* (Step past the comma) */
+ while (*StartOfSequence == ' ')
+ StartOfSequence ++;
+ while (isdigit (*StartOfSequence))
+ AttributeVal2 = AttributeVal2 * 10 + *(StartOfSequence ++) - '0';
+ }
+ }
+ if (*StartOfSequence != '}') /* Need closing bracket */
+ Attribute = 0;
+ if (Attribute > 0)
+ {
+ *((*SpectrumLine) ++) = Attribute;
+ *((*SpectrumLine) ++) = AttributeVal1;
+ if (Attribute == 0x16 || Attribute == 0x17)
+ *((*SpectrumLine) ++) = AttributeVal2;
+ (*BasicLine) = StartOfSequence + 1;
+ if (StripSpaces)
+ while ((**BasicLine) == ' ')
+ (*BasicLine) ++;
+ return (1);
+ }
+ }
+ if (!NoWarnings)
+ {
+ for (Cnt = 0 ; *((*BasicLine) + Cnt) && *((*BasicLine) + Cnt) != '}' ; Cnt ++)
+ ;
+ if (*((*BasicLine) + Cnt) == '}')
+ {
+ OldCharacter = *((*BasicLine) + Cnt + 1);
+ *((*BasicLine) + Cnt + 1) = '\0';
+ printf ("WARNING - Unexpandable sequence \"%s\" in line %d\n", (*BasicLine), BasicLineNo);
+ *((*BasicLine) + Cnt + 1) = OldCharacter;
+ return (0);
+ }
+ }
+ return (0);
+}
+
+int PrepareLine (char *LineIn, int FileLineNo, char **FirstToken)
+
+/**********************************************************************************************************************************/
+/* Pre : `LineIn' points to the read line, `FileLineNo' holds the real line number. */
+/* Post : Multiple spaces have been removed (unless within a string), the BASIC line number has been found and `FirstToken' is */
+/* pointing at the first non-whitespace character after the line number. */
+/* Bad characters are reported, as well as any other error. The return value is the BASIC line number, -1 if error, or */
+/* -2 if the (empty!) line should be skipped. */
+/* Import: GetLineNumber. */
+/**********************************************************************************************************************************/
+
+{
+ char *IndexIn;
+ char *IndexOut;
+ bool InString = FALSE;
+ bool SingleSeparator = FALSE;
+ bool StillOk = TRUE;
+ bool DoingREM = FALSE;
+ int BasicLineNo = -1;
+ static int PreviousBasicLineNo = -1;
+
+ IndexIn = LineIn;
+ IndexOut = ConvertedSpectrumLine;
+ while (*IndexIn && StillOk)
+ {
+ if (*IndexIn == '\t') /* EXCEPTION: Print ' */
+ {
+ *(IndexOut ++) = 0x06;
+ IndexIn ++;
+ }
+ else if (*IndexIn < 32 || *IndexIn >= 127) /* (Exclude copyright sign as well) */
+ StillOk = FALSE;
+ else
+ {
+ if (!DoingREM)
+ if (!x_strnicmp (IndexIn, " REM ", 5) || /* Going through REM statement ? */
+ !x_strnicmp (IndexIn, ":REM ", 5))
+ DoingREM = TRUE; /* Signal: copy anything and everything ASCII */
+ if (InString || DoingREM)
+ *(IndexOut ++) = *IndexIn;
+ else
+ {
+ if (*IndexIn == ' ')
+ {
+ if (!SingleSeparator) /* Remove multiple spaces */
+ {
+ SingleSeparator = TRUE;
+ *(IndexOut ++) = *IndexIn;
+ }
+ }
+ else
+ {
+ SingleSeparator = FALSE;
+ *(IndexOut ++) = *IndexIn;
+ }
+ }
+ if (*IndexIn == '\"' && !DoingREM)
+ InString = !InString;
+ IndexIn ++;
+ }
+ }
+ *IndexOut = '\0';
+ if (!StillOk)
+ if (*IndexIn == 0x0D || *IndexIn == 0x0A) /* 'Correct' for end-of-line */
+ StillOk = TRUE; /* (Accept CR and/or LF as end-of-line) */
+ BasicLineNo = GetLineNumber (FirstToken);
+ if (InString)
+ fprintf (ErrStream, "ERROR - %s line %d misses terminating quote\n",
+ BasicLineNo < 0 ? "ASCII" : "BASIC", BasicLineNo < 0 ? FileLineNo : BasicLineNo);
+ else if (!StillOk)
+ fprintf (ErrStream, "ERROR - %s line %d contains a bad character (code %02Xh)\n",
+ BasicLineNo < 0 ? "ASCII" : "BASIC", BasicLineNo < 0 ? FileLineNo : BasicLineNo, *IndexIn);
+ else if (BasicLineNo < 0) /* Could not read line number */
+ {
+ if (!(**FirstToken)) /* Line is completely empty ? */
+ {
+ if (!NoWarnings)
+ printf ("WARNING - Skipping empty ASCII line %d\n", FileLineNo);
+ return (-2); /* Signal: skip entire line */
+ }
+ else
+ {
+ fprintf (ErrStream, "ERROR - Missing line number in ASCII line %d\n", FileLineNo);
+ StillOk = FALSE;
+ }
+ }
+ else if (PreviousBasicLineNo >= 0) /* Not the first line ? */
+ {
+ if (BasicLineNo < PreviousBasicLineNo) /* This line number smaller than previous ? */
+ {
+ fprintf (ErrStream, "ERROR - Line number %d is smaller than previous line number %d\n", BasicLineNo, PreviousBasicLineNo);
+ StillOk = FALSE;
+ }
+ else if (BasicLineNo == PreviousBasicLineNo && !NoWarnings) /* Same line number as previous ? */
+ printf ("WARNING - Duplicate use of line number %d\n", BasicLineNo); /* (BASIC can handle it after all...) */
+ }
+ else if (!(**FirstToken)) /* Line contains only a line number ? */
+ {
+ fprintf (ErrStream, "ERROR - Line %d contains no statements!\n", BasicLineNo);
+ StillOk = FALSE;
+ }
+ PreviousBasicLineNo = BasicLineNo; /* Remember this line number */
+ if (!InString && StillOk)
+ return (BasicLineNo);
+ else
+ return (-1);
+}
+
+bool CheckEnd (int BasicLineNo, int StatementNo, byte **Index)
+
+/**********************************************************************************************************************************/
+/* Pre : `BasicLineNo' holds the line number, `StatementNo' the statement number, `Index' the current position in the line. */
+/* Post : A check is made whether the end of the current statement has been reached. */
+/* If so, an error is reported and TRUE is returned (so FALSE indicates that everything is still fine and dandy). */
+/* Import: none. */
+/**********************************************************************************************************************************/
+
+{
+ if (**Index == ':' || **Index == 0x0D) /* End of statement or end of line ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Unexpected end of statement\n", BasicLineNo, StatementNo);
+ return (TRUE);
+ }
+ return (FALSE);
+}
+
+bool ScanVariable (int BasicLineNo, int StatementNo, int Keyword, byte **Index, bool *Type, int *NameLen, int AllowSlicing)
+
+/**********************************************************************************************************************************/
+/* Pre : `BasicLineNo' holds the line number, `StatementNo' the statement number, `Keyword' the keyword to which this operand */
+/* belongs, `Index' the current position in the line. */
+/* `AllocSlicing' is one of the following values: */
+/* -1 = Don't check for slicing/indexing (used by DEF FN) */
+/* 0 = No slicing/indexing allowed */
+/* 1 = Either slicing or indexing may follow (indices being numeric) */
+/* 2 = Only numeric indexing may follow (used by LET and READ) */
+/* Post : A check has been made whether there's a variable at the current position. If so, it has been skipped. */
+/* Slicing is handled here as well, but notice that this is not necessarily correct! */
+/* Single letter string variables can be either flat or array and both possibilities are considered here. */
+/* Both "a$(1 TO 10)" and "a$(1, 2)" are correct to BASIC, but depend on whether a "DIM" statement was used. */
+/* The length of the found string (without any '$') is returned in `NameLen', its type is returned in `Type' (TRUE for */
+/* numeric and FALSE for string variables). The return value is TRUE is all went well. Errors have already been reported. */
+/* The return value is FALSE either when no variable is at this point or an error was found. */
+/* `NameLen' is returned 0 if no variable was detected here, or > 0 if in error. */
+/* Import: ScanExpression. */
+/**********************************************************************************************************************************/
+
+{
+ bool SubType;
+ bool IsArray = FALSE;
+ bool SetTokenBracket = FALSE;
+
+ Keyword = Keyword; /* (Keep compilers happy) */
+ *Type = TRUE; /* Assume it will be numeric */
+ *NameLen = 0;
+ if (!isalpha (**Index)) /* The first character must be alphabetic for a variable */
+ return (FALSE);
+ *NameLen = 1;
+ while (isalnum (*(++ (*Index)))) /* Read on, until end of the word */
+ (*NameLen) ++;
+ if (**Index == '$') /* It's a string variable ? */
+ {
+ if (*NameLen > 1) /* String variables can only have a single character name */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - String variables can only have single character names\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ (*Index) ++;
+ *Type = FALSE;
+ }
+#ifdef __DEBUG__
+ printf ("DEBUG - %sScanVariable, Type is %s\n", ListSpaces, *Type ? "NUM" : "ALPHA");
+#endif
+ if (AllowSlicing >= 0 && **Index == '(') /* Slice the string ? */
+ {
+#ifdef __DEBUG__
+ printf ("DEBUG - %sScanVariable, reading index\n", ListSpaces);
+#endif
+ if (*NameLen > 1) /* Arrays can only have a single character name */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Arrays can only have single character names\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ if (AllowSlicing == 0) /* Slicing/Indexing not allowed ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Slicing/Indexing not allowed\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ (*Index) ++; /* (Skip the bracket) */
+ if (**Index == ')') /* Empty slice "a$()" is not ok */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Empty array index not allowed\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ if (**Index == 0xCC) /* "a$( TO num)" or "a$( TO )" */
+ {
+ if (AllowSlicing == 2)
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Slicing token \"TO\" inappropriate for arrays\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ }
+ else /* Not "a$( TO num)" nor "a$( TO )" */
+ {
+ if (!TokenBracket)
+ {
+ TokenBracket = TRUE; /* Allow complex expression */
+ SetTokenBracket = TRUE;
+ }
+ if (!ScanExpression (BasicLineNo, StatementNo, '(', Index, &SubType, 0)) /* First parameter */
+ return (FALSE);
+ if (SetTokenBracket)
+ TokenBracket = FALSE;
+ if (!SubType) /* Must be numeric */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Variables indices must be numeric\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ if (**Index == ')') /* "a$(num)" is ok */
+ {
+ (*Index) ++;
+#ifdef __DEBUG__
+ printf ("DEBUG - %sScanVariable, index ending, next char is \"%s\"\n", ListSpaces, TokenMap[**Index].Token);
+#endif
+ return (TRUE);
+ }
+ }
+ if (**Index != 0xCC && **Index != ',') /* Either an array or a slice */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Unexpected index character \"%c\"\n",
+ BasicLineNo, StatementNo, **Index);
+ return (FALSE);
+ }
+ if (**Index == ',')
+ IsArray = TRUE;
+ else
+ {
+ if (AllowSlicing == 2)
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Slicing token \"TO\" inappropriate for arrays\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ if (*Type) /* Only character strings can be sliced */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Only character strings can be sliced\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ }
+ do
+ {
+ (*Index) ++; /* Skip each "," (or the "TO" for non-arrays) */
+ if (!TokenBracket)
+ {
+ TokenBracket = TRUE;
+ SetTokenBracket = TRUE;
+ }
+ if (!ScanExpression (BasicLineNo, StatementNo, '(', Index, &SubType, 0)) /* Second or further parameter */
+ return (FALSE);
+ if (SetTokenBracket)
+ TokenBracket = FALSE;
+ if (!SubType) /* Must be numeric */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Variables indices must be numeric\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ if (!IsArray && **Index != ')')
+ {
+ BADTOKEN ("\")\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ else if (IsArray && **Index != ',' && **Index != ')')
+ {
+ BADTOKEN ("\",\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ }
+ while (**Index != ')');
+ (*Index) ++; /* (Step past closing bracket) */
+#ifdef __DEBUG__
+ printf ("DEBUG - %sScanVariable, index ending, next char is \"%s\"\n", ListSpaces, TokenMap[**Index].Token);
+#endif
+ }
+ return (TRUE);
+}
+
+bool SliceDirectString (int BasicLineNo, int StatementNo, int Keyword, byte **Index)
+
+/**********************************************************************************************************************************/
+/* Pre : `BasicLineNo' holds the line number, `StatementNo' the statement number, `Keyword' the keyword to which this operand */
+/* belongs, `Index' the current position in the line. */
+/* A direct string has just been read and a '(' character is currently under the cursor. */
+/* Post : Slicing is handled here. */
+/* Possible are "string"(), "string"(num), "string"( TO ), "string"(num TO ), "string"( TO num) and "string"(num TO num). */
+/* The return value is FALSE if an error was found (which has already been reported here). */
+/* Import: ScanExpression. */
+/**********************************************************************************************************************************/
+
+{
+ bool SubType;
+ bool SetTokenBracket = FALSE;
+
+ Keyword = Keyword; /* (Keep compilers happy) */
+ (*Index) ++; /* Step past the opening bracket */
+ if (**Index == ')') /* Empty slice "abc"() is ok */
+ {
+ (*Index) ++;
+ return (TRUE);
+ }
+ if (**Index != 0xCC) /* Not "abc"( TO num) nor "abc"( TO ) */
+ {
+ if (!TokenBracket)
+ {
+ TokenBracket = TRUE;
+ SetTokenBracket = TRUE;
+ }
+ if (!ScanExpression (BasicLineNo, StatementNo, '(', Index, &SubType, 0)) /* First parameter */
+ return (FALSE);
+ if (SetTokenBracket)
+ TokenBracket = FALSE;
+ if (!SubType) /* Must be numeric */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Slice values must be numeric\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ }
+ if (**Index == ')') /* "abc"(num) is ok */
+ {
+ (*Index) ++;
+ return (TRUE);
+ }
+ if (**Index != 0xCC) /* ('TO') */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Unexpected index character\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ (*Index) ++;
+ if (**Index == ')') /* "abc"(num TO ) is ok */
+ {
+ (*Index) ++;
+ return (TRUE);
+ }
+ if (!TokenBracket)
+ {
+ TokenBracket = TRUE;
+ SetTokenBracket = TRUE;
+ }
+ if (!ScanExpression (BasicLineNo, StatementNo, '(', Index, &SubType, 0)) /* Second parameter */
+ return (FALSE);
+ if (SetTokenBracket)
+ TokenBracket = FALSE;
+ if (!SubType) /* Must be numeric */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Slice values must be numeric\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ if (**Index != ')')
+ {
+ BADTOKEN ("\")\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ (*Index) ++; /* (Step past closing bracket) */
+ return (TRUE);
+}
+
+bool ScanStream (int BasicLineNo, int StatementNo, int Keyword, byte **Index)
+
+/**********************************************************************************************************************************/
+/* Pre : `BasicLineNo' holds the line number, `StatementNo' the statement number, `Keyword' the keyword to which this operand */
+/* belongs, `Index' the current position in the line. */
+/* A stream hash mark (`#') has just been read. */
+/* Post : The following stream number is checked to be a numeric expression. */
+/* The return value is FALSE if an error was found (which has already been reported here). */
+/* Import: HandleClass06. */
+/**********************************************************************************************************************************/
+
+{
+ if (!SignalInterface1 (BasicLineNo, StatementNo, 0))
+ return (FALSE);
+ return (HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)); /* Find numeric expression */
+}
+
+bool SignalInterface1 (int BasicLineNo, int StatementNo, int NewMode)
+
+/**********************************************************************************************************************************/
+/* Pre : `BasicLineNo' holds the line number, `StatementNo' the statement number, `NewMode' holds the required hardware mode. */
+/* Post : The required hardware is tested for conflicts. */
+/* The return value is FALSE if there was a conflict (which has already been reported here). */
+/* Import: none. */
+/**********************************************************************************************************************************/
+
+{
+ if ((NewMode == 1 && UsesInterface1 == 2) || /* Interface1 required, but already flagged Opus ? */
+ (NewMode == 2 && UsesInterface1 == 1)) /* Opus required, but already flagged Interface1 ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - The program uses commands that are specific\n"
+ "for Interface 1 and Opus Discovery, but don't exist on both devices\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ UsesInterface1 = NewMode;
+ return (TRUE);
+}
+
+bool ScanChannel (int BasicLineNo, int StatementNo, int Keyword, byte **Index, byte *WhichChannel)
+
+/**********************************************************************************************************************************/
+/* Pre : `BasicLineNo' holds the line number, `StatementNo' the statement number, `Keyword' the keyword to which this operand */
+/* belongs, `Index' the current position in the line. */
+/* Post : A channel identifier of the form "x";n; must follow. `x' is a single alphanumeric character, `n' is a numeric */
+/* expression, the rest are required characters. */
+/* The found channel identifier ('x') is returned (in lowercase) in `WhichChannel'. */
+/* The return value is FALSE if an error was found (which has already been reported here). */
+/* Import: HandleClass06, CheckEnd. */
+/**********************************************************************************************************************************/
+
+{
+ int NeededHardware = 0; /* (Default to Interface 1) */
+
+ *WhichChannel = '\0';
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ if (**Index != '\"')
+ {
+ if (!HandleClass06 (BasicLineNo, StatementNo, Keyword, Index))/* EXCEPTION: The Opus allows '<num>' to abbreviate '"m";<num>' */
+ {
+ fprintf (ErrStream, "Expected to find a channel identifier\n");
+ return (FALSE);
+ }
+ *WhichChannel = 'm';
+ if (!SignalInterface1 (BasicLineNo, StatementNo, 2)) /* Signal the Opus specificness */
+ return (FALSE);
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ if (**Index != ';')
+ {
+ BADTOKEN ("\";\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ (*Index) ++;
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ }
+ else
+ {
+ (*Index) ++;
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ if (!isalpha (**Index) && /* (Ordinary channel) */
+ **Index != '#' && /* (Linked channel, OPEN # only) */
+ **Index != 0xAF && /* ('CODE' channel, OPEN # only) */
+ **Index != 0xCF) /* ('CAT' channel, OPEN # only) */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Channel name must be alphanumeric\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ *WhichChannel = tolower (**Index);
+ (*Index) ++;
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ if (**Index != '\"')
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Channel name must be single character\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ (*Index) ++;
+ if (*WhichChannel == 'k' || *WhichChannel == 's' || *WhichChannel == 'p' || /* (Normal Spectrum channels) */
+ *WhichChannel == 'm' || *WhichChannel == 't' || *WhichChannel == 'b' ||
+ *WhichChannel == '#' || *WhichChannel == 0xCF) /* ('CAT' channel) */
+ NeededHardware = 0;
+ else if (*WhichChannel == 'n') /* Network channel is available on Interface 1 but not on Opus */
+ NeededHardware = 1;
+ else if (*WhichChannel == 'j' || /* (Opus: Joystick channel) */
+ *WhichChannel == 'd' || /* (Opus: disk channel) */
+ *WhichChannel == 0xAF) /* (Opus: 'CODE' channel) */
+ NeededHardware = 2;
+ if (!SignalInterface1 (BasicLineNo, StatementNo, NeededHardware))
+ return (FALSE);
+ if (*WhichChannel == 'm' || *WhichChannel == 'd' || *WhichChannel == 'n' || /* Continue checking with these channels only */
+ *WhichChannel == '#' || *WhichChannel == 0xCF)
+ {
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ if (**Index != ';')
+ {
+ BADTOKEN ("\";\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ (*Index) ++;
+ if (!HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)) /* Find numeric expression */
+ return (FALSE);
+ if (*WhichChannel == 'm') /* Omly the 'm' channel requires a ';' character following */
+ {
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ if (**Index != ';')
+ {
+ BADTOKEN ("\";\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ (*Index) ++;
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ }
+ }
+ }
+ return (TRUE);
+}
+
+bool ScanExpression (int BasicLineNo, int StatementNo, int Keyword, byte **Index, bool *Type, int Level)
+
+/**********************************************************************************************************************************/
+/* Pre : `BasicLineNo' holds the line number, `StatementNo' the statement number, `Keyword' the keyword to which this operand */
+/* belongs, `Index' the current position in the line. */
+/* `Level' is used for recursion and must be 0 when called, unless when cassed from ScanVariable (then it must be 1). */
+/* Post : An expression must be found, either numerical or string. Its type is returned in `Type' (TRUE for numerical). */
+/* All subexpressions, between brackets, are dealt with using recursion. */
+/* The return value is FALSE if an error was found (which has already been reported here). */
+/* Import: ScanExpression (recursive), SliceDirectString, ScanVariable, HandleClassXX. */
+/**********************************************************************************************************************************/
+
+{
+ bool More = TRUE;
+ bool SubType = TRUE; /* (Assume numeric expression) */
+ bool SubSubType;
+ bool TypeKnown = FALSE;
+ bool TotalTypeKnown = FALSE;
+ bool Dummy;
+ int VarNameLen;
+ int ClassIndex = -1;
+ byte ThisToken;
+
+#ifdef __DEBUG__
+ RecurseLevel ++;
+ memset (ListSpaces, ' ', RecurseLevel * 2);
+ ListSpaces[RecurseLevel * 2] = '\0';
+ printf ("DEBUG - %sEnter ScanExpression\n", ListSpaces);
+#endif
+ if (**Index == '+' || **Index == '-') /* Unary plus and minus */
+ {
+ *Type = TRUE; /* Then we expect a numeric expression */
+ TypeKnown = TRUE;
+ (*Index) ++; /* Skip the sign */
+ }
+ while (More)
+ {
+#ifdef __DEBUG__
+ printf ("DEBUG - %sScanExpression sub (keyword \"%s\"), first char is \"%s\"\n",
+ ListSpaces, TokenMap[Keyword].Token, TokenMap[**Index].Token);
+#endif
+ if (**Index == '(') /* Opening bracket ? */
+ {
+#ifdef __DEBUG__
+ printf ("DEBUG - %sRecurse ScanExpression for \"(\"\n", ListSpaces);
+#endif
+ (*Index) ++; /* The 'parent' steps past the opening bracket */
+ if (!ScanExpression (BasicLineNo, StatementNo, '(', Index, &SubSubType, Level + 1)) /* Recurse */
+ return (FALSE);
+ if (TypeKnown && SubSubType != SubType) /* Bad subexpression type ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Type conflict in expression\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ else if (!TypeKnown) /* We didn't have an expected type yet ? */
+ {
+ SubType = SubSubType;
+ TypeKnown = TRUE;
+ }
+ (*Index) ++; /* The 'parent' steps past the closing bracket too */
+ if (**Index == '(') /* Slicing ? */
+ {
+ if (!SubSubType) /* Result was a string ? */
+ {
+ if (!SliceDirectString (BasicLineNo, StatementNo, Keyword, Index))
+ return (FALSE);
+ }
+ else /* No, it was numerical, which you can't slice */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - cannot slice a numerical value\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ }
+ }
+ else if (**Index == ')') /* Closing bracket ? */
+ { /* Leave the bracket for the parent, to allow functions (eg. "ATTR (...)") */
+ if (!TotalTypeKnown) /* 'Simple' expression ? */
+ *Type = SubType; /* Set return type */
+#ifdef __DEBUG__
+ printf ("DEBUG - %sLeave ScanExpression, Type is %s next char is \"%s\"\n",
+ ListSpaces, *Type ? "NUM" : "ALPHA", TokenMap[**Index].Token);
+ if (-- RecurseLevel > 0)
+ memset (ListSpaces, ' ', RecurseLevel * 2);
+ ListSpaces[RecurseLevel * 2] = '\0';
+#endif
+ return (TRUE); /* Step out of the recursion */
+ }
+ else if (**Index == ':' || **Index == 0x0D) /* End of statement or end of line ? */
+ {
+ if (!TotalTypeKnown) /* 'Simple' expression ? */
+ *Type = SubType; /* Set return type */
+ if (Level) /* Not on lowest level ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - too few closing brackets\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ More = FALSE;
+ }
+ else if (isdigit (**Index) || **Index == '.') /* Number ? */
+ {
+ if (!TypeKnown) /* Unknown expression type yet ? */
+ {
+ TypeKnown = TRUE; /* Signal: it is numeric */
+ SubType = TRUE;
+ }
+ else if (!SubType) /* Type was known to be string ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Type conflict in expression\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ while (*(++ (*Index)) != 0x0E) /* Skip until the number marker */
+ ;
+ (*Index) ++;
+ }
+ else if (**Index == '\"') /* Direct string ? */
+ {
+ if (!TypeKnown) /* Unknown expression type yet ? */
+ {
+ TypeKnown = TRUE; /* Signal: it is a string */
+ SubType = FALSE;
+ }
+ else if (SubType) /* Type was known to be numeric ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Type conflict in expression\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ while (**Index == '\"') /* Concatenated strings are ok, since they allow the use of the " character */
+ {
+ while (*(++ (*Index)) != '\"') /* Find closing quote */
+ ;
+ (*Index) ++; /* Step past it */
+ }
+ if (**Index == '(') /* String is sliced ? */
+ if (!SliceDirectString (BasicLineNo, StatementNo, Keyword, Index))
+ return (FALSE);
+ }
+ else if (ScanVariable (BasicLineNo, StatementNo, Keyword, Index, &SubSubType, &VarNameLen, 1)) /* Is it a variable ? */
+ {
+ if (!TypeKnown) /* Unknown expression type yet ? */
+ {
+ TypeKnown = TRUE; /* Signal: it is string */
+ SubType = SubSubType;
+ }
+ else if (SubType != SubSubType) /* Different type variable ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Type conflict in expression\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ }
+ else if (VarNameLen != 0) /* (Not a variable) */
+ return (FALSE); /* (But an error that was already reported) */
+ /* It's none of the above. Go check tokens */
+ else switch (TokenMap[**Index].TokenType)
+ {
+ case 0 : fprintf (ErrStream, "ERROR in line %d, statement %d - Unexpected token \"%s\"\n",
+ BasicLineNo, StatementNo, TokenMap[**Index].Token);
+ return (FALSE);
+ case 1 :
+ case 2 : fprintf (ErrStream, "ERROR in line %d, statement %d - Unexpected keyword \"%s\"\n",
+ BasicLineNo, StatementNo, TokenMap[**Index].Token);
+ return (FALSE);
+ case 3 :
+ case 4 :
+ case 5 : ThisToken = *((*Index) ++);
+ if (TokenMap[ThisToken].TokenType == 5)
+ {
+ if (Keyword != 0xF5 && Keyword != 0xE0) /* Not handling a PRINT or LPRINT ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Unexpected token \"%s\"\n",
+ BasicLineNo, StatementNo, TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ }
+ else if (ThisToken == 0xC0 && **Index == '\"') /* Special: USR "x" */
+ {
+ (*Index) ++; /* (Step past the opening quote) */
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ if (toupper (**Index) < 'A' || toupper (**Index) > 'U') /* Bad UDG character ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Bad UDG \"%s\"\n",
+ BasicLineNo, StatementNo, TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ (*Index) ++;
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ if (**Index != '\"') /* More than one letter ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - An UDG name may be only 1 letter\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ (*Index) --;
+ if (toupper (**Index) == 'T' || toupper (**Index) == 'U') /* One of the UDGs 'T' or 'U' ? */
+ switch (Is48KProgram) /* Then the program must be 48K */
+ {
+ case -1 : Is48KProgram = 1; break; /* Set the flag */
+ case 0 : fprintf (ErrStream, "ERROR - Line %d contains UDGs \'T\' and/or \'U\'\n"
+ "but the program was already marked 128K\n", BasicLineNo);
+ return (FALSE);
+ case 1 : break;
+ }
+ (*Index) += 2; /* Step past the UDG name and closing quote */
+ break; /* Done, step out */
+ }
+ else
+ {
+ if (!TypeKnown) /* Unknown expression type yet ? */
+ {
+ TypeKnown = TRUE; /* Set expected type */
+ SubType = (TokenMap[ThisToken].TokenType == 3);
+ }
+ else if ((SubType && TokenMap[ThisToken].TokenType == 4) ||
+ (!SubType && TokenMap[ThisToken].TokenType == 3))
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Type conflict in expression\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ }
+ ClassIndex = -1;
+ while (TokenMap[ThisToken].KeywordClass[++ ClassIndex]) /* Handle all class parameters */
+ {
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ else if (TokenMap[ThisToken].KeywordClass[ClassIndex] >= 32) /* Required token or class ? */
+ {
+ if (**Index != TokenMap[ThisToken].KeywordClass[ClassIndex]) /* (Required token) */
+ { /* (Token not there) */
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Expected \"%c\", but got \"%s\"\n",
+ BasicLineNo, StatementNo, TokenMap[ThisToken].KeywordClass[ClassIndex], TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ else
+ {
+ if (**Index == '(')
+ {
+#ifdef __DEBUG__
+ printf ("DEBUG - %sTurning on token bracket\n", ListSpaces);
+#endif
+ TokenBracket = TRUE;
+ }
+ else if (**Index == ')')
+ {
+#ifdef __DEBUG__
+ printf ("DEBUG - %sTurning off token bracket\n", ListSpaces);
+#endif
+ TokenBracket = FALSE;
+ }
+ (*Index) ++;
+ }
+ }
+ else /* (Command class) */
+ switch (TokenMap[ThisToken].KeywordClass[ClassIndex])
+ {
+ case 1 : if (!HandleClass01 (BasicLineNo, StatementNo, ThisToken, Index, &Dummy)) /* (Special: FN) */
+ return (FALSE);
+ break;
+ case 3 : if (!HandleClass03 (BasicLineNo, StatementNo, ThisToken, Index))
+ return (FALSE);
+ break;
+ case 5 : if (!HandleClass05 (BasicLineNo, StatementNo, ThisToken, Index))
+ return (FALSE);
+ break;
+ case 6 : if (!HandleClass06 (BasicLineNo, StatementNo, ThisToken, Index))
+ return (FALSE);
+ break;
+ case 8 : if (!HandleClass08 (BasicLineNo, StatementNo, ThisToken, Index))
+ return (FALSE);
+ break;
+ case 10 : if (!HandleClass10 (BasicLineNo, StatementNo, ThisToken, Index))
+ return (FALSE);
+ break;
+ case 12 : if (!HandleClass12 (BasicLineNo, StatementNo, ThisToken, Index))
+ return (FALSE);
+ break;
+ case 13 : if (!HandleClass13 (BasicLineNo, StatementNo, ThisToken, Index))
+ return (FALSE);
+ break;
+ case 14 : if (!HandleClass14 (BasicLineNo, StatementNo, ThisToken, Index))
+ return (FALSE);
+ break;
+ }
+ }
+ if (ThisToken == 0xA6) /* INKEY$ ? */
+ if (**Index == '#') /* Type 'INKEY$#<stream>' ? */
+ {
+ (*Index) ++;
+ if (!ScanStream (BasicLineNo, StatementNo, ThisToken, Index))
+ return (FALSE);
+ }
+ break;
+ }
+ /* Piece done, continue */
+ if (More)
+ {
+ if (**Index == 0xC5 || **Index == 0xC6) /* ('OR' and 'AND') */
+ {
+#ifdef __DEBUG__
+ printf ("DEBUG - %sRecurse ScanExpression for \"%s\"\n", ListSpaces, TokenMap[**Index].Token);
+#endif
+ if (!TotalTypeKnown) /* 'Simple' expression before the AND/OR ? */
+ *Type = SubType;
+ if (**Index == 0xC5 && !*Type)
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - \"OR\" requires a numeric left value\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ ThisToken = *((*Index) ++); /* Step over the operator - but remember it */
+ if (!ScanExpression (BasicLineNo, StatementNo, ThisToken, Index, &SubSubType, 0)) /* Recurse - at level 0! */
+ return (FALSE);
+ if (!SubSubType) /* The expression at the right must be numeric for both AND and OR */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - \"%s\" requires a numeric right value\n",
+ BasicLineNo, StatementNo, TokenMap[ThisToken].Token);
+ return (FALSE);
+ }
+ if (!TypeKnown) /* We didn't have an expected type yet ? */
+ {
+ TypeKnown = TRUE;
+ TotalTypeKnown = TRUE;
+ SubType = *Type = (bool)(ThisToken == 0xC6 && !*Type ? FALSE : TRUE); /* Signal resulting type */
+ /* x$ AND y -> result is string */
+ /* x AND y -> result is numeric */
+ /* x OR y -> result is numeric */
+ }
+ More = FALSE; /* (Because the recursing causes the expression to be evaluated right to left, we're done now) */
+ }
+ else if ((**Index == '=' || **Index == '<' || **Index == '>' || /* EXCEPTION: equations between brackets (side effects) */
+ **Index == 0xC7 || **Index == 0xC8 || **Index == 0xC9) && /* ("<=", ">=" and "<>") */
+ Level) /* Not on level 0: that is handled below! */
+ { /* Expressions like 'LET A=(INKEY$="A")'; we're now between these brackets */
+ SubType = *Type = TRUE; /* Signal: result is going to be numeric */
+ TotalTypeKnown = TRUE;
+ TypeKnown = FALSE; /* Start with a fresh subexpression type */
+ (*Index) ++;
+ }
+ else if ((TokenMap[Keyword].TokenType != 4 && TokenMap[Keyword].TokenType != 3) || /* Not evaluating an expression token ? */
+ TokenBracket) /* Or evaluating an operand of a token ? */
+ {
+ if (**Index == '+') /* (Can apply to both string and numeric expressions) */
+ (*Index) ++;
+ else if (**Index == '-' || **Index == '*' || **Index == '/' || **Index == '^') /* (Numeric only) */
+ {
+ if (!SubType) /* Type was known to be string ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Type conflict in expression\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ (*Index) ++;
+ }
+ /* Equations and logical operators turn the total result numeric, but each subexpression may be of any type */
+ else if ((**Index == '=' || **Index == '<' || **Index == '>' ||
+ **Index == 0xC7 || **Index == 0xC8 || **Index == 0xC9) && /* ("<=", ">=" and "<>") */
+ !Level) /* Only evaluate these on level 0! */
+ {
+ TotalTypeKnown = TRUE;
+ *Type = TRUE; /* Signal: result is going to be numeric */
+ TypeKnown = FALSE; /* Start with a fresh subexpression type */
+ (*Index) ++;
+ }
+ else
+ More = FALSE;
+ }
+ else
+ More = FALSE;
+ }
+ }
+ if (!TotalTypeKnown) /* 'Simple' expression ? */
+ *Type = SubType; /* Set return type */
+#ifdef __DEBUG__
+ printf ("DEBUG - %sLeave ScanExpression, Type is %s, next char is \"%s\"\n",
+ ListSpaces, *Type ? "NUM" : "ALPHA", TokenMap[**Index].Token);
+ if (-- RecurseLevel > 0)
+ memset (ListSpaces, ' ', RecurseLevel * 2);
+ ListSpaces[RecurseLevel * 2] = '\0';
+#endif
+ return (TRUE);
+}
+
+bool HandleClass01 (int BasicLineNo, int StatementNo, int Keyword, byte **Index, bool *Type)
+
+/**********************************************************************************************************************************/
+/* Class 1 = Used in LET. A variable is required. */
+/* `Type' is returned to handle the rest of this special statement (HandleClass02) */
+/* This function is also used to parse the variable name for DIM and FN. */
+/**********************************************************************************************************************************/
+
+{
+ int VarNameLen;
+ int ParseArray;
+
+#ifdef __DEBUG__
+ printf ("DEBUG - %sLine %d, statement %d, Enter Class 1, keyword \"%s\", next is \"%s\"\n",
+ ListSpaces, BasicLineNo, StatementNo, TokenMap[Keyword].Token, TokenMap[**Index].Token);
+#endif
+ ParseArray = ((Keyword == 0xA8 || Keyword == 0xE9) ? -1 : 2); /* Do not parse any bracketing if checking DIM or FN */
+ if (!ScanVariable (BasicLineNo, StatementNo, Keyword, Index, Type, &VarNameLen, ParseArray))
+ {
+ if (VarNameLen == 0)
+ BADTOKEN ("variable", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ return (TRUE);
+}
+
+bool HandleClass02 (int BasicLineNo, int StatementNo, int Keyword, byte **Index, bool Type)
+
+/**********************************************************************************************************************************/
+/* Class 2 = Used in LET. An expression, numeric or string, must follow. */
+/* `Type' is the type as returned previously by the HandleClass01 call */
+/**********************************************************************************************************************************/
+
+{
+ bool SubType;
+
+#ifdef __DEBUG__
+ printf ("DEBUG - %sLine %d, statement %d, Enter Class 2, keyword \"%s\", next is \"%s\"\n",
+ ListSpaces, BasicLineNo, StatementNo, TokenMap[Keyword].Token, TokenMap[**Index].Token);
+#endif
+ if (!ScanExpression (BasicLineNo, StatementNo, Keyword, Index, &SubType, 0))
+ return (FALSE);
+ if (SubType != Type) /* Must match */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Bad assignment expression type\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ return (TRUE);
+}
+
+bool HandleClass03 (int BasicLineNo, int StatementNo, int Keyword, byte **Index)
+
+/**********************************************************************************************************************************/
+/* Class 3 = A numeric expression may follow. Zero to be used in case of default. */
+/**********************************************************************************************************************************/
+
+{
+#ifdef __DEBUG__
+ printf ("DEBUG - %sLine %d, statement %d, Enter Class 3, keyword \"%s\", next is \"%s\"\n",
+ ListSpaces, BasicLineNo, StatementNo, TokenMap[Keyword].Token, TokenMap[**Index].Token);
+#endif
+ if (**Index == ':' || **Index == 0x0D) /* No expression following ? */
+ return (TRUE); /* Then we're done already */
+ if (Keyword == 0xFD && **Index == '#') /* EXCEPTION: CLEAR may take a stream rather than a numeric expression */
+ {
+ (*Index) ++;
+ if (!SignalInterface1 (BasicLineNo, StatementNo, 0)) /* (Which is Interface1/Opus specific) */
+ return (FALSE);
+ if (**Index == ':' || **Index == 0x0D) /* No expression following ? */
+ return (TRUE); /* (An empty stream is allowed as well - it clears all streams at once) */
+ }
+ return (HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)); /* Find numeric expression */
+}
+
+bool HandleClass04 (int BasicLineNo, int StatementNo, int Keyword, byte **Index)
+
+/**********************************************************************************************************************************/
+/* Class 4 = A single character variable must follow. */
+/**********************************************************************************************************************************/
+
+{
+ bool Type;
+ int VarNameLen;
+
+#ifdef __DEBUG__
+ printf ("DEBUG - %sLine %d, statement %d, Enter Class 4, keyword \"%s\", next is \"%s\"\n",
+ ListSpaces, BasicLineNo, StatementNo, TokenMap[Keyword].Token, TokenMap[**Index].Token);
+#endif
+ if (!ScanVariable (BasicLineNo, StatementNo, Keyword, Index, &Type, &VarNameLen, 0))
+ {
+ if (VarNameLen == 0)
+ BADTOKEN ("variable", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ if (VarNameLen != 1 || !Type) /* Not single letter or not a numeric variable ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Wrong variable type\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ return (TRUE);
+}
+
+bool HandleClass05 (int BasicLineNo, int StatementNo, int Keyword, byte **Index)
+
+/**********************************************************************************************************************************/
+/* Class 5 = A set of items may be given. */
+/**********************************************************************************************************************************/
+
+{
+ bool Type;
+ bool More = TRUE;
+ int VarNameLen;
+
+#ifdef __DEBUG__
+ printf ("DEBUG - %sLine %d, statement %d, Enter Class 5, keyword \"%s\", next is \"%s\"\n",
+ ListSpaces, BasicLineNo, StatementNo, TokenMap[Keyword].Token, TokenMap[**Index].Token);
+#endif
+ while (More)
+ {
+ while (**Index == ';' || **Index == ',' || **Index == '\'') /* One of the separator characters ? */
+ (*Index) ++; /* (More than one may follow) */
+ if (**Index == ':' || **Index == 0x0D) /* End of statement or end of line ? */
+ More = FALSE;
+ else if (**Index == '#') /* A stream ? */
+ {
+ (*Index) ++; /* (Step past the '#' mark) */
+ if (!ScanStream (BasicLineNo, StatementNo, Keyword, Index))
+ return (FALSE);
+ }
+ else if (TokenMap[**Index].TokenType == 2 || /* A colour parameter ? */
+ **Index == 0xAD) /* TAB ? */
+ {
+ (*Index) ++; /* (Skip the token) */
+ if (!HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)) /* Find parameter (numeric expression) */
+ return (FALSE);
+ }
+ else if (**Index == 0xAC) /* AT ? */
+ {
+ (*Index) ++; /* (Skip the token) */
+ if (!HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)) /* Find first parameter (numeric expression) */
+ return (FALSE);
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ if (**Index != ',') /* (Required separator token) */
+ {
+ BADTOKEN ("\",\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ (*Index) ++; /* (Skip the token) */
+ if (!HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)) /* Find second parameter (numeric expression) */
+ return (FALSE);
+ }
+ else if (Keyword == 0xEE && **Index == 0xCA) /* INPUT may use LINE */
+ {
+ (*Index) ++; /* (Skip the token) */
+ if (!ScanVariable (BasicLineNo, StatementNo, Keyword, Index, &Type, &VarNameLen, 0))
+ {
+ if (VarNameLen == 0)
+ BADTOKEN ("variable", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ if (Type) /* Not a alphanumeric variable ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - INPUT LINE requires an alphanumeric variable\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ }
+ else if (!ScanExpression (BasicLineNo, StatementNo, Keyword, Index, &Type, 0)) /* Get expression */
+ return (FALSE);
+ }
+ return (TRUE);
+}
+
+bool HandleClass06 (int BasicLineNo, int StatementNo, int Keyword, byte **Index)
+
+/**********************************************************************************************************************************/
+/* Class 6 = A numeric expression must follow. */
+/**********************************************************************************************************************************/
+
+{
+ bool Type = FALSE;
+
+#ifdef __DEBUG__
+ printf ("DEBUG - %sLine %d, statement %d, Enter Class 6, keyword \"%s\", next is \"%s\"\n",
+ ListSpaces, BasicLineNo, StatementNo, TokenMap[Keyword].Token, TokenMap[**Index].Token);
+#endif
+ if (!ScanExpression (BasicLineNo, StatementNo, Keyword, Index, &Type, 0)) /* Get expression */
+ return (FALSE);
+ if (!Type && Keyword != 0xC0) /* Must be numeric */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Expected numeric expression\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ return (TRUE);
+}
+
+bool HandleClass07 (int BasicLineNo, int StatementNo, int Keyword, byte **Index)
+
+/**********************************************************************************************************************************/
+/* Class 7 = Handles colour items. */
+/* Effectively the same as Class 6 */
+/**********************************************************************************************************************************/
+
+{
+#ifdef __DEBUG__
+ printf ("DEBUG - %sLine %d, statement %d, Enter Class 7, keyword \"%s\", next is \"%s\"\n",
+ ListSpaces, BasicLineNo, StatementNo, TokenMap[Keyword].Token, TokenMap[**Index].Token);
+#endif
+ return (HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)); /* Find numeric expression */
+}
+
+bool HandleClass08 (int BasicLineNo, int StatementNo, int Keyword, byte **Index)
+
+/**********************************************************************************************************************************/
+/* Class 8 = Two numeric expressions, separated by a comma, must follow. */
+/**********************************************************************************************************************************/
+
+{
+#ifdef __DEBUG__
+ printf ("DEBUG - %sLine %d, statement %d, Enter Class 8, keyword \"%s\", next is \"%s\"\n",
+ ListSpaces, BasicLineNo, StatementNo, TokenMap[Keyword].Token, TokenMap[**Index].Token);
+#endif
+ if (!HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)) /* Find first numeric expression */
+ return (FALSE);
+ if (**Index != ',')
+ {
+ BADTOKEN ("\",\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ (*Index) ++;
+ return (HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)); /* Find second numeric expression */
+}
+
+bool HandleClass09 (int BasicLineNo, int StatementNo, int Keyword, byte **Index)
+
+/**********************************************************************************************************************************/
+/* Class 9 = As for class 8 but colour items may precede the expression. */
+/* Used only by PLOT and DRAW. Colour items are TokenType 2 */
+/**********************************************************************************************************************************/
+
+{
+ bool CheckColour = TRUE;
+
+#ifdef __DEBUG__
+ printf ("DEBUG - %sLine %d, statement %d, Enter Class 9, keyword \"%s\", next is \"%s\"\n",
+ ListSpaces, BasicLineNo, StatementNo, TokenMap[Keyword].Token, TokenMap[**Index].Token);
+#endif
+ while (CheckColour)
+ {
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ if (TokenMap[**Index].TokenType == 2) /* A colour parameter ? */
+ {
+ (*Index) ++; /* Skip the token */
+ if (!HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)) /* Find parameter (numeric expression) */
+ return (FALSE);
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ if (**Index != ';') /* All colour parameters must be separated with semicolons */
+ {
+ BADTOKEN ("\";\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ (*Index) ++; /* Skip the ";' */
+ }
+ else
+ CheckColour = FALSE;
+ }
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ return (HandleClass08 (BasicLineNo, StatementNo, Keyword, Index));
+}
+
+bool HandleClass10 (int BasicLineNo, int StatementNo, int Keyword, byte **Index)
+
+/**********************************************************************************************************************************/
+/* Class 10 = A string expression must follow. */
+/**********************************************************************************************************************************/
+
+{
+ bool Type;
+
+#ifdef __DEBUG__
+ printf ("DEBUG - %sLine %d, statement %d, Enter Class 10, keyword \"%s\", next is \"%s\"\n",
+ ListSpaces, BasicLineNo, StatementNo, TokenMap[Keyword].Token, TokenMap[**Index].Token);
+#endif
+ if (!ScanExpression (BasicLineNo, StatementNo, Keyword, Index, &Type, 0)) /* Get expression */
+ return (FALSE);
+ if (Type) /* Must be string */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Expected string expression\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ return (TRUE);
+}
+
+bool HandleClass11 (int BasicLineNo, int StatementNo, int Keyword, byte **Index)
+
+/**********************************************************************************************************************************/
+/* Class 11 = Handles cassette routines. */
+/**********************************************************************************************************************************/
+
+{
+ bool Type;
+ int VarNameLen;
+ int MoveLoop;
+ byte WhichChannel = '\0'; /* (Default is no channel; for tape) */
+
+#ifdef __DEBUG__
+ printf ("DEBUG - %sLine %d, statement %d, Enter Class 11, keyword \"%s\", next is \"%s\"\n",
+ ListSpaces, BasicLineNo, StatementNo, TokenMap[Keyword].Token, TokenMap[**Index].Token);
+#endif
+ switch (Keyword)
+ {
+ case 0xEF: /* (LOAD) */
+ case 0xD6: /* (VERIFY) */
+ case 0xD5: if (**Index == '*') /* (MERGE) */
+ {
+ (*Index) ++;
+ if (!ScanChannel (BasicLineNo, StatementNo, Keyword, Index, &WhichChannel))
+ return (FALSE);
+ if (WhichChannel != 'm' && WhichChannel != 'b' && WhichChannel != 'n')
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - You cannot LOAD/VERIFY/MERGE from the \"%s\" channel\n",
+ BasicLineNo, StatementNo, TokenMap[WhichChannel].Token);
+ return (FALSE);
+ }
+ }
+ else if (**Index == '!') /* 128K RAM-bank ? */
+ {
+ (*Index) ++;
+ switch (Is48KProgram) /* Then the program must be 128K */
+ {
+ case -1 : Is48KProgram = 0; break; /* Set the flag */
+ case 1 : fprintf (ErrStream, "ERROR - Line %d contains 128K file I/O, but the program\n"
+ "also uses UDGs \'T\' and/or \'U\'\n", BasicLineNo);
+ return (FALSE);
+ case 0 : break;
+ }
+ }
+ if (WhichChannel != '\0' && WhichChannel != 'm') /* Not tape nor microdrive/disk channel ? */
+ {
+ if (**Index != ':' && **Index != 0x0D && /* (End of statement) */
+ **Index != 0xAF && /* (CODE) */
+ **Index != 0xE4 && /* (DATA) */
+ **Index != 0xCA && /* (LINE) */
+ **Index != 0xAA) /* (SCREEN$) */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - The \"%s\" channel does not use filenames\n",
+ BasicLineNo, StatementNo, TokenMap[WhichChannel].Token);
+ return (FALSE);
+ }
+ }
+ else
+ {
+ if (**Index == '\"') /* Look for a filename */
+ {
+ while (**Index == '\"') /* Concatenated strings are ok, since they allow the use of the " character */
+ { /* (And an empty string is allowed here as well) */
+ while (*(++ (*Index)) != '\"') /* Find closing quote */
+ if (**Index == 0x0D) /* End of line ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Unexpected end of line\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ (*Index) ++; /* Step past it */
+ }
+ }
+ else if (**Index == ':' || **Index == 0x0D || /* (End of statement) */
+ **Index == 0xAF || /* (CODE) */
+ **Index == 0xE4 || /* (DATA) */
+ **Index == 0xCA || /* (LINE) */
+ **Index == 0xAA) /* (SCREEN$) */
+ {
+ BADTOKEN ("filename", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ else if (!HandleClass10 (BasicLineNo, StatementNo, Keyword, Index)) /* Look for a string expression */
+ return (FALSE);
+ }
+ if (**Index != ':' && **Index != 0x0D) /* (Continue unless end of statement) */
+ {
+ if (**Index == 0xAF) /* CODE */
+ {
+ if (Keyword == 0xD5) /* (We were doing MERGE ?) */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Cannot MERGE CODE\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ (*Index) ++;
+ if (**Index != ':' && **Index != 0x0D) /* Optional address ? */
+ {
+ if (!HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)) /* Find address (numeric expression) */
+ return (FALSE);
+ if (**Index == ',') /* Also optional length ? */
+ {
+ (*Index) ++;
+ if (!HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)) /* Find length (numeric expression) */
+ return (FALSE);
+ }
+ else if (**Index != ':' && **Index != 0x0D)
+ {
+ BADTOKEN ("\",\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ }
+ }
+ else if (**Index == 0xAA) /* SCREEN$ */
+ (*Index) ++;
+ else if (**Index == 0xE4) /* DATA */
+ {
+ (*Index) ++;
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ if (!ScanVariable (BasicLineNo, StatementNo, Keyword, Index, &Type, &VarNameLen, -1))
+ {
+ if (VarNameLen == 0)
+ BADTOKEN ("variable", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ if (VarNameLen != 1) /* Not single letter ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Wrong variable type; must be single character\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ if (**Index != '(') /* The variable must be followed by an empty index */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - DATA requires an array\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ (*Index) ++;
+ if (**Index != ')')
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - DATA requires an empty array index\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ (*Index) ++;
+ }
+ else
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Unknown file-type \"%s\"\n",
+ BasicLineNo, StatementNo, TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ }
+ break;
+ case 0xF8: if (**Index == '*') /* (SAVE) */
+ {
+ (*Index) ++;
+ if (!ScanChannel (BasicLineNo, StatementNo, Keyword, Index, &WhichChannel))
+ return (FALSE);
+ if (WhichChannel != 'm' && WhichChannel != 'b' && WhichChannel != 'n')
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - You cannot SAVE to the \"%s\" channel\n",
+ BasicLineNo, StatementNo, TokenMap[WhichChannel].Token);
+ return (FALSE);
+ }
+ }
+ else if (**Index == '!') /* 128K RAM-bank ? */
+ {
+ (*Index) ++;
+ switch (Is48KProgram) /* Then the program must be 128K */
+ {
+ case -1 : Is48KProgram = 0; break; /* Set the flag */
+ case 1 : fprintf (ErrStream, "ERROR - Line %d contains 128K file I/O, but the program\n"
+ "also uses UDGs \'T\' and/or \'U\'\n", BasicLineNo);
+ return (FALSE);
+ case 0 : break;
+ }
+ }
+ if (WhichChannel != '\0' && WhichChannel != 'm') /* Not tape nor microdrive/disk channel ? */
+ {
+ if (**Index != ':' && **Index != 0x0D && /* (End of statement) */
+ **Index != 0xAF && /* (CODE) */
+ **Index != 0xE4 && /* (DATA) */
+ **Index != 0xCA && /* (LINE) */
+ **Index != 0xAA) /* (SCREEN$) */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - The \"%s\" channel does not use filenames\n",
+ BasicLineNo, StatementNo, TokenMap[WhichChannel].Token);
+ return (FALSE);
+ }
+ }
+ else
+ {
+ if (**Index == '\"') /* Look for a filename */
+ {
+ if (*(*Index + 1) == '\"' && /* Empty string (not allowed) ? */
+ *(*Index + 2) != '\"') /* Concatenation - first char is a " (allowed) ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Empty filename not allowed\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ while (**Index == '\"') /* Concatenated strings are ok, since they allow the use of the " character */
+ {
+ while (*(++ (*Index)) != '\"') /* Find closing quote */
+ if (**Index == 0x0D) /* End of line ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Unexpected end of line\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ (*Index) ++; /* Step past it */
+ }
+ }
+ else if (**Index == ':' || **Index == 0x0D || /* (End of statement) */
+ **Index == 0xAF || /* (CODE) */
+ **Index == 0xE4 || /* (DATA) */
+ **Index == 0xCA || /* (LINE) */
+ **Index == 0xAA) /* (SCREEN$) */
+ {
+ BADTOKEN ("filename", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ else if (!HandleClass10 (BasicLineNo, StatementNo, Keyword, Index)) /* Look for a string expression */
+ return (FALSE);
+ }
+ if (**Index != ':' && **Index != 0x0D) /* (Continue unless end of statement) */
+ {
+ if (**Index == 0xAF) /* CODE */
+ {
+ (*Index) ++;
+ if (!HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)) /* Find address (numeric expression) */
+ return (FALSE);
+ if (**Index != ',')
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - %s CODE requires both address and length\n",
+ BasicLineNo, StatementNo, TokenMap[Keyword].Token);
+ return (FALSE);
+ }
+ (*Index) ++;
+ if (!HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)) /* Find length (numeric expression) */
+ return (FALSE);
+ }
+ else if (**Index == 0xE4) /* DATA */
+ {
+ (*Index) ++;
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ if (!ScanVariable (BasicLineNo, StatementNo, Keyword, Index, &Type, &VarNameLen, -1))
+ {
+ if (VarNameLen == 0)
+ BADTOKEN ("variable", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ if (VarNameLen != 1) /* Not single letter ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Wrong variable type; must be single character\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ if (**Index != '(') /* The variable must be followed by an empty index */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - DATA requires an array\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ (*Index) ++;
+ if (**Index != ')')
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - DATA requires an empty array index\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ (*Index) ++;
+ }
+ else if (**Index == 0xAA) /* SCREEN$ */
+ (*Index) ++;
+ else if (**Index == 0xCA) /* LINE */
+ {
+ (*Index) ++;
+ if (!HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)) /* Find starting line (numeric expression) */
+ return (FALSE);
+ }
+ else
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Unknown file-type \"%s\"\n",
+ BasicLineNo, StatementNo, TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ }
+ break;
+ case 0xCF: if (!SignalInterface1 (BasicLineNo, StatementNo, 0)) /* (CAT) */
+ return (FALSE);
+ if (**Index == '#') /* A stream may precede the drive number */
+ {
+ (*Index) ++;
+ if (!ScanStream (BasicLineNo, StatementNo, Keyword, Index))
+ return (FALSE);
+ if (**Index != ',') /* (Required separator token) */
+ {
+ BADTOKEN ("\",\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ }
+ if (!HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)) /* Find drive number (numeric expression) */
+ return (FALSE);
+ break;
+ case 0xD0: if (!ScanChannel (BasicLineNo, StatementNo, Keyword, Index, &WhichChannel)) /* (FORMAT) */
+ return (FALSE);
+ switch (WhichChannel)
+ {
+ case 'm' : if (CheckEnd (BasicLineNo, StatementNo, Index)) /* "m" requires an additional new volume name */
+ return (FALSE);
+ if (**Index == '\"') /* Look for a volume name */
+ {
+ if (*(*Index + 1) == '\"' && /* Empty string (not allowed) ? */
+ *(*Index + 2) != '\"') /* Concatenation - first char is a " (allowed) ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Empty volume name not allowed\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ while (**Index == '\"') /* Concatenated strings are ok, since they allow the use of the " character */
+ {
+ while (*(++ (*Index)) != '\"') /* Find closing quote */
+ if (**Index == 0x0D) /* End of line ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Unexpected end of line\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ (*Index) ++; /* Step past it */
+ }
+ }
+ else if (!HandleClass10 (BasicLineNo, StatementNo, Keyword, Index)) /* Look for a string expression */
+ return (FALSE);
+ break;
+ case 't' : /* The port channels requires an additional baud rate */
+ case 'b' :
+ case 'j' : if (**Index != ';') /* The joystick channel requires a operand to turn it on or off */
+ {
+ BADTOKEN ("\";\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ (*Index) ++;
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ if (!HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)) /* Look for a numeric expression */
+ return (FALSE);
+ break;
+ default : fprintf (ErrStream, "ERROR in line %d, statement %d - You cannot FORMAT from the \"%s\" channel\n",
+ BasicLineNo, StatementNo, TokenMap[WhichChannel].Token);
+ return (FALSE);
+ }
+ break;
+ case 0xD1: for (MoveLoop = 0 ; MoveLoop < 2 ; MoveLoop ++) /* (MOVE) */
+ {
+ if (**Index == '#')
+ {
+ (*Index) ++; /* (Step past the '#' mark) */
+ if (!ScanStream (BasicLineNo, StatementNo, Keyword, Index))
+ return (FALSE);
+ }
+ else
+ {
+ if (!ScanChannel (BasicLineNo, StatementNo, Keyword, Index, &WhichChannel))
+ return (FALSE);
+ switch (WhichChannel)
+ {
+ case 'm' : if (CheckEnd (BasicLineNo, StatementNo, Index)) /* "m" requires an additional filename */
+ return (FALSE);
+ if (**Index == '\"') /* Look for a filename */
+ {
+ if (*(*Index + 1) == '\"' && /* Empty string (not allowed) ? */
+ *(*Index + 2) != '\"') /* Concatenation - first char is a " (allowed) ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Empty filename not allowed\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ while (**Index == '\"')
+ {
+ while (*(++ (*Index)) != '\"')
+ if (**Index == 0x0D)
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Unexpected end of line\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ (*Index) ++;
+ }
+ }
+ else if (!HandleClass10 (BasicLineNo, StatementNo, Keyword, Index))
+ return (FALSE);
+ break;
+ case 't' :
+ case 'b' :
+ case 'n' :
+ case 'd' : break; /* All these are okay and don't use extra parameters */
+ case 's' : if (MoveLoop == 0) /* The "s" channel is write-only */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - You cannot MOVE from the \"s\" channel\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ break;
+ case 'k' : if (MoveLoop == 1) /* The "k" channel is read-only */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - You cannot MOVE to the \"k\" channel\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ break;
+ default : fprintf (ErrStream, "ERROR in line %d, statement %d - You cannot MOVE from/to the \"%s\" channel\n",
+ BasicLineNo, StatementNo, TokenMap[WhichChannel].Token);
+ return (FALSE);
+ }
+ }
+ if (MoveLoop == 0)
+ {
+ if (**Index != 0xCC) /* Required token 'TO' */
+ {
+ BADTOKEN ("\"TO\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ (*Index) ++;
+ }
+ }
+ break;
+ case 0xD2: if (**Index == '!') /* (ERASE) */
+ { /* 128K RAM-bank ? */
+ (*Index) ++;
+ switch (Is48KProgram) /* Then the program must be 128K */
+ {
+ case -1 : Is48KProgram = 0; break; /* Set the flag */
+ case 1 : fprintf (ErrStream, "ERROR - Line %d contains 128K file I/O, but the program\n"
+ "also uses UDGs \'T\' and/or \'U\'\n", BasicLineNo);
+ return (FALSE);
+ case 0 : break;
+ }
+ }
+ else
+ {
+ if (!ScanChannel (BasicLineNo, StatementNo, Keyword, Index, &WhichChannel))
+ return (FALSE);
+ if (WhichChannel != 'm')
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - You can only ERASE from the ! or \"m\" channel\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ }
+ if (CheckEnd (BasicLineNo, StatementNo, Index)) /* Additional filename required */
+ return (FALSE);
+ if (**Index == '\"') /* Look for a filename */
+ {
+ if (*(*Index + 1) == '\"' && /* Empty string (not allowed) ? */
+ *(*Index + 2) != '\"') /* Concatenation - first char is a " (allowed) ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Empty filename not allowed\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ while (**Index == '\"')
+ {
+ while (*(++ (*Index)) != '\"')
+ if (**Index == 0x0D)
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Unexpected end of line\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ (*Index) ++;
+ }
+ }
+ else if (!HandleClass10 (BasicLineNo, StatementNo, Keyword, Index))
+ return (FALSE);
+ break;
+ case 0xD3: if (!ScanStream (BasicLineNo, StatementNo, Keyword, Index)) /* (OPEN #) */
+ return (FALSE);
+ if (**Index != ';' && **Index != ',') /* (Required token) */
+ {
+ BADTOKEN ("\";\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ (*Index) ++;
+ if (!ScanChannel (BasicLineNo, StatementNo, Keyword, Index, &WhichChannel))
+ return (FALSE);
+ switch (WhichChannel)
+ {
+ case 'm' : if (CheckEnd (BasicLineNo, StatementNo, Index)) /* "m" requires an additional filename */
+ return (FALSE);
+ if (**Index == '\"') /* Look for a filename */
+ {
+ if (*(*Index + 1) == '\"' && /* Empty string (not allowed) ? */
+ *(*Index + 2) != '\"') /* Concatenation - first char is a " (allowed) ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Empty filename not allowed\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ while (**Index == '\"')
+ {
+ while (*(++ (*Index)) != '\"')
+ if (**Index == 0x0D)
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Unexpected end of line\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ (*Index) ++;
+ }
+ }
+ else if (!HandleClass10 (BasicLineNo, StatementNo, Keyword, Index))
+ return (FALSE);
+ break;
+ case 's' :
+ case 'k' :
+ case 'p' :
+ case 't' :
+ case 'b' :
+ case 'n' :
+ case 0xAF:
+ case 0xCF:
+ case '#' : break; /* All these are okay and don't use extra parameters */
+ default : fprintf (ErrStream, "ERROR in line %d, statement %d - You cannot attach a stream to the \"%s\" "
+ "channel\n", BasicLineNo, StatementNo, TokenMap[WhichChannel].Token);
+ return (FALSE);
+ }
+ if (**Index != ':' && **Index != 0x0D) /* (Continue unless end of statement) */
+ {
+ if (**Index == 0xBF) /* IN */
+ {
+ (*Index) ++;
+ if (!SignalInterface1 (BasicLineNo, StatementNo, 2)) /* This is Opus specific */
+ return (FALSE);
+ }
+ else if (**Index == 0xDF || /* OUT */
+ **Index == 0xB9) /* EXP */
+ {
+ (*Index) ++;
+ if (!SignalInterface1 (BasicLineNo, StatementNo, 2)) /* This is Opus specific */
+ return (FALSE);
+ if (!HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)) /* Find numeric expression */
+ return (FALSE);
+ }
+ else if (**Index == 0xA5) /* RND */
+ {
+ (*Index) ++;
+ if (!SignalInterface1 (BasicLineNo, StatementNo, 2)) /* This is Opus specific */
+ return (FALSE);
+ if (!HandleClass06 (BasicLineNo, StatementNo, Keyword, Index)) /* Find numeric expression */
+ return (FALSE);
+ if (**Index == ',') /* RND may take a second parameter */
+ {
+ (*Index) ++;
+ if (!HandleClass06 (BasicLineNo, StatementNo, Keyword, Index))
+ return (FALSE);
+ }
+ }
+ }
+ break;
+ case 0xD4: if (!ScanStream (BasicLineNo, StatementNo, Keyword, Index)) /* (CLOSE #) */
+ return (FALSE);
+ break;
+ }
+ return (TRUE);
+}
+
+bool HandleClass12 (int BasicLineNo, int StatementNo, int Keyword, byte **Index)
+
+/**********************************************************************************************************************************/
+/* Class 12 = One or more string expressions, separated by commas, must follow. */
+/**********************************************************************************************************************************/
+
+{
+ bool Type;
+ bool More = TRUE;
+
+#ifdef __DEBUG__
+ printf ("DEBUG - %sLine %d, statement %d, Enter Class 12, keyword \"%s\", next is \"%s\"\n",
+ ListSpaces, BasicLineNo, StatementNo, TokenMap[Keyword].Token, TokenMap[**Index].Token);
+#endif
+ while (More)
+ {
+ if (!ScanExpression (BasicLineNo, StatementNo, Keyword, Index, &Type, 0)) /* Find an expression */
+ return (FALSE);
+ if (Type) /* Must be string */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - \"%s\" requires string parameters\n",
+ BasicLineNo, StatementNo, TokenMap[Keyword].Token);
+ return (FALSE);
+ }
+ if (**Index == ':' || **Index == 0x0D) /* End of statement or end of line ? */
+ More = FALSE;
+ else if (**Index == ',') /* Separator ? */
+ (*Index) ++;
+ else if (**Index != ')')
+ {
+ BADTOKEN ("\",\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ }
+ return (TRUE);
+}
+
+bool HandleClass13 (int BasicLineNo, int StatementNo, int Keyword, byte **Index)
+
+/**********************************************************************************************************************************/
+/* Class 13 = One or more expressions, separated by commas, must follow (DATA, DIM, FN) */
+/**********************************************************************************************************************************/
+
+{
+ bool Type;
+ bool More = TRUE;
+
+#ifdef __DEBUG__
+ printf ("DEBUG - %sLine %d, statement %d, Enter Class 13, keyword \"%s\", next is \"%s\"\n",
+ ListSpaces, BasicLineNo, StatementNo, TokenMap[Keyword].Token, TokenMap[**Index].Token);
+#endif
+ if (**Index == ')' && Keyword == 0xA8) /* FN requires zero or more expressions */
+ return (TRUE); /* (The closing bracket is a required character and stepped over in CheckSyntax) */
+ while (More)
+ {
+ if (!ScanExpression (BasicLineNo, StatementNo, Keyword, Index, &Type, 0)) /* Find an expression */
+ return (FALSE); /* (Don't care about the type) */
+ if (Keyword == 0xE9 && !Type) /* DIM requires numeric dimensions */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - \"DIM\" requires numeric dimensions\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ if (Keyword == 0xE9 || Keyword == 0xA8) /* FN and DIM end with a closing bracket */
+ {
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ if (**Index == ')')
+ More = FALSE;
+ }
+ if (**Index == ':' || **Index == 0x0D) /* End of statement or end of line ? */
+ More = FALSE;
+ else if (**Index == ',') /* Separator ? */
+ (*Index) ++;
+ else if (**Index != ')')
+ {
+ BADTOKEN ("\",\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ }
+ return (TRUE);
+}
+
+bool HandleClass14 (int BasicLineNo, int StatementNo, int Keyword, byte **Index)
+
+/**********************************************************************************************************************************/
+/* Class 14 = One or more variables, separated by commas, must follow (READ) */
+/**********************************************************************************************************************************/
+
+{
+ bool Type;
+ bool More = TRUE;
+ int VarNameLen;
+
+#ifdef __DEBUG__
+ printf ("DEBUG - %sLine %d, statement %d, Enter Class 14, keyword \"%s\", next is \"%s\"\n",
+ ListSpaces, BasicLineNo, StatementNo, TokenMap[Keyword].Token, TokenMap[**Index].Token);
+#endif
+ while (More)
+ {
+ if (!ScanVariable (BasicLineNo, StatementNo, Keyword, Index, &Type, &VarNameLen, 2)) /* We need a variable */
+ {
+ if (VarNameLen == 0) /* (Not a variable) */
+ BADTOKEN ("variable", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ if (**Index == ':' || **Index == 0x0D) /* End of statement or end of line ? */
+ More = FALSE;
+ else if (**Index == ',') /* Separator ? */
+ (*Index) ++;
+ else
+ {
+ BADTOKEN ("\",\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ }
+ return (TRUE);
+}
+
+bool HandleClass15 (int BasicLineNo, int StatementNo, int Keyword, byte **Index)
+
+/**********************************************************************************************************************************/
+/* Class 15 = DEF FN */
+/**********************************************************************************************************************************/
+
+{
+ bool Type;
+ int VarNameLen;
+
+#ifdef __DEBUG__
+ printf ("DEBUG - %sLine %d, statement %d, Enter Class 15, keyword \"%s\", next is \"%s\"\n",
+ ListSpaces, BasicLineNo, StatementNo, TokenMap[Keyword].Token, TokenMap[**Index].Token);
+#endif
+ if (!ScanVariable (BasicLineNo, StatementNo, Keyword, Index, &Type, &VarNameLen, -1))
+ {
+ if (VarNameLen == 0)
+ BADTOKEN ("variable", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ if (VarNameLen != 1) /* Not single letter ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Wrong variable type; must be single character\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ if (**Index == '(') /* Arguments to be passed to the expression while running ? */
+ {
+ (*Index) ++;
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ if (**Index == ')')
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Empty parameter array not allowed\n", BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ while (**Index != ')')
+ {
+ if (!ScanVariable (BasicLineNo, StatementNo, Keyword, Index, &Type, &VarNameLen, -1))
+ {
+ if (VarNameLen == 0)
+ BADTOKEN ("variable", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ if (VarNameLen != 1) /* Not single letter ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Wrong variable type; must be single character\n",
+ BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ if (**Index != 0x0E) /* A number (marker) must follow each parameter */
+ {
+ BADTOKEN ("number marker", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ (*Index) ++; /* (Step past it) */
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ if (**Index != ')')
+ {
+ if (**Index == ',')
+ (*Index) ++;
+ else
+ {
+ BADTOKEN ("\",\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ }
+ }
+ (*Index) ++;
+ }
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ if (**Index != '=')
+ {
+ BADTOKEN ("\"=\"", TokenMap[**Index].Token);
+ return (FALSE);
+ }
+ (*Index) ++;
+ if (CheckEnd (BasicLineNo, StatementNo, Index))
+ return (FALSE);
+ return (ScanExpression (BasicLineNo, StatementNo, Keyword, Index, &Type, 0)); /* Find an expression */
+}
+
+bool CheckSyntax (int BasicLineNo, byte *Line)
+
+/**********************************************************************************************************************************/
+/* Pre : `Line' points to the converted BASIC line. An initial syntax check has been done already - */
+/* - The line number makes sense; */
+/* - Keywords are at the beginning of each statement and not within a statement; */
+/* - There are less than 128 statements in the line; */
+/* - Brackets match on a per-line basis (but not necessarily on a per-statement basis!) */
+/* - Quotes match; */
+/* Post : The line has been checked against 'normal' Spectrum BASIC syntax. Extended devices that change the normal syntax */
+/* (such as Interface 1 or disk interfaces) are not understood and will generate error messages. */
+/* Import: None. */
+/**********************************************************************************************************************************/
+
+{
+ byte StrippedLine[MAXLINELENGTH + 1];
+ byte *StrippedIndex;
+ byte Keyword;
+ bool AllOk = TRUE;
+ bool VarType;
+ int StatementNo = 0;
+ int ClassIndex = -1;
+
+ StrippedIndex = &(StrippedLine[0]);
+ while (*Line != 0x0D) /* First clean up the line, dropping number expansions and trash */
+ {
+ switch (*Line)
+ {
+ case 0 :
+ case 1 :
+ case 2 :
+ case 3 :
+ case 4 :
+ case 5 :
+ case 6 :
+ case 7 :
+ case 8 :
+ case 9 :
+ case 10 :
+ case 11 :
+ case 12 :
+ case 13 : break;
+ case 14 : *(StrippedIndex ++) = *Line; Line += 5; break; /* EXCEPTION: keep the marker, but drop the number */
+ case 15 : break;
+ case 16 :
+ case 17 :
+ case 18 :
+ case 19 :
+ case 20 :
+ case 21 : Line ++; break;
+ case 22 :
+ case 23 : Line += 2; break;
+ case 24 :
+ case 25 :
+ case 26 :
+ case 27 :
+ case 28 :
+ case 29 :
+ case 30 :
+ case 31 :
+ case 32 : break; /* (We don't care for spaces either!) */
+ default : *(StrippedIndex ++) = *Line; break; /* Pass on only 'good' bits */
+ }
+ Line ++;
+ }
+ *(StrippedIndex ++) = 0x0D;
+ *StrippedIndex = '\0';
+ StrippedIndex = &(StrippedLine[0]); /* Ok, here goes... */
+ while (AllOk && *StrippedIndex != 0x0D) /* Handle each statement */
+ {
+ StatementNo ++;
+ Keyword = *(StrippedIndex ++);
+ if (Keyword == 0xEA) /* 'REM' ? */
+ return (TRUE); /* Then we're done checking this line */
+ if (TokenMap[Keyword].TokenType != 0 && TokenMap[Keyword].TokenType != 1 && TokenMap[Keyword].TokenType != 2) /* (Sanity) */
+ {
+ if (Keyword == 0xA9) /* EXCEPTION: POINT may be used as command */
+ {
+ if (*StrippedIndex != '#') /* It must be followed by a stream in that case */
+ {
+ fprintf (ErrStream, "ERROR - Keyword (\"%s\") error in line %d, statement %d\n",
+ TokenMap[Keyword].Token, BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ StrippedIndex ++;
+ if (!ScanStream (BasicLineNo, StatementNo, Keyword, &StrippedIndex)) /* (Also signals Interface1/Opus specificness) */
+ return (FALSE);
+ if (*StrippedIndex != ';')
+ {
+ BADTOKEN ("\";\"", TokenMap[*StrippedIndex].Token);
+ return (FALSE);
+ }
+ StrippedIndex ++;
+ if (!HandleClass06 (BasicLineNo, StatementNo, Keyword, &StrippedIndex))
+ return (FALSE);
+ }
+ else
+ {
+ fprintf (ErrStream, "ERROR - Keyword (\"%s\") error in line %d, statement %d\n",
+ TokenMap[Keyword].Token, BasicLineNo, StatementNo);
+ return (FALSE);
+ }
+ }
+ else
+ {
+ ClassIndex = -1;
+#ifdef __DEBUG__
+ RecurseLevel = 0;
+ ListSpaces[0] = '\0';
+ printf ("DEBUG - Start Line %d, Statement %d, Keyword \"%s\"\n", BasicLineNo, StatementNo, TokenMap[Keyword].Token);
+#endif
+ if ((Keyword == 0xE1 || Keyword == 0xF0) && *StrippedIndex == '#') /* EXCEPTION: LIST and LLIST may take a stream */
+ {
+ StrippedIndex ++;
+ if (!ScanStream (BasicLineNo, StatementNo, Keyword, &StrippedIndex)) /* (Also signals Interface1/Opus specificness) */
+ return (FALSE);
+ if (*StrippedIndex != ':' && *StrippedIndex != 0x0D) /* Line number is not required */
+ {
+ if (*StrippedIndex != ',')
+ {
+ BADTOKEN ("\",\"", TokenMap[*StrippedIndex].Token);
+ return (FALSE);
+ }
+ StrippedIndex ++;
+ }
+ }
+ while (AllOk && TokenMap[Keyword].KeywordClass[++ ClassIndex]) /* Handle all class parameters */
+ {
+ if (*StrippedIndex == 0x0D)
+ {
+ if (TokenMap[Keyword].KeywordClass[ClassIndex] != 3 && /* Class 5 and 3 need 0 or more arguments */
+ TokenMap[Keyword].KeywordClass[ClassIndex] != 5)
+ {
+ if ((Keyword == 0xEB && TokenMap[Keyword].KeywordClass[ClassIndex] == 0xCD) || /* 'FOR' doesn't need 'STEP' parameter */
+ (Keyword == 0xFC && TokenMap[Keyword].KeywordClass[ClassIndex] == ',')) /* 'DRAW' doesn't need a third parameter */
+ ClassIndex ++;
+ else
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Unexpected end of line\n", BasicLineNo, StatementNo);
+ AllOk = FALSE;
+ }
+ }
+ }
+ else if (TokenMap[Keyword].KeywordClass[ClassIndex] >= 32) /* Required token or class ? */
+ {
+ if (*StrippedIndex != TokenMap[Keyword].KeywordClass[ClassIndex]) /* (Required token) */
+ {
+ if ((Keyword == 0xEB && TokenMap[Keyword].KeywordClass[ClassIndex] == 0xCD && *StrippedIndex == ':') ||
+ (Keyword == 0xFC && TokenMap[Keyword].KeywordClass[ClassIndex] == ',' && *StrippedIndex == ':'))
+ ClassIndex ++; /* EXCEPTION: 'FOR' does not require the 'STEP' parameter */
+ /* EXCEPTION: 'DRAW' does not require the third parameter */
+ else
+ { /* (Token not there) */
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Expected \"%s\", but got \"%s\"\n",
+ BasicLineNo, StatementNo, TokenMap[TokenMap[Keyword].KeywordClass[ClassIndex]].Token,
+ TokenMap[*StrippedIndex].Token);
+ AllOk = FALSE;
+ }
+ }
+ else
+ StrippedIndex ++;
+ }
+ else /* (Command class) */
+ switch (TokenMap[Keyword].KeywordClass[ClassIndex])
+ {
+ case 1 : AllOk = HandleClass01 (BasicLineNo, StatementNo, Keyword, &StrippedIndex, &VarType); break;
+ case 2 : AllOk = HandleClass02 (BasicLineNo, StatementNo, Keyword, &StrippedIndex, VarType); break;
+ case 3 : AllOk = HandleClass03 (BasicLineNo, StatementNo, Keyword, &StrippedIndex); break;
+ case 4 : AllOk = HandleClass04 (BasicLineNo, StatementNo, Keyword, &StrippedIndex); break;
+ case 5 : AllOk = HandleClass05 (BasicLineNo, StatementNo, Keyword, &StrippedIndex); break;
+ case 6 : AllOk = HandleClass06 (BasicLineNo, StatementNo, Keyword, &StrippedIndex); break;
+ case 7 : AllOk = HandleClass07 (BasicLineNo, StatementNo, Keyword, &StrippedIndex); break;
+ case 8 : AllOk = HandleClass08 (BasicLineNo, StatementNo, Keyword, &StrippedIndex); break;
+ case 9 : AllOk = HandleClass09 (BasicLineNo, StatementNo, Keyword, &StrippedIndex); break;
+ case 10 : AllOk = HandleClass10 (BasicLineNo, StatementNo, Keyword, &StrippedIndex); break;
+ case 11 : AllOk = HandleClass11 (BasicLineNo, StatementNo, Keyword, &StrippedIndex); break;
+ case 13 : AllOk = HandleClass13 (BasicLineNo, StatementNo, Keyword, &StrippedIndex); break;
+ case 14 : AllOk = HandleClass14 (BasicLineNo, StatementNo, Keyword, &StrippedIndex); break;
+ case 15 : AllOk = HandleClass15 (BasicLineNo, StatementNo, Keyword, &StrippedIndex); break;
+ }
+ }
+ }
+ if (AllOk && Keyword != 0xFA) /* Handling 'IF' and AllOk (i.e. just read the "THEN" ?) */
+ { /* (Nope, go check end of statement) */
+ if (*StrippedIndex != ':' && *StrippedIndex != 0x0D)
+ {
+ if (Keyword == 0xFB && *StrippedIndex == '#') /* EXCEPTION: 'CLS #' is allowed */
+ {
+ StrippedIndex ++;
+ if (!SignalInterface1 (BasicLineNo, StatementNo, 0))
+ return (FALSE);
+ if (*StrippedIndex != ':' && *StrippedIndex != 0x0D)
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Expected end of statement, but got \"%s\"\n",
+ BasicLineNo, StatementNo, TokenMap[*StrippedIndex].Token);
+ AllOk = FALSE;
+ }
+ }
+ else
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Expected end of statement, but got \"%s\"\n",
+ BasicLineNo, StatementNo, TokenMap[*StrippedIndex].Token);
+ AllOk = FALSE;
+ }
+ }
+ }
+ if (AllOk && *StrippedIndex == ':') /* (Placing this check here allows weird (but legal) construction "THEN :") */
+ {
+ StrippedIndex ++;
+ while (*StrippedIndex == ':') /* (More consecutive ':' separators are allowed) */
+ {
+ StrippedIndex ++;
+ StatementNo ++;
+ }
+ }
+ }
+ return (AllOk);
+}
+
+int main (int argc, char **argv)
+
+/**********************************************************************************************************************************/
+/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MAIN PROGRAM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
+/* Import: MatchToken, HandleNumbers, ExpandSequences, PrepareLine, CheckSyntax. */
+/**********************************************************************************************************************************/
+
+{
+ FILE *FpIn;
+ FILE *FpOut;
+ char FileNameIn[256] = "\0";
+ char FileNameOut[256] = "\0";
+ char LineIn[MAXLINELENGTH + 1]; /* One line read from the ASCII file */
+ char *BasicIndex; /* Current scan position in the (converted) ASCII line */
+ byte *ResultIndex; /* Current write index in to the binary result line */
+ byte Token;
+ int LineCount = 0; /* Line count in the ASCII file */
+ int BasicLineNo; /* Current BASIC line number */
+ int SubLineCount; /* Current statement number */
+ bool ExpectKeyword; /* If TRUE, the next scanned token must be a keyword */
+ bool InString; /* TRUE while inside quotes */
+ int BracketCount = 0; /* Match opening and closing brackets */
+ int AutoStart; /* Auto-start line as provided on the command line */
+ int ObjectLength; /* Binary length of one converted line */
+ int BlockSize = 0; /* Total size of the TAP block */
+ byte Parity = 0; /* Overall block parity */
+ bool AllOk = TRUE;
+ bool EndOfFile = FALSE;
+ bool WriteError = FALSE; /* Fingers crossed that this stays FALSE... */
+ size_t Size;
+ int Cnt;
+
+ ErrStream = stderr;
+ Cnt = 1;
+ for (Cnt = 1 ; Cnt < argc && AllOk; Cnt ++) /* Do all command line arguments */
+ {
+ if (argv[Cnt][0] == '-')
+ switch (tolower (argv[Cnt][1]))
+ {
+ case 'c' : CaseIndependant = TRUE; break;
+ case 'w' : NoWarnings = TRUE; break;
+ case 'q' : Quiet = TRUE; break;
+ case 'n' : DoCheckSyntax = FALSE; break;
+ case 'e' : ErrStream = stdout; break;
+ case 'a' : AutoStart = atoi (argv[Cnt] + 2);
+ if (AutoStart < 0 || AutoStart >= 10000)
+ {
+ fprintf (ErrStream, "Invalid auto-start line number %d\n", AutoStart);
+ exit (1);
+ }
+ TapeHeader.HStartLo = (byte)(AutoStart & 0xFF);
+ TapeHeader.HStartHi = (byte)(AutoStart >> 8);
+ break;
+ case 's' : if (strlen (argv[Cnt] + 2) > 10)
+ {
+ fprintf (ErrStream, "Spectrum blockname too long \"%s\"\n", argv[Cnt] + 2);
+ exit (1);
+ }
+ strncpy (TapeHeader.HName, argv[Cnt] + 2, strlen (argv[Cnt] + 2));
+ break;
+ default : fprintf (ErrStream, "Unknown switch \'%c\'\n", argv[Cnt][1]);
+ }
+ else if (FileNameIn[0] == '\0')
+ strcpy (FileNameIn, argv[Cnt]);
+ else if (FileNameOut[0] == '\0')
+ strcpy (FileNameOut, argv[Cnt]);
+ else
+ AllOk = FALSE;
+ }
+ if (FileNameIn[0] == '\0') /* We do need an input file! */
+ AllOk = FALSE;
+ if (!Quiet || !AllOk)
+ printf ("\nBAS2TAP v2.2 by M. van der Heide of ThunderWare Research Center\n\n");
+ if (!AllOk)
+ {
+ printf ("Usage: BAS2TAP [-q] [-w] [-e] [-c] [-aX] [-sX] FileIn [FileOut]\n");
+ printf (" -q = quiet: no banner, no progress indication\n");
+ printf (" -w = suppress generation of warnings\n");
+ printf (" -e = write errors to stdout in stead of stderr channel\n");
+ printf (" -c = case independant tokens (be careful here!)\n");
+ printf (" -n = disable syntax checking\n");
+ printf (" -a = set auto-start line in BASIC header\n");
+ printf (" -s = set \"filename\" in BASIC header\n");
+ exit (1);
+ }
+ if (FileNameOut[0] == '\0')
+ strcpy (FileNameOut, FileNameIn);
+ Size = strlen (FileNameOut);
+ while (-- Size > 0 && FileNameOut[Size] != '.')
+ ;
+ if (Size == 0) /* No extension ? */
+ strcat (FileNameOut, ".tap");
+ else if (strcmp (FileNameOut + Size, ".tap") && strcmp (FileNameOut + Size, ".TAP"))
+ strcpy (FileNameOut + Size, ".tap");
+ if (!Quiet)
+ printf ("Creating output file %s\n",FileNameOut);
+ if ((FpIn = fopen (FileNameIn, "rt")) == NULL)
+ {
+ perror ("ERROR - Cannot open source file");
+ exit (1);
+ }
+ if ((FpOut = fopen (FileNameOut, "wb")) == NULL)
+ {
+ perror ("ERROR - Cannot create output file");
+ fclose (FpIn);
+ exit (1);
+ }
+ Parity = TapeHeader.Flag2;
+ if (fwrite (&TapeHeader, 1, sizeof (struct TapeHeader_s), FpOut) < sizeof (struct TapeHeader_s))
+ { AllOk = FALSE; WriteError = TRUE; } /* Write dummy header to get space */
+ while (AllOk && !EndOfFile)
+ {
+ if (fgets (LineIn, MAXLINELENGTH + 1, FpIn) != NULL)
+ {
+ LineCount ++;
+ if (strlen (LineIn) >= MAXLINELENGTH)
+ { /* We don't require an end-of-line marker */
+ fprintf (ErrStream, "ERROR - Line %d too long\n", LineCount);
+ AllOk = FALSE;
+ }
+ else if ((BasicLineNo = PrepareLine (LineIn, LineCount, &BasicIndex)) < 0)
+ {
+ if (BasicLineNo == -1) /* (Error) */
+ AllOk = FALSE;
+ else /* (Line should simply be skipped) */
+ ;
+ }
+ else if (BasicLineNo >= 10000)
+ {
+ fprintf (ErrStream, "ERROR - Line number %d is larger than the maximum allowed\n", BasicLineNo);
+ AllOk = FALSE;
+ }
+ else
+ {
+ if (!Quiet)
+ {
+ printf ("\rConverting line %4d -> %4d\r", LineCount, BasicLineNo);
+ fflush (stdout); /* (Force line without end-of-line to be printed) */
+ }
+ InString = FALSE;
+ ExpectKeyword = TRUE;
+ SubLineCount = 1;
+ ResultIndex = ResultingLine + 4; /* Reserve space for line number and length */
+ HandlingDEFFN = FALSE;
+ while (*BasicIndex && AllOk)
+ {
+ if (InString)
+ {
+ if (*BasicIndex == '\"')
+ {
+ InString = FALSE;
+ *(ResultIndex ++) = *(BasicIndex ++);
+ while (*BasicIndex == ' ') /* Skip trailing spaces */
+ BasicIndex ++;
+ }
+ else
+ switch (ExpandSequences (BasicLineNo, &BasicIndex, &ResultIndex, FALSE))
+ {
+ case -1 : AllOk = FALSE; break; /* (Error - already reported) */
+ case 0 : *(ResultIndex ++) = *(BasicIndex ++); break; /* (No expansion made) */
+ case 1 : break;
+ }
+ }
+ else if (*BasicIndex == '\"')
+ {
+ if (ExpectKeyword)
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Expected keyword but got quote\n", BasicLineNo, SubLineCount);
+ AllOk = FALSE;
+ }
+ else
+ {
+ InString = TRUE;
+ *(ResultIndex ++) = *(BasicIndex ++);
+ }
+ }
+ else if (ExpectKeyword)
+ {
+ switch (MatchToken (BasicLineNo, TRUE, &BasicIndex, &Token))
+ {
+ case -2 : AllOk = FALSE; break; /* (Error - already reported) */
+ case -1 : fprintf (ErrStream, "ERROR in line %d, statement %d - Expected keyword but got token \"%s\"\n",
+ BasicLineNo, SubLineCount, TokenMap[Token].Token); /* (Not keyword) */
+ AllOk = FALSE;
+ break;
+ case 0 : fprintf (ErrStream, "ERROR in line %d, statement %d - Expected keyword but got \"%s\"\n", /* (No match) */
+ BasicLineNo, SubLineCount, TokenMap[(byte)(*BasicIndex)].Token);
+ AllOk = FALSE;
+ break;
+ case 1 : *(ResultIndex ++) = Token; /* (Found keyword) */
+ if (Token != ':') /* Special exception; empty statement */
+ ExpectKeyword = FALSE;
+ if (Token == DEFFN)
+ {
+ HandlingDEFFN = TRUE;
+ InsideDEFFN = FALSE;
+ }
+ if (Token == 0xEA) /* Special exception; REM */
+ while (*BasicIndex) /* Simply copy over the remaining part of the line, */
+ /* disregarding token or number expansions */
+ /* As brackets aren't tested for, the match counting stops here */
+ /* (a closing bracket in a REM statement will not be seen by BASIC) */
+ switch (ExpandSequences (BasicLineNo, &BasicIndex, &ResultIndex, FALSE))
+ {
+ case -1 : AllOk = FALSE; break;
+ case 0 : *(ResultIndex ++) = *(BasicIndex ++); break;
+ case 1 : break;
+ }
+ break;
+ }
+ }
+ else if (*BasicIndex == '(') /* Opening bracket */
+ {
+ BracketCount ++;
+ *(ResultIndex ++) = *(BasicIndex ++);
+ if (HandlingDEFFN && !InsideDEFFN)
+#ifdef __DEBUG__
+ {
+ printf ("DEBUG - %sDEFFN, Going inside parameter list\n", ListSpaces);
+ InsideDEFFN = TRUE; /* Signal: require special treatment! */
+ }
+#else
+ InsideDEFFN = TRUE; /* Signal: require special treatment! */
+#endif
+ }
+ else if (*BasicIndex == ')') /* Closing bracket */
+ {
+ if (HandlingDEFFN && InsideDEFFN)
+ {
+#ifdef __DEBUG__
+ printf ("DEBUG - %sDEFFN, Done parameter list\n", ListSpaces);
+ InsideDEFFN = TRUE; /* Signal: require special treatment! */
+#endif
+ *(ResultIndex ++) = 0x0E; /* Insert room for the evaluator (call by value) */
+ *(ResultIndex ++) = 0x00;
+ *(ResultIndex ++) = 0x00;
+ *(ResultIndex ++) = 0x00;
+ *(ResultIndex ++) = 0x00;
+ *(ResultIndex ++) = 0x00;
+ InsideDEFFN = FALSE; /* Mark end of special treatment */
+ HandlingDEFFN = FALSE; /* (The part after the '=' is just like eg. LET) */
+ }
+ if (-- BracketCount < 0) /* More closing than opening brackets */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Too many closing brackets\n", BasicLineNo, SubLineCount);
+ AllOk = FALSE;
+ }
+ else
+ *(ResultIndex ++) = *(BasicIndex ++);
+ }
+ else if (*BasicIndex == ',' && HandlingDEFFN && InsideDEFFN)
+ {
+#ifdef __DEBUG__
+ printf ("DEBUG - %sDEFFN, Done parameter; another follows\n", ListSpaces);
+#endif
+ *(ResultIndex ++) = 0x0E; /* Insert room for the evaluator (call by value) */
+ *(ResultIndex ++) = 0x00;
+ *(ResultIndex ++) = 0x00;
+ *(ResultIndex ++) = 0x00;
+ *(ResultIndex ++) = 0x00;
+ *(ResultIndex ++) = 0x00;
+ *(ResultIndex ++) = *(BasicIndex ++); /* (Copy over the ',') */
+ }
+ else
+ switch (MatchToken (BasicLineNo, FALSE, &BasicIndex, &Token))
+ {
+ case -2 : AllOk = FALSE; break; /* (Error - already reported) */
+ case -1 : fprintf (ErrStream, "ERROR in line %d, statement %d - Unexpected keyword \"%s\"\n",/* (Match but keyword) */
+ BasicLineNo, SubLineCount, TokenMap[Token].Token);
+ AllOk = FALSE;
+ break;
+ case 0 : switch (HandleNumbers (BasicLineNo, &BasicIndex, &ResultIndex)) /* (No token) */
+ {
+ case 0 : switch (ExpandSequences (BasicLineNo, &BasicIndex, &ResultIndex, TRUE)) /* (No number) */
+ {
+ case -1 : AllOk = FALSE; break; /* (Error - already reported) */
+ case 0 : if (isalpha (*BasicIndex)) /* (No expansion made) */
+ while (isalnum (*BasicIndex)) /* Skip full strings in one go */
+ *(ResultIndex ++) = *(BasicIndex ++);
+ else
+ *(ResultIndex ++) = *(BasicIndex ++);
+ break;
+ case 1 : break;
+ }
+ break;
+ case -1 : AllOk = FALSE; break;
+ }
+ break;
+ case 1 : *(ResultIndex ++) = Token; /* (Found token, no keyword) */
+ if (Token == ':' || Token == 0xCB)
+ {
+ ExpectKeyword = TRUE;
+ HandlingDEFFN = FALSE;
+ if (BracketCount != 0) /* All brackets match ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Too few closing brackets\n",
+ BasicLineNo, SubLineCount);
+ AllOk = FALSE;
+ }
+ if (++ SubLineCount > 127)
+ {
+ fprintf (ErrStream, "ERROR - Line %d has too many statements\n", BasicLineNo);
+ AllOk = FALSE;
+ }
+ }
+ break;
+ }
+ }
+ *(ResultIndex ++) = 0x0D;
+ if (AllOk && BracketCount != 0) /* All brackets match ? */
+ {
+ fprintf (ErrStream, "ERROR in line %d, statement %d - Too few closing brackets\n", BasicLineNo, SubLineCount);
+ AllOk = FALSE;
+ }
+ if (AllOk && DoCheckSyntax)
+ AllOk = CheckSyntax (BasicLineNo, ResultingLine + 4); /* Check the syntax of the decoded line */
+ if (AllOk)
+ {
+ ObjectLength = (int)(ResultIndex - ResultingLine);
+ ResultingLine[0] = (byte)(BasicLineNo >> 8); /* Line number is put reversed */
+ ResultingLine[1] = (byte)(BasicLineNo & 0xFF);
+ ResultingLine[2] = (byte)((ObjectLength - 4) & 0xFF); /* Make sure this runs on any CPU */
+ ResultingLine[3] = (byte)((ObjectLength - 4) >> 8);
+ BlockSize += ObjectLength;
+ for (Cnt = 0 ; Cnt < ObjectLength ; Cnt ++)
+ Parity ^= ResultingLine[Cnt];
+ if (BlockSize > 41500) /* (= 65368-23755-<some work/stack space>) */
+ {
+ fprintf (ErrStream, "ERROR - Object file too large at line %d!\n", BasicLineNo);
+ AllOk = FALSE;
+ }
+ else
+ if (fwrite (ResultingLine, 1, ObjectLength, FpOut) != ObjectLength)
+ { AllOk = FALSE; WriteError = TRUE; }
+ }
+ }
+ }
+ else
+ EndOfFile = TRUE;
+ }
+ if (!Quiet)
+ {
+ printf ("\r \r");
+ fflush (stdout);
+ }
+ if (!WriteError) /* Finish the TAP file no matter what went wrong, unless it was the writing itself */
+ {
+ ResultingLine[0] = Parity; /* Now it's time to write the 'real' header in front */
+ if (fwrite (ResultingLine, 1, 1, FpOut) < 1)
+ {
+ perror ("ERROR - Write error");
+ fclose (FpIn);
+ fclose (FpOut);
+ exit (1);
+ }
+ TapeHeader.HLenLo = TapeHeader.HBasLenLo = (byte)(BlockSize & 0xFF);
+ TapeHeader.HLenHi = TapeHeader.HBasLenHi = (byte)(BlockSize >> 8);
+ TapeHeader.LenLo2 = (byte)((BlockSize + 2) & 0xFF);
+ TapeHeader.LenHi2 = (byte)((BlockSize + 2) >> 8);
+ Parity = 0;
+ for (Cnt = 2 ; Cnt < 20 ; Cnt ++)
+ Parity ^= *((byte *)&TapeHeader + Cnt);
+ TapeHeader.Parity1 = Parity;
+ fseek (FpOut, 0, SEEK_SET);
+ if (fwrite (&TapeHeader, 1, sizeof (struct TapeHeader_s), FpOut) < sizeof (struct TapeHeader_s))
+ {
+ perror ("ERROR - Write error");
+ exit (1);
+ }
+ if (!Quiet)
+ {
+ if (AllOk)
+ printf ("Done! Listing contains %d %s.\n", LineCount, LineCount == 1 ? "line" : "lines");
+ else
+ printf ("Listing as far as done contains %d %s.\n", LineCount - 1, LineCount == 2 ? "line" : "lines");
+ if (Is48KProgram >= 0)
+ printf ("Note: this program can only be used in %dK mode\n", Is48KProgram ? 48 : 128);
+ switch (UsesInterface1)
+ {
+ case -1 : break; /* Neither of them */
+ case 0 : printf ("Note: this program requires Interface 1 or Opus Discovery\n"); break;
+ case 1 : printf ("Note: this program requires Interface 1\n"); break;
+ case 2 : printf ("Note: this program requires an Opus Discovery"); break;
+ }
+ }
+ }
+ else
+ perror ("ERROR - Write error");
+ fclose (FpIn);
+ fclose (FpOut);
+ return (AllOk ? 0 : 1); /* (Keep weird compilers happy) */
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-10-18 14:37:05 +0000