Fixed scanner terminology

git-svn-id: https://svn.inf.ethz.ch/svn/lecturers/a2/trunk@8534 8c9fc860-2736-0410-a75d-ab315db34111

source/FoxARMAssembler.Mod

@@ -18,11 +18,11 @@ TYPE
 		BEGIN
 			registerNumber := InstructionSet.None;
 			result := FALSE;
-			IF symbol.token = Scanner.Identifier THEN
-				registerNumber := InstructionSet.RegisterNumberFromName(symbol.identifierString);
+			IF token.symbol = Scanner.Identifier THEN
+				registerNumber := InstructionSet.RegisterNumberFromName(token.identifierString);
 				IF registerNumber # InstructionSet.None THEN
 					result := TRUE;
-					NextSymbol
+					NextToken
 				END
 			END;
 			RETURN result
@@ -32,20 +32,20 @@ TYPE
 		VAR num: LONGINT;
 		BEGIN
 			registerList := {};
-			IF symbol.token = Scanner.LeftBrace THEN
+			IF token.symbol = Scanner.LeftBrace THEN
 				REPEAT
-					NextSymbol;
+					NextToken;
 					IF GetRegister(num) THEN
 						IF (num > 16) THEN
 							Error(errorPosition, "invalid register in list (not yet implemented)")
 						END;
 						INCL(registerList, num);
 					END;
-				UNTIL symbol.token # Scanner.Comma;
-				IF symbol.token # Scanner.RightBrace THEN 
+				UNTIL token.symbol # Scanner.Comma;
+				IF token.symbol # Scanner.RightBrace THEN 
 					Error(errorPosition, "'}' expected.")
 				ELSE
-					NextSymbol;
+					NextToken;
 					RETURN TRUE
 				END;
 			END;
@@ -64,8 +64,8 @@ TYPE
 			registerNumber := InstructionSet.None;
 			fields := {};
 
-			IF symbol.token = Scanner.Identifier THEN
-				strings := Strings.Split(symbol.identifierString, '_'); (* split the identifier at the underscore symbol *)
+			IF token.symbol = Scanner.Identifier THEN
+				strings := Strings.Split(token.identifierString, '_'); (* split the identifier at the underscore symbol *)
 				IF LEN(strings) = 2 THEN
 					IF (strings[0]^ = "CPSR") OR (strings[0]^ = "SPSR") THEN
 						IF strings[0]^ = "CPSR" THEN registerNumber := InstructionSet.CPSR
@@ -82,7 +82,7 @@ TYPE
 								END
 							END;
 							result := TRUE;
-							NextSymbol
+							NextToken
 						END
 					END
 				END
@@ -97,11 +97,11 @@ TYPE
 		BEGIN
 			shiftModeNumber := InstructionSet.None;
 			result := FALSE;
-			IF symbol.token = Scanner.Identifier THEN
-				shiftModeNumber := InstructionSet.ShiftModeNumberFromName(symbol.identifierString);
+			IF token.symbol = Scanner.Identifier THEN
+				shiftModeNumber := InstructionSet.ShiftModeNumberFromName(token.identifierString);
 				IF shiftModeNumber # InstructionSet.None THEN
 					result := TRUE;
-					NextSymbol
+					NextToken
 				END
 			END;
 			RETURN result
@@ -115,11 +115,11 @@ TYPE
 			coprocessorNumber := InstructionSet.None;
 			result := FALSE;
 
-			IF symbol.token = Scanner.Identifier THEN
-				coprocessorNumber := InstructionSet.CoprocessorNumberFromName(symbol.identifierString);
+			IF token.symbol = Scanner.Identifier THEN
+				coprocessorNumber := InstructionSet.CoprocessorNumberFromName(token.identifierString);
 				IF coprocessorNumber # InstructionSet.None THEN
 					result := TRUE;
-					NextSymbol
+					NextToken
 				END
 			END;
 
@@ -131,10 +131,10 @@ TYPE
 		VAR
 			result: BOOLEAN;
 		BEGIN
-			IF (symbol.token = Scanner.Number) & (symbol.numberType = Scanner.Integer) & (symbol.integer >= 0) & (symbol.integer <= 7) THEN
-				coprocessorOpcode := symbol.integer;
+			IF (token.symbol = Scanner.Number) & (token.numberType = Scanner.Integer) & (token.integer >= 0) & (token.integer <= 7) THEN
+				coprocessorOpcode := token.integer;
 				result := TRUE;
-				NextSymbol
+				NextToken
 			ELSE
 				coprocessorOpcode := InstructionSet.None;
 				result := FALSE
@@ -162,7 +162,7 @@ TYPE
 			i.e., the '#'-sign followed by any expression that evaluates to a constant value
 		**)
 		PROCEDURE GetImmediateValue*(VAR immediateValue: LONGINT): BOOLEAN;
-		BEGIN RETURN ThisToken(Scanner.Unequal) & GetPlainValue(immediateValue)
+		BEGIN RETURN ThisSymbol(Scanner.Unequal) & GetPlainValue(immediateValue)
 		END GetImmediateValue;
 
 		PROCEDURE Instruction*(CONST mnemonic: ARRAY OF CHAR);
@@ -194,17 +194,17 @@ TYPE
 					Error(position, "too many operands")
 				ELSE
 					InstructionSet.InitOperand(operand);
-					IF ThisToken(Scanner.LeftBracket) THEN
+					IF ThisSymbol(Scanner.LeftBracket) THEN
 						bracketIsOpen := TRUE;
 						(* memory operand *)
 						indexingMode := {};
 						IF GetRegister(registerNumber) THEN
-							IF ThisToken(Scanner.RightBracket) THEN
+							IF ThisSymbol(Scanner.RightBracket) THEN
 								bracketIsOpen := FALSE;
 								(* post indexing *)
 								INCL(indexingMode, InstructionSet.PostIndexed)
 							END;
-							IF ExpectToken(Scanner.Comma) THEN
+							IF ExpectSymbol(Scanner.Comma) THEN
 								IF GetImmediateValue(offsetImmediateValue) THEN
 									(* immediate offset memory operand *)
 									isImmediateOffset := TRUE;
@@ -223,9 +223,9 @@ TYPE
 									isImmediateOffset := FALSE;
 
 									(* parse sign *)
-									IF ThisToken(Scanner.Plus) THEN
+									IF ThisSymbol(Scanner.Plus) THEN
 										INCL(indexingMode, InstructionSet.Increment)
-									ELSIF ThisToken(Scanner.Minus) THEN
+									ELSIF ThisSymbol(Scanner.Minus) THEN
 										INCL(indexingMode, InstructionSet.Decrement)
 									ELSE
 										Error(errorPosition, "plus or minus sign expected")
@@ -254,8 +254,8 @@ TYPE
 							END;
 
 							IF bracketIsOpen THEN
-								IF ExpectToken(Scanner.RightBracket) THEN
-									IF ThisToken(Scanner.ExclamationMark) THEN
+								IF ExpectSymbol(Scanner.RightBracket) THEN
+									IF ThisSymbol(Scanner.ExclamationMark) THEN
 										(* preindexing *)
 										INCL(indexingMode, InstructionSet.PreIndexed)
 									END
@@ -277,7 +277,7 @@ TYPE
 							ELSE
 								Error(errorPosition, "immediate offset is out of range")
 							END;
-							IF ExpectToken(Scanner.RightBracket) THEN
+							IF ExpectSymbol(Scanner.RightBracket) THEN
 							END;
 						ELSE
 							Error(errorPosition, "register expected")
@@ -301,10 +301,10 @@ TYPE
 						shiftRegisterNumber := InstructionSet.None;
 						shiftImmediateValue := 0;
 
-						IF ThisToken(Scanner.ExclamationMark) THEN
+						IF ThisSymbol(Scanner.ExclamationMark) THEN
 							INCL(flags, InstructionSet.flagBaseRegisterUpdate);
 						END;
-						IF ThisToken(Scanner.Comma) THEN
+						IF ThisSymbol(Scanner.Comma) THEN
 							(* parse shift mode *)
 							IF GetShiftMode(shiftModeNumber) THEN
 								IF shiftModeNumber # InstructionSet.shiftRRX THEN (* RRX shift amount is always 1 *)
@@ -322,7 +322,7 @@ TYPE
 						END
 					ELSIF GetRegisterList(registerList) THEN
 						InstructionSet.InitRegisterList(operand, InstructionSet.R0, registerList);
-						IF ThisToken(Scanner.Arrow) THEN
+						IF ThisSymbol(Scanner.Arrow) THEN
 							INCL(flags, InstructionSet.flagUserMode);
 						END;
 	
@@ -338,12 +338,12 @@ TYPE
 						(* ARM immediate value *)
 						InstructionSet.InitImmediate(operand, value)
 
-					ELSIF GetNonConstant(errorPosition,symbol.identifierString, result) THEN
+					ELSIF GetNonConstant(errorPosition,token.identifierString, result) THEN
 						InstructionSet.InitImmediate(operand,LONGINT(result.value));
 						IF result.fixup # NIL THEN
 							InstructionSet.AddFixup(operand,result.fixup);
 						END;
-						NextSymbol;
+						NextToken;
 					ELSIF GetPlainValue(value) THEN (* expression that evaluates to constant value *)
 						(* resolved label name *)
 						InstructionSet.InitImmediate(operand, value)
@@ -352,11 +352,11 @@ TYPE
 						Error(position, "invalid operand")
 					END;
 
-					IF ThisToken(Scanner.ExclamationMark) THEN
+					IF ThisSymbol(Scanner.ExclamationMark) THEN
 						INCL(flags, InstructionSet.flagBaseRegisterUpdate);
 					END;
 
-					IF ~newOperandExpected THEN newOperandExpected := ThisToken(Scanner.Comma) END; (* a comma means that there is one more operand *)
+					IF ~newOperandExpected THEN newOperandExpected := ThisSymbol(Scanner.Comma) END; (* a comma means that there is one more operand *)
 
 					operands[operandNumber] := operand;
 					
@@ -383,7 +383,7 @@ TYPE
 				END;
 
 				operandNumber := 0;
-				IF symbol.token # Scanner.Ln THEN
+				IF token.symbol # Scanner.Ln THEN
 					REPEAT
 						ParseOperand;
 

source/FoxAssembler.Mod

@@ -157,7 +157,7 @@ TYPE
 		diagnostics: Diagnostics.Diagnostics;
 		error-: BOOLEAN;
 		errorPosition-: Position;
-		symbol-: Scanner.Symbol;
+		token-: Scanner.Token;
 		scanner: Scanner.AssemblerScanner;
 		orgOffset: LONGINT;
 		section-: IntermediateCode.Section;
@@ -175,7 +175,7 @@ TYPE
 
 		PROCEDURE SetContext(CONST context: Scanner.Context);
 		BEGIN
-			scanner.SetContext(context); NextSymbol;
+			scanner.SetContext(context); NextToken;
 		END SetContext;
 
 		PROCEDURE Error*(pos: SyntaxTree.Position; CONST msg: ARRAY OF CHAR);
@@ -189,26 +189,26 @@ TYPE
 		BEGIN COPY(s1,msg); Strings.Append(msg,s2); Error(pos, msg);
 		END ErrorSS;
 
-		PROCEDURE NextSymbol*;
-		BEGIN error := error OR ~scanner.GetNextSymbol(symbol); errorPosition := symbol.position;
-		END NextSymbol;
+		PROCEDURE NextToken*;
+		BEGIN error := error OR ~scanner.GetNextToken(token); errorPosition := token.position;
+		END NextToken;
 
-		PROCEDURE ThisToken*(x: LONGINT): BOOLEAN;
+		PROCEDURE ThisSymbol*(x: Scanner.Symbol): BOOLEAN;
 		BEGIN
-			IF ~error & (symbol.token = x) THEN NextSymbol; RETURN TRUE ELSE RETURN FALSE END;
-		END ThisToken;
+			IF ~error & (token.symbol = x) THEN NextToken; RETURN TRUE ELSE RETURN FALSE END;
+		END ThisSymbol;
 
 		PROCEDURE GetIdentifier*(VAR pos: Position; VAR identifier: ARRAY OF CHAR): BOOLEAN;
 		BEGIN
-			pos := symbol.position;
-			IF symbol.token # Scanner.Identifier THEN RETURN FALSE
-			ELSE COPY(symbol.identifierString,identifier); NextSymbol; RETURN TRUE
+			pos := token.position;
+			IF token.symbol # Scanner.Identifier THEN RETURN FALSE
+			ELSE COPY(token.identifierString,identifier); NextToken; RETURN TRUE
 			END;
 		END GetIdentifier;
 
 		PROCEDURE ThisIdentifier*(CONST this: ARRAY OF CHAR): BOOLEAN;
 		BEGIN
-			IF ~error & (symbol.token = Scanner.Identifier) & (this = symbol.identifierString) THEN NextSymbol; RETURN TRUE ELSE RETURN FALSE END;
+			IF ~error & (token.symbol = Scanner.Identifier) & (this = token.identifierString) THEN NextToken; RETURN TRUE ELSE RETURN FALSE END;
 		END ThisIdentifier;
 
 		PROCEDURE ExpectIdentifier*(VAR pos: Position; VAR identifier: ARRAY OF CHAR): BOOLEAN;
@@ -218,15 +218,15 @@ TYPE
 			END;
 		END ExpectIdentifier;
 
-		PROCEDURE ExpectToken*(x: LONGINT): BOOLEAN;
+		PROCEDURE ExpectSymbol*(x: Scanner.Symbol): BOOLEAN;
 		VAR s: Basic.MessageString;
 		BEGIN
-			IF ThisToken(x) THEN RETURN TRUE
+			IF ThisSymbol(x) THEN RETURN TRUE
 			ELSE
-				s := "expected token "; Strings.Append(s,Scanner.tokens[x]); Strings.Append(s," but got "); Strings.Append(s,Scanner.tokens[symbol.token]);
+				s := "expected token "; Strings.Append(s,Scanner.symbols[x]); Strings.Append(s," but got "); Strings.Append(s,Scanner.symbols[token.symbol]);
 				Error(errorPosition,s);RETURN FALSE
 			END;
-		END ExpectToken;
+		END ExpectSymbol;
 
 		PROCEDURE ExpectConstantInteger*(VAR x: Result; critical: BOOLEAN): BOOLEAN;
 		VAR result: Result;
@@ -242,7 +242,7 @@ TYPE
 		PROCEDURE Section;
 		VAR sectionType: Scanner.IdentifierString; pos: Position;
 		BEGIN
-			IF ExpectToken(Scanner.Period) THEN
+			IF ExpectSymbol(Scanner.Period) THEN
 				IF ExpectIdentifier(pos,sectionType) THEN
 					IF sectionType = "data" THEN
 						IF Trace THEN D.String("data section"); D.Ln END;
@@ -322,10 +322,10 @@ TYPE
 			END;
 
 			IF (sym # NIL) & (sym IS SyntaxTree.Import)  THEN
-				NextSymbol;
-				IF ExpectToken(Scanner.Period) & (symbol.token = Scanner.Identifier) THEN
-					identifier := SyntaxTree.NewIdentifier(symbol.identifierString);
-					IF Trace THEN D.String("GetScopeSymbol  :"); D.String(symbol.identifierString); D.Ln; END;
+				NextToken;
+				IF ExpectSymbol(Scanner.Period) & (token.symbol = Scanner.Identifier) THEN
+					identifier := SyntaxTree.NewIdentifier(token.identifierString);
+					IF Trace THEN D.String("GetScopeSymbol  :"); D.String(token.identifierString); D.Ln; END;
 					localScope := sym(SyntaxTree.Import).module.moduleScope;
 					sym := NIL;
 					WHILE (sym = NIL) & (localScope # NIL) DO
@@ -487,21 +487,21 @@ TYPE
 		PROCEDURE Factor (VAR x: Result; critical: BOOLEAN): BOOLEAN;
 		VAR label: NamedLabel; identifier: Scanner.IdentifierString; pos: Position;
 		BEGIN
-			IF ThisToken(Scanner.Number) THEN
+			IF ThisSymbol(Scanner.Number) THEN
 				(* ASSERT(symbol.numberType = Scanner.Integer); *)
-				IF symbol.numberType = Scanner.Integer THEN
-					x.value := symbol.integer
-				ELSIF symbol.numberType = Scanner.Hugeint THEN
-					x.value := symbol.hugeint;
+				IF token.numberType = Scanner.Integer THEN
+					x.value := token.integer
+				ELSIF token.numberType = Scanner.Hugeint THEN
+					x.value := token.hugeint;
 					(* ASSERT(x.value < 0); (* the resulting 32 bit integer must be negative when interpreted as a signed value *)*)
 				END;
 				x.type := ConstantInteger;
 				RETURN TRUE;
-			ELSIF ThisToken(Scanner.PC) THEN (* pc IN units ! *)
+			ELSIF ThisSymbol(Scanner.PC) THEN (* pc IN units ! *)
 				x.value := code.pc;
 				x.type := ConstantInteger; (* TODO: should it be 'x.type := Offset'? *)
 				RETURN TRUE;
-			ELSIF ThisToken(Scanner.PCOffset) THEN
+			ELSIF ThisSymbol(Scanner.PCOffset) THEN
 				x.value := code.pc-orgOffset;
 				x.type := ConstantInteger; (* TODO: should it be 'x.type := Offset'? *)
 				RETURN TRUE;
@@ -517,8 +517,8 @@ TYPE
 					x.value := 0; x.type := ConstantInteger; RETURN TRUE
 				ELSE Error(pos,"undefined symbol"); RETURN FALSE
 				END;
-			ELSIF ThisToken(Scanner.LeftParenthesis)  THEN
-				RETURN Expression (x, critical) & ExpectToken(Scanner.RightParenthesis);
+			ELSIF ThisSymbol(Scanner.LeftParenthesis)  THEN
+				RETURN Expression (x, critical) & ExpectSymbol(Scanner.RightParenthesis);
 			END;
 			RETURN FALSE
 		END Factor;
@@ -528,8 +528,8 @@ TYPE
 		VAR y: Result; op : LONGINT;
 		BEGIN
 			IF Factor (x, critical) THEN
-				WHILE (symbol.token = Scanner.Times) OR (symbol.token = Scanner.Div) OR (symbol.token = Scanner.Mod) DO
-					op := symbol.token; NextSymbol;
+				WHILE (token.symbol = Scanner.Times) OR (token.symbol = Scanner.Div) OR (token.symbol = Scanner.Mod) DO
+					op := token.symbol; NextToken;
 					IF Factor (y, critical) THEN
 						IF (x.type IN ConstantIntegerOrOffset) & (y.type IN ConstantIntegerOrOffset) THEN
 							IF op = Scanner.Times THEN x.value := x.value * y.value
@@ -557,8 +557,8 @@ TYPE
 		PROCEDURE Expression*(VAR x: Result; critical: BOOLEAN): BOOLEAN;
 		VAR y: Result; op : LONGINT;
 		BEGIN
-			op := symbol.token;
-			IF ThisToken(Scanner.Minus) THEN
+			op := token.symbol;
+			IF ThisSymbol(Scanner.Minus) THEN
 				IF Term (x, critical) THEN
 					IF x.type IN ConstantIntegerOrOffset THEN
 						x.value := -x.value; x.valueR := x.value
@@ -570,12 +570,12 @@ TYPE
 				ELSE
 					RETURN FALSE;
 				END;
-			ELSIF ThisToken(Scanner.Plus) THEN
+			ELSIF ThisSymbol(Scanner.Plus) THEN
 				IF ~Term (x, critical) THEN RETURN FALSE
 				ELSE
 					RETURN (x.type IN ConstantIntegerOrOffset) OR (x.type = ConstantFloat)
 				END;
-			ELSIF ThisToken(Scanner.Not) THEN
+			ELSIF ThisSymbol(Scanner.Not) THEN
 				IF Term (x, critical) THEN
 					IF x.type IN ConstantIntegerOrOffset THEN
 						x.value := -x.value-1; x.valueR := x.value
@@ -585,8 +585,8 @@ TYPE
 				END;
 			ELSIF ~Term (x, critical) THEN RETURN FALSE
 			END;
-			WHILE (symbol.token = Scanner.Plus) OR (symbol.token = Scanner.Minus) DO
-				op := symbol.token; NextSymbol;
+			WHILE (token.symbol = Scanner.Plus) OR (token.symbol = Scanner.Minus) DO
+				op := token.symbol; NextToken;
 				IF Term (y, critical) THEN
 					IF op = Scanner.Plus THEN
 						IF (x.type IN ConstantIntegerOrOffset) & (y.type IN ConstantIntegerOrOffset) THEN
@@ -640,26 +640,26 @@ TYPE
 				IF Trace THEN D.String("Data"); D.Ln; END;
 				REPEAT
 					pos := errorPosition;
-					IF symbol.token = Scanner.String THEN
+					IF token.symbol = Scanner.String THEN
 						IF (pass = MaxPasses) & (code.comments # NIL) THEN
 							code.comments.String(ident); section.comments.String(' "');
-							code.comments.String(symbol.string^);
+							code.comments.String(token.string^);
 							code.comments.String('"');
 							code.comments.Ln;
 							code.comments.Update
 						END;
 						i := 0;
-						WHILE symbol.string[i] # 0X DO
-							PutBitsIfLastPass(ORD(symbol.string[i]),size);
+						WHILE token.string[i] # 0X DO
+							PutBitsIfLastPass(ORD(token.string[i]),size);
 							INC(i);
 						END;
-						NextSymbol;
+						NextToken;
 
-					ELSIF (symbol.token = Scanner.Identifier) & GetNonConstant(errorPosition,symbol.identifierString,result) THEN
+					ELSIF (token.symbol = Scanner.Identifier) & GetNonConstant(errorPosition,token.identifierString,result) THEN
 						IF (pass = MaxPasses) & (code.comments # NIL) THEN
 							code.comments.String(ident);
 							code.comments.String(" ");
-							code.comments.String(symbol.identifierString);
+							code.comments.String(token.identifierString);
 							code.comments.Ln;
 							code.comments.Update
 						END;
@@ -675,7 +675,7 @@ TYPE
 						END;
 
 						PutBitsIfLastPass(0,size);
-						NextSymbol;
+						NextToken;
 
 					ELSIF Expression(x,FALSE) THEN
 						IF x.type # ConstantInteger THEN Error(pos,"forbidden non-constant value") END;
@@ -697,7 +697,7 @@ TYPE
 
 					ELSE Error(pos,"expected string or expression");
 					END;
-				UNTIL error OR ~ThisToken(Scanner.Comma);
+				UNTIL error OR ~ThisSymbol(Scanner.Comma);
 			END;
 			RETURN TRUE
 		END Data;
@@ -729,24 +729,24 @@ TYPE
 				result: Result; first: BOOLEAN; str: ARRAY 256 OF CHAR;
 			BEGIN
 				first := TRUE;
-				WHILE ~error & (symbol.token # Scanner.Ln) & (symbol.token # Scanner.Comma) DO
-					IF (symbol.token = Scanner.Identifier) & GetNonConstant(errorPosition,symbol.identifierString,result) THEN
+				WHILE ~error & (token.symbol # Scanner.Ln) & (token.symbol # Scanner.Comma) DO
+					IF (token.symbol = Scanner.Identifier) & GetNonConstant(errorPosition,token.identifierString,result) THEN
 							D.String("(* non constant ");
-							D.String(symbol.identifierString); D.String("="); DumpResult(D.Log,result);
+							D.String(token.identifierString); D.String("="); DumpResult(D.Log,result);
 							D.String("*)");
-					ELSIF (symbol.token = Scanner.Identifier) & GetConstant(errorPosition,symbol.identifierString,result) THEN
+					ELSIF (token.symbol = Scanner.Identifier) & GetConstant(errorPosition,token.identifierString,result) THEN
 							D.String("(* constant ");
 							DumpResult(D.Log,result);
 							D.String("*)");
 					END;
 					IF first THEN first := FALSE ELSE Strings.Append(operand," ") END;
-					Scanner.SymbolToString(symbol, scanner.case, str);
+					Scanner.TokenToString(token, scanner.case, str);
 					Strings.Append(operand, str);
-					NextSymbol;
+					NextToken;
 				END;
 				IF Trace THEN
 					D.String("operand= ");
-					D.String(operand); IF symbol.token = Scanner.Comma THEN D.String(" , ") END;
+					D.String(operand); IF token.symbol = Scanner.Comma THEN D.String(" , ") END;
 				END;
 			END ParseOperand;
 		BEGIN
@@ -754,19 +754,19 @@ TYPE
 				D.String("Instruction= "); D.String(mnemonic);  D.String(" ");
 			END;
 			numberOperands := 0;
-			IF ~ThisToken(Scanner.Ln) THEN
+			IF ~ThisSymbol(Scanner.Ln) THEN
 				REPEAT
 					ParseOperand(errorPosition,numberOperands);
 					INC(numberOperands);
-				UNTIL error OR ~ThisToken(Scanner.Comma);
-				IF ~error & ExpectToken(Scanner.Ln) THEN END;
+				UNTIL error OR ~ThisSymbol(Scanner.Comma);
+				IF ~error & ExpectSymbol(Scanner.Ln) THEN END;
 			END;
 			IF Trace THEN D.Ln END
 		END Instruction;
 
 		PROCEDURE IgnoreNewLines;
 		BEGIN
-			WHILE ThisToken(Scanner.Ln) DO END;
+			WHILE ThisSymbol(Scanner.Ln) DO END;
 		END IgnoreNewLines;
 
 		PROCEDURE DoAssemble();
@@ -781,21 +781,21 @@ TYPE
 			NEW(results);
 
 			scanner.GetContext(context);
-			NextSymbol;
+			NextToken;
 			IgnoreNewLines;
-			WHILE ~error & (symbol.token # Scanner.Period) & (symbol.token # Scanner.EndOfText) DO
-				IF ThisToken(Scanner.Number) THEN
-					line := symbol.integer;
-					IF ThisToken(Scanner.Colon) THEN (* line number *)
-					ELSE Error(symbol.position,"Identifier expected");
+			WHILE ~error & (token.symbol # Scanner.Period) & (token.symbol # Scanner.EndOfText) DO
+				IF ThisSymbol(Scanner.Number) THEN
+					line := token.integer;
+					IF ThisSymbol(Scanner.Colon) THEN (* line number *)
+					ELSE Error(token.position,"Identifier expected");
 					END;
 				END;
 				IF ExpectIdentifier(pos,identifier) THEN
-					IF ThisToken(Scanner.Colon) THEN (* label *)
+					IF ThisSymbol(Scanner.Colon) THEN (* label *)
 						DefineLabel(pos,identifier)
-					ELSIF ThisIdentifier("equ") OR ThisToken(Scanner.Equal) THEN
+					ELSIF ThisIdentifier("equ") OR ThisSymbol(Scanner.Equal) THEN
 						IF Expression(result,FALSE) THEN DefineResult(pos,identifier,result) END;
-					ELSE scanner.SkipToEndOfLine; NextSymbol;
+					ELSE scanner.SkipToEndOfLine; NextToken;
 					END;
 				END;
 				IgnoreNewLines;
@@ -807,17 +807,17 @@ TYPE
 				code.SetPC(orgCodePos);
 				SetContext(context);
 				IgnoreNewLines;
-				WHILE ~error & (symbol.token # Scanner.EndOfText) & (symbol.token # Scanner.Period) DO
-					IF ThisToken(Scanner.Number) THEN
-						line := symbol.integer;
-						IF ThisToken(Scanner.Colon) THEN (* line number *)
-						ELSE Error(symbol.position,"Identifier expected");
+				WHILE ~error & (token.symbol # Scanner.EndOfText) & (token.symbol # Scanner.Period) DO
+					IF ThisSymbol(Scanner.Number) THEN
+						line := token.integer;
+						IF ThisSymbol(Scanner.Colon) THEN (* line number *)
+						ELSE Error(token.position,"Identifier expected");
 						END;
 					END;
 					IF ExpectIdentifier(pos,identifier) THEN
-						IF ThisToken(Scanner.Colon) THEN (* label *)
+						IF ThisSymbol(Scanner.Colon) THEN (* label *)
 							SetLabel(pos,identifier);
-						ELSIF ThisIdentifier("equ") OR ThisToken(Scanner.Equal) THEN (* constant definition *)
+						ELSIF ThisIdentifier("equ") OR ThisSymbol(Scanner.Equal) THEN (* constant definition *)
 							IF Expression(result,FALSE) THEN SetResult(identifier,result) END;
 						ELSE
 							IF identifier = "section" THEN
@@ -832,7 +832,7 @@ TYPE
 								errorPosition := pos;
 								Instruction(identifier);
 								(*
-								IF ~error & ExpectToken(Scanner.Ln) THEN END;
+								IF ~error & ExpectSymbol(Scanner.Ln) THEN END;
 								*)
 							END;
 						END;
@@ -872,7 +872,7 @@ TYPE
 			IF Trace THEN D.String("AllSections"); D.Ln END;
 			SetContext(scanner.startContext);
 			IgnoreNewLines;
-			WHILE ThisToken(Scanner.Period) & ExpectIdentifier(pos,sectionType) & ExpectIdentifier(pos,sectionName) DO
+			WHILE ThisSymbol(Scanner.Period) & ExpectIdentifier(pos,sectionType) & ExpectIdentifier(pos,sectionName) DO
 				D.String("section "); D.String(sectionType); D.String(" "); D.String(sectionName); D.Ln;
 				DoAssemble;
 			END;
@@ -913,12 +913,12 @@ TYPE
 	END Test;
 
 	PROCEDURE TestScanner*(context: Commands.Context);
-	VAR scanner: Scanner.AssemblerScanner;  diagnostics: Diagnostics.StreamDiagnostics; symbol: Scanner.Symbol;
+	VAR scanner: Scanner.AssemblerScanner;  diagnostics: Diagnostics.StreamDiagnostics; token: Scanner.Token;
 	BEGIN
 		NEW(diagnostics,context.out);
 		scanner := Scanner.NewAssemblerScanner("command",context.arg,0,diagnostics);
-		WHILE scanner.GetNextSymbol(symbol) & (symbol.token # Scanner.EndOfText)  DO
-			Scanner.OutSymbol(context.out, symbol); context.out.Ln;
+		WHILE scanner.GetNextToken(token) & (token.symbol # Scanner.EndOfText)  DO
+			Scanner.PrintToken(context.out, token); context.out.Ln;
 		END;
 	END TestScanner;
 

source/FoxDisassembler.Mod

@@ -121,35 +121,35 @@ TYPE
 
 		PROCEDURE ParseLogFile*(file: Files.File): Block;
 		VAR reader: Files.Reader; newline: BOOLEAN; sectionName: ObjectFile.SectionName; scanner: Scanner.AssemblerScanner;
-			symbol: Scanner.Symbol; b: BOOLEAN; block: Block; first: Block; last: Block;
+			token: Scanner.Token; b: BOOLEAN; block: Block; first: Block; last: Block;
 
-			PROCEDURE GetNextSymbol;
+			PROCEDURE GetNextToken;
 			VAR b: BOOLEAN;
-			BEGIN b := scanner.GetNextSymbol(symbol)
-			END GetNextSymbol;
+			BEGIN b := scanner.GetNextToken(token)
+			END GetNextToken;
 
-			PROCEDURE ExpectToken(token: LONGINT): BOOLEAN;
-			BEGIN IF symbol.token = token THEN GetNextSymbol; RETURN TRUE ELSE RETURN FALSE END;
+			PROCEDURE ExpectToken(symbol: Scanner.Symbol): BOOLEAN;
+			BEGIN IF token.symbol = symbol THEN GetNextToken; RETURN TRUE ELSE RETURN FALSE END;
 			END ExpectToken;
 
 			PROCEDURE ExpectIdentifier(VAR name: ARRAY OF CHAR): BOOLEAN;
 			BEGIN
-				IF (symbol.token = Scanner.Identifier) THEN COPY(symbol.identifierString,name); GetNextSymbol; RETURN TRUE
+				IF (token.symbol = Scanner.Identifier) THEN COPY(token.identifierString,name); GetNextToken; RETURN TRUE
 				ELSE RETURN FALSE
 				END;
 			END ExpectIdentifier;
 
 			PROCEDURE ExpectThisIdentifier(CONST name: ARRAY OF CHAR): BOOLEAN;
 			BEGIN
-				IF (symbol.token = Scanner.Identifier) & (symbol.identifierString = name) THEN GetNextSymbol; RETURN TRUE
+				IF (token.symbol = Scanner.Identifier) & (token.identifierString = name) THEN GetNextToken; RETURN TRUE
 				ELSE RETURN FALSE
 				END;
 			END ExpectThisIdentifier;
 
 			PROCEDURE ExpectNumber(VAR int: LONGINT):BOOLEAN;
 			BEGIN
-				IF (symbol.token = Scanner.Number) THEN
-					int := SHORT(symbol.hugeint); GetNextSymbol; RETURN TRUE
+				IF (token.symbol = Scanner.Number) THEN
+					int := SHORT(token.hugeint); GetNextToken; RETURN TRUE
 				ELSE RETURN FALSE
 				END;
 			END ExpectNumber;
@@ -168,7 +168,7 @@ TYPE
 					codeDisplacement := displacement; dataDisplacement := displacement
 				ELSIF ExpectThisIdentifier("data") & ExpectThisIdentifier("displacement") & ExpectNumber(displacement) THEN
 					dataDisplacement := displacement;
-				ELSE scanner.SkipToEndOfLine; GetNextSymbol;	scanner.ResetError;
+				ELSE scanner.SkipToEndOfLine; GetNextToken;	scanner.ResetError;
 				END;
 				IF (block # NIL) & Trace THEN
 					D.String("found section ");
@@ -185,14 +185,14 @@ TYPE
 			IF file = NIL THEN RETURN NIL END;
 			NEW(reader, file, 0);
 			scanner := Scanner.NewAssemblerScanner("",reader,0,NIL);
-			b := scanner.GetNextSymbol(symbol);
+			b := scanner.GetNextToken(token);
 			REPEAT
 				block := ParseLine();
 				IF block # NIL THEN
 					IF first = NIL THEN first := block; last := block ELSE last.next := block; last := block END;
 				END;
-				GetNextSymbol
-			UNTIL symbol.token = Scanner.EndOfText;
+				GetNextToken
+			UNTIL token.symbol = Scanner.EndOfText;
 			RETURN first;
 		END ParseLogFile;
 

source/FoxIntermediateAssembler.Mod

@@ -29,23 +29,23 @@ TYPE
 
 				IF numberOperands >= 3 THEN Error(errorPosition,"too many operands")
 				ELSE
-					memory := ThisToken(Scanner.LeftBracket);
-					IF (symbol.token = Scanner.Identifier) & IntermediateCode.DenotesRegister(symbol.identifierString,class1,register1) THEN
-						NextSymbol;
-						stop := ~ThisToken(Scanner.Plus);
+					memory := ThisSymbol(Scanner.LeftBracket);
+					IF (token.symbol = Scanner.Identifier) & IntermediateCode.DenotesRegister(token.identifierString,class1,register1) THEN
+						NextToken;
+						stop := ~ThisSymbol(Scanner.Plus);
 					END;
 					IF ~stop THEN
-						IF (symbol.token = Scanner.Identifier) THEN
-							IF IntermediateCode.DenotesRegister(symbol.identifierString,class2,register2) THEN
-								NextSymbol;
-							ELSIF GetNonConstant(errorPosition,symbol.identifierString,result) THEN
-								NextSymbol;
+						IF (token.symbol = Scanner.Identifier) THEN
+							IF IntermediateCode.DenotesRegister(token.identifierString,class2,register2) THEN
+								NextToken;
+							ELSIF GetNonConstant(errorPosition,token.identifierString,result) THEN
+								NextToken;
 							ELSIF Expression(result,FALSE) THEN
 							END;
 						ELSIF Expression(result,FALSE) THEN
 						END;
 					END;
-					IF memory & ExpectToken(Scanner.RightBracket) THEN
+					IF memory & ExpectSymbol(Scanner.RightBracket) THEN
 						(*
 						IntermediateCode.InitMemory(operand,register1,register2,result.value);
 						*)
@@ -76,11 +76,11 @@ TYPE
 			IF mnem >= 0 THEN
 				FOR i := 0 TO 2 DO IntermediateCode.InitOperand(operands[i]) END;
 				numberOperands := 0;
-				IF symbol.token # Scanner.Ln THEN
+				IF token.symbol # Scanner.Ln THEN
 					REPEAT
 						ParseOperand;
 						INC(numberOperands);
-					UNTIL error OR ~ThisToken(Scanner.Comma);
+					UNTIL error OR ~ThisSymbol(Scanner.Comma);
 				END;
 
 				IF ~error THEN

source/FoxIntermediateParser.Mod

@@ -20,7 +20,7 @@ TYPE
 	VAR
 		diagnostics: Diagnostics.Diagnostics;
 		error: BOOLEAN;
-		symbol: Scanner.Symbol;
+		token: Scanner.Token;
 		scanner: Scanner.AssemblerScanner;
 		system: Global.System;
 
@@ -41,37 +41,37 @@ TYPE
 			IF Trace THEN D.TraceBack END
 		END Error;
 
-		PROCEDURE NextSymbol;
-		BEGIN error := error OR ~scanner.GetNextSymbol(symbol)
-		END NextSymbol;
+		PROCEDURE NextToken;
+		BEGIN error := error OR ~scanner.GetNextToken(token)
+		END NextToken;
 
-		PROCEDURE ThisToken(x: LONGINT): BOOLEAN;
+		PROCEDURE ThisSymbol(x: Scanner.Symbol): BOOLEAN;
 		BEGIN
-			IF ~error & (symbol.token = x) THEN NextSymbol; RETURN TRUE ELSE RETURN FALSE END;
-		END ThisToken;
+			IF ~error & (token.symbol = x) THEN NextToken; RETURN TRUE ELSE RETURN FALSE END;
+		END ThisSymbol;
 
 		PROCEDURE GetIdentifier(VAR pos: Position; VAR identifier: ARRAY OF CHAR): BOOLEAN;
 		BEGIN
-			pos := symbol.position;
-			IF symbol.token # Scanner.Identifier THEN RETURN FALSE
-			ELSE COPY(symbol.identifierString,identifier); NextSymbol; RETURN TRUE
+			pos := token.position;
+			IF token.symbol # Scanner.Identifier THEN RETURN FALSE
+			ELSE COPY(token.identifierString,identifier); NextToken; RETURN TRUE
 			END;
 		END GetIdentifier;
 
-		PROCEDURE ExpectToken(x: LONGINT): BOOLEAN;
+		PROCEDURE ExpectSymbol(x: Scanner.Symbol): BOOLEAN;
 		VAR
 			s: MessageString;
 		BEGIN
-			IF ThisToken(x) THEN RETURN TRUE
+			IF ThisSymbol(x) THEN RETURN TRUE
 			ELSE
-				s := "expected token "; Strings.Append(s,Scanner.tokens[x]); Strings.Append(s," but got "); Strings.Append(s,Scanner.tokens[symbol.token]);
-				Error(symbol.position, s);RETURN FALSE
+				s := "expected symbol "; Strings.Append(s,Scanner.symbols[x]); Strings.Append(s," but got "); Strings.Append(s,Scanner.symbols[token.symbol]);
+				Error(token.position, s);RETURN FALSE
 			END;
-		END ExpectToken;
+		END ExpectSymbol;
 
 		PROCEDURE ThisIdentifier(CONST this: ARRAY OF CHAR): BOOLEAN;
 		BEGIN
-			IF ~error & (symbol.token = Scanner.Identifier) & (this = symbol.identifierString) THEN NextSymbol; RETURN TRUE ELSE RETURN FALSE END;
+			IF ~error & (token.symbol = Scanner.Identifier) & (this = token.identifierString) THEN NextToken; RETURN TRUE ELSE RETURN FALSE END;
 		END ThisIdentifier;
 
 		PROCEDURE ExpectAnyIdentifier(VAR pos: Position; VAR identifier: ARRAY OF CHAR): BOOLEAN;
@@ -85,12 +85,12 @@ TYPE
 		VAR
 			result, isNegated: BOOLEAN;
 		BEGIN
-			isNegated := ThisToken(Scanner.Minus);
-			IF ExpectToken(Scanner.Number) & (symbol.numberType = Scanner.Integer) THEN
+			isNegated := ThisSymbol(Scanner.Minus);
+			IF ExpectSymbol(Scanner.Number) & (token.numberType = Scanner.Integer) THEN
 				IF isNegated THEN
-					integer := -symbol.integer
+					integer := -token.integer
 				ELSE
-					integer := symbol.integer
+					integer := token.integer
 				END;
 				result := TRUE
 			ELSE
@@ -103,8 +103,8 @@ TYPE
 		VAR
 			result: BOOLEAN;
 		BEGIN
-			IF ExpectToken(Scanner.Number) & (symbol.numberType = Scanner.Integer) THEN
-				integer := symbol.integer;
+			IF ExpectSymbol(Scanner.Number) & (token.numberType = Scanner.Integer) THEN
+				integer := token.integer;
 				result := TRUE
 			ELSE
 				result := FALSE
@@ -114,17 +114,17 @@ TYPE
 
 		PROCEDURE IgnoreNewLines;
 		BEGIN
-			WHILE ThisToken(Scanner.Ln) DO END;
+			WHILE ThisSymbol(Scanner.Ln) DO END;
 		END IgnoreNewLines;
 
-		(* expect the newline or end-of-text symbol *)
+		(* expect the newline or end-of-text token *)
 		PROCEDURE ExpectLineDelimiter(): BOOLEAN;
 		BEGIN
-			IF ~error & ((symbol.token = Scanner.Ln) OR (symbol.token = Scanner.EndOfText)) THEN
-				NextSymbol;
+			IF ~error & ((token.symbol = Scanner.Ln) OR (token.symbol = Scanner.EndOfText)) THEN
+				NextToken;
 				RETURN TRUE
 			ELSE
-				Error(symbol.position, "end of line/text expected");
+				Error(token.position, "end of line/text expected");
 				RETURN FALSE
 			END;
 		END ExpectLineDelimiter;
@@ -138,10 +138,10 @@ TYPE
 		BEGIN
 			IF Trace THEN D.String(">>> ParseLineNumber"); D.Ln END;
 
-			positionOfLine := symbol.position;
-			IF ThisToken(Scanner.Number) THEN (* note: line numbers are optional *)
-				specifiedLineNumber := symbol.integer;
-				IF ExpectToken(Scanner.Colon) THEN
+			positionOfLine := token.position;
+			IF ThisSymbol(Scanner.Number) THEN (* note: line numbers are optional *)
+				specifiedLineNumber := token.integer;
+				IF ExpectSymbol(Scanner.Colon) THEN
 					IF Strict & (specifiedLineNumber # expectedLineNumber) THEN
 						message := "invalid code line number (";
 						Strings.IntToStr(specifiedLineNumber, tempString); Strings.Append(message, tempString);
@@ -169,7 +169,7 @@ TYPE
 		BEGIN
 			IF Trace THEN D.String(">>> ParseOperand"); D.Ln END;
 
-			positionOfOperand := symbol.position;
+			positionOfOperand := token.position;
 
 			(* defaults *)
 			hasTypeDescriptor := FALSE;
@@ -184,7 +184,7 @@ TYPE
 
 			(* consume optional memory operand bracket *)
 			IF ~lastWasIdentifier THEN
-				isMemoryOperand := ThisToken(Scanner.LeftBracket);
+				isMemoryOperand := ThisSymbol(Scanner.LeftBracket);
 				lastWasIdentifier := GetIdentifier(pos, identifier)
 			END;
 
@@ -199,11 +199,11 @@ TYPE
 					symbolOffset := 0;
 
 					(* consume optional symbol offset *)
-					IF ThisToken(Scanner.Colon) THEN
+					IF ThisSymbol(Scanner.Colon) THEN
 						IF ExpectIntegerWithSign(integer) THEN
 							symbolOffset := integer
 						ELSE
-							Error(symbol.position, "invalid symbol offset")
+							Error(token.position, "invalid symbol offset")
 						END
 					END;
 
@@ -213,18 +213,18 @@ TYPE
 					IntermediateCode.InitAddress(operand, IntermediateCode.UnsignedIntegerType(system.addressSize), name, 0, symbolOffset)
 				END
 
-			ELSIF symbol.token = Scanner.String THEN
+			ELSIF token.symbol = Scanner.String THEN
 				(* string constant *)
-				IntermediateCode.InitString(operand, symbol.string);
-				NextSymbol
+				IntermediateCode.InitString(operand, token.string);
+				NextToken
 
 			ELSE
 				(* immediate values/numbers *)
-				isNegated := ThisToken(Scanner.Minus);
-				IF ThisToken(Scanner.Number) THEN
-					CASE symbol.numberType OF
+				isNegated := ThisSymbol(Scanner.Minus);
+				IF ThisSymbol(Scanner.Number) THEN
+					CASE token.numberType OF
 					| Scanner.Integer:
-						IF isNegated THEN someLongint := -symbol.integer ELSE someLongint := symbol.integer END;
+						IF isNegated THEN someLongint := -token.integer ELSE someLongint := token.integer END;
 						IF ~hasTypeDescriptor THEN
 							(* if no type description was included: use number type *)
 							IntermediateCode.InitNumber(operand, someLongint);
@@ -236,7 +236,7 @@ TYPE
 							IntermediateCode.InitImmediate(operand, type, someLongint)
 						END
 					| Scanner.Hugeint:
-						IF isNegated THEN someHugeint := - symbol.hugeint ELSE someHugeint := symbol.hugeint END;
+						IF isNegated THEN someHugeint := - token.hugeint ELSE someHugeint := token.hugeint END;
 						IF ~hasTypeDescriptor THEN
 							(* if no type description was included: use number type *)
 							IntermediateCode.InitNumber(operand, someHugeint)
@@ -248,7 +248,7 @@ TYPE
 							IntermediateCode.InitImmediate(operand, type, someHugeint)
 						END
 					| Scanner.Real, Scanner.Longreal:
-						IF isNegated THEN someLongreal := -symbol.real ELSE someLongreal := symbol.real END;
+						IF isNegated THEN someLongreal := -token.real ELSE someLongreal := token.real END;
 						(* if no type description was included: use float type with same amount of bits as address type *)
 						IF ~hasTypeDescriptor THEN
 							IntermediateCode.InitType(type, IntermediateCode.Float, INTEGER(system.addressSize))
@@ -266,22 +266,22 @@ TYPE
 			END;
 
 			(* consume optional offset given in system units *)
-			IF ThisToken(Scanner.Plus) THEN
+			IF ThisSymbol(Scanner.Plus) THEN
 				IF ExpectIntegerWithoutSign(integer) THEN
 					IntermediateCode.SetOffset(operand, integer)
 				ELSE
-					Error(symbol.position, "invalid offset")
+					Error(token.position, "invalid offset")
 				END
-			ELSIF ThisToken(Scanner.Minus) THEN
+			ELSIF ThisSymbol(Scanner.Minus) THEN
 				IF ExpectIntegerWithoutSign(integer) THEN
 					IntermediateCode.SetOffset(operand, -integer)
 				ELSE
-					Error(symbol.position, "invalid offset")
+					Error(token.position, "invalid offset")
 				END
 			END;
 
 			(* wrap memory operand around current operand if necessary *)
-			IF isMemoryOperand & ExpectToken(Scanner.RightBracket) THEN
+			IF isMemoryOperand & ExpectSymbol(Scanner.RightBracket) THEN
 				IntermediateCode.SetType(operand, IntermediateCode.UnsignedIntegerType(system.addressSize)); (* set the type of the inner operand to the platform's address type *)
 				IF ~hasTypeDescriptor THEN
 					IntermediateCode.InitType(type, IntermediateCode.SignedInteger, INTEGER(system.addressSize)) (* default: signed integer type of address size *)
@@ -303,7 +303,7 @@ TYPE
 		BEGIN
 			IF Trace THEN D.String(">>> ParseInstruction"); D.Ln END;
 
-			positionOfInstruction := symbol.position;
+			positionOfInstruction := token.position;
 			IF ExpectAnyIdentifier(positionOfInstruction, identifier) THEN
 				(* TODO: detect labels of the form << labelName: >> *)
 				opCode := IntermediateCode.FindMnemonic(identifier);
@@ -318,9 +318,9 @@ TYPE
 					IntermediateCode.InitOperand(operands[2]);
 
 					operandNumber := 0;
-					IF ~ThisToken(Scanner.Ln) & ~ThisToken(Scanner.EndOfText) THEN
+					IF ~ThisSymbol(Scanner.Ln) & ~ThisSymbol(Scanner.EndOfText) THEN
 						REPEAT
-							positionOfOperand := symbol.position;
+							positionOfOperand := token.position;
 							IF operandNumber > 2 THEN
 								Error(positionOfInstruction, "instruction has too many operands")
 							ELSE
@@ -335,7 +335,7 @@ TYPE
 									INC(operandNumber)
 								END
 							END
-						UNTIL error OR ~ThisToken(Scanner.Comma);
+						UNTIL error OR ~ThisSymbol(Scanner.Comma);
 						IF ~error & ExpectLineDelimiter() THEN END
 					END;
 
@@ -362,7 +362,7 @@ TYPE
 			SELF.scanner := scanner;
 			IgnoreNewLines;
 			lineNumber := 0;
-			WHILE ~error & (symbol.token # Scanner.Period) & (symbol.token # Scanner.EndOfText) DO
+			WHILE ~error & (token.symbol # Scanner.Period) & (token.symbol # Scanner.EndOfText) DO
 				(* consume optional line number *)
 				ParseLineNumber(lineNumber);
 				IF ~error THEN
@@ -384,11 +384,11 @@ TYPE
 		BEGIN
 			IF Trace THEN D.Ln; D.String(">>> ParseSectionProperties"); D.Ln END;
 
-			WHILE ~error & (symbol.token # Scanner.EndOfText) & (symbol.token # Scanner.Ln) DO
-				positionOfProperty := symbol.position;
+			WHILE ~error & (token.symbol # Scanner.EndOfText) & (token.symbol # Scanner.Ln) DO
+				positionOfProperty := token.position;
 
 				(* fingerprint *)
-				IF ThisIdentifier("fingerprint") & ExpectToken(Scanner.Equal) THEN
+				IF ThisIdentifier("fingerprint") & ExpectSymbol(Scanner.Equal) THEN
 					IF ExpectIntegerWithSign(integer) THEN
 						IF (section.fingerprint # 0) & (section.fingerprint # integer) THEN
 							Error(positionOfProperty, "incompatible fingerprint");
@@ -400,7 +400,7 @@ TYPE
 					END
 
 				(* position *)
-				ELSIF ThisIdentifier("aligned") & ExpectToken(Scanner.Equal) THEN
+				ELSIF ThisIdentifier("aligned") & ExpectSymbol(Scanner.Equal) THEN
 					IF ExpectIntegerWithSign(integer) THEN
 						section.SetPositionOrAlignment(FALSE, integer)
 					ELSE
@@ -408,7 +408,7 @@ TYPE
 					END
 
 				(* fixed position *)
-				ELSIF ThisIdentifier("fixed") & ExpectToken(Scanner.Equal) THEN
+				ELSIF ThisIdentifier("fixed") & ExpectSymbol(Scanner.Equal) THEN
 					IF ExpectIntegerWithSign(integer) THEN
 						section.SetPositionOrAlignment(TRUE, integer)
 					ELSE
@@ -416,7 +416,7 @@ TYPE
 					END
 
 				(* unit size of the section in bits *)
-				ELSIF ThisIdentifier("unit") & ExpectToken(Scanner.Equal) THEN
+				ELSIF ThisIdentifier("unit") & ExpectSymbol(Scanner.Equal) THEN
 					IF ExpectIntegerWithSign(integer) THEN
 						section.SetBitsPerUnit(integer) (* overwrite default unit size *)
 					ELSE
@@ -424,7 +424,7 @@ TYPE
 					END
 
 				(* total size of the section in units *)
-				ELSIF ThisIdentifier("size") & ExpectToken(Scanner.Equal) THEN
+				ELSIF ThisIdentifier("size") & ExpectSymbol(Scanner.Equal) THEN
 					IF ExpectIntegerWithSign(integer) THEN
 						 (* nothing to do (this property is ignored, since the size is calculated from the actual content) *)
 					ELSE
@@ -455,16 +455,16 @@ TYPE
 
 			ASSERT(scanner # NIL);
 			SELF.scanner := scanner;
-			NextSymbol; (* read first symbol *)
+			NextToken; (* read first token *)
 
 			(* go through directives *)
 			afterModuleDirective := FALSE;
 			afterImportsDirective := FALSE;
 			afterFirstSection := FALSE;
 			IgnoreNewLines;
-			WHILE ~error & (symbol.token # Scanner.EndOfText) DO
-				positionOfDirective := symbol.position;
-				IF ExpectToken(Scanner.Period) & ExpectAnyIdentifier(pos, identifier) THEN
+			WHILE ~error & (token.symbol # Scanner.EndOfText) DO
+				positionOfDirective := token.position;
+				IF ExpectSymbol(Scanner.Period) & ExpectAnyIdentifier(pos, identifier) THEN
 					(* 'module' directive *)
 					IF identifier = "module" THEN
 						IF afterModuleDirective THEN
@@ -502,7 +502,7 @@ TYPE
 									IF ~loader(identifier) THEN Error(positionOfDirective, "could not import") END;
 									*)
 								END
-							UNTIL error OR ~ThisToken(Scanner.Comma);
+							UNTIL error OR ~ThisSymbol(Scanner.Comma);
 							IF ExpectLineDelimiter() THEN
 								afterImportsDirective := TRUE
 							END
@@ -512,8 +512,8 @@ TYPE
 					ELSE
 						(* determine if section is external *)
 						IF identifier = "external" THEN
-							positionOfDirective := symbol.position;
-							IF ExpectToken(Scanner.Period) & ExpectAnyIdentifier(pos, identifier) THEN END;
+							positionOfDirective := token.position;
+							IF ExpectSymbol(Scanner.Period) & ExpectAnyIdentifier(pos, identifier) THEN END;
 							isExternalSection := TRUE
 						ELSE
 							isExternalSection := FALSE

source/FoxScanner.Mod

@@ -25,9 +25,9 @@ TYPE
 
 CONST
 
-(** tokens *)
+(** symbols *)
 	(*
-	note: order of tokens is important for the parser, do not modify without looking it up
+	note: order of symbols is important for the parser, do not modify without looking it up
 
 	FoxProgTools.Enum --export --linefeed=6
     	None
@@ -168,15 +168,15 @@ TYPE
 	END KeywordTable;
 TYPE
 
-	Token*=LONGINT;
+	Symbol*=LONGINT;
 	Position*= Basic.Position;
 
 	(**
-		symbol: data structure for the data transfer of the last read input from the scanner to the parser
+		token: data structure for the data transfer of the last read input from the scanner to the parser
 	**)
-	Symbol*= RECORD
+	Token*= RECORD
 		position*: Position;
-		token*: Token; (* token of symbol *)
+		symbol*: Symbol; (* symbol of token *)
 		identifier*: IdentifierType; (* identifier *)
 		identifierString*: IdentifierString; (* cache of identifier's string *)
 		string*: StringType;  (* string or identifier *)
@@ -260,8 +260,8 @@ TYPE
 	END StringMaker;
 
 	(** scanner reflects the following EBNF
-		Symbol 				= String | Token | Number | Keyword | Identifier.
-		Token 				=  | '#' | '&' | '(' ['*' any '*' ')'] | ')' | '*'['*'] | '+'['*'] | ',' | '-' | '.' [ '.' | '*' | '/' | '=' | '#' | '>'['='] | '<' ['=']
+		Token 				= String | Symbol | Number | Keyword | Identifier.
+		Symbol 				=  | '#' | '&' | '(' ['*' any '*' ')'] | ')' | '*'['*'] | '+'['*'] | ',' | '-' | '.' [ '.' | '*' | '/' | '=' | '#' | '>'['='] | '<' ['=']
 											  | '/' | ':' ['='] | ';'  | '<' ['=' | '<' ['?'] ] | '=' | '>' [ '=' | '>' ['?']]  
 											  | '[' | ']' | '^' | '{' | '|' | '}' | '~' | '\' |  '`' |  '?' ['?'] | '!' ['!']
 		Identifier			= Letter {Letter | Digit | '_'}.
@@ -315,7 +315,7 @@ TYPE
 			case := Unknown;
 			firstIdentifier := TRUE;
 			SELF.position := pos; 
-			DEC(position.start, 1); (* one symbol lookahead *)
+			DEC(position.start, 1); (* one token lookahead *)
 			IF reader = NIL THEN ch := EOT ELSE 	GetNextCharacter END;
 			IF Trace THEN D.Str( "New scanner  " );   D.Ln;  END;
 			IF source = "" THEN SELF.position.reader := reader END; 
@@ -487,7 +487,7 @@ TYPE
 			IF ch = EOT THEN position.start := startPosition; ErrorS("Unexpected end of text in string") END;
 		END ConsumeStringUntil;
 
-		PROCEDURE GetEscapedString(VAR symbol: Symbol);
+		PROCEDURE GetEscapedString(VAR token: Token);
 		VAR endString: ARRAY 4 OF CHAR; escape: CHAR;
 		BEGIN
 			(* backslash already consumed *)
@@ -513,7 +513,7 @@ TYPE
 			UNTIL TRUE;
 			stringWriter.Char(0X);
 			stringWriter.Update;
-			symbol.string := stringMaker.GetStringCopy(symbol.stringLength);
+			token.string := stringMaker.GetStringCopy(token.stringLength);
 		END GetEscapedString;
 
 
@@ -522,7 +522,7 @@ TYPE
 		**)
 		(* multiline indicates that a string may occupy more than one lines, either concatenated or via multi-strings " "  " "
 		*)
-		PROCEDURE GetString(VAR symbol: Symbol; multiLine, multiString, useControl: BOOLEAN);
+		PROCEDURE GetString(VAR token: Token; multiLine, multiString, useControl: BOOLEAN);
 		VAR och: CHAR; error: BOOLEAN;
 		CONST control = '\';
 
@@ -568,7 +568,7 @@ TYPE
 			UNTIL ~multiString OR (ch # och);
 			stringWriter.Char(0X);
 			stringWriter.Update;
-			symbol.string := stringMaker.GetStringCopy(symbol.stringLength);
+			token.string := stringMaker.GetStringCopy(token.stringLength);
 		END GetString;
 
 		(**
@@ -578,14 +578,14 @@ TYPE
 
 			'_' is the underscore character
 		**)
-		PROCEDURE GetIdentifier( VAR symbol: Symbol );
+		PROCEDURE GetIdentifier( VAR token: Token );
 		VAR i: LONGINT;
 		BEGIN
 			i := 0;
-			REPEAT symbol.identifierString[i] := ch; INC( i );  GetNextCharacter UNTIL reservedCharacter[ORD( ch )] OR (i = MaxIdentifierLength);
+			REPEAT token.identifierString[i] := ch; INC( i );  GetNextCharacter UNTIL reservedCharacter[ORD( ch )] OR (i = MaxIdentifierLength);
 			IF i = MaxIdentifierLength THEN Error( Basic.IdentifierTooLong );  DEC( i ) END;
-			symbol.identifierString[i] := 0X;
-			StringPool.GetIndex(symbol.identifierString, symbol.identifier);
+			token.identifierString[i] := 0X;
+			StringPool.GetIndex(token.identifierString, token.identifier);
 		END GetIdentifier;
 
 		(**
@@ -596,11 +596,11 @@ TYPE
 		HexDigit     =  Digit | 'A' | 'B' | 'C' | 'D' | 'E' | 'F'.
 		Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' .
 		**)
-		PROCEDURE GetNumber(VAR symbol: Symbol): Token;
+		PROCEDURE GetNumber(VAR token: Token): Symbol;
 		VAR i, nextInt, m, n, d, e, si: LONGINT;
 			dig: ARRAY 24 OF CHAR;
 			f: LONGREAL;  expCh: CHAR;  neg, long: BOOLEAN;
-			result: Token;
+			result: Symbol;
 			hugeint, tenh, number: HUGEINT;
 			digits: LONGINT;
 
@@ -659,12 +659,12 @@ TYPE
 						GetNextCharacter;
 						IF (ch = "'") & IsHexDigit(reader.Peek()) THEN GetNextCharacter END;
 					END;
-					symbol.hugeint := number;
-					symbol.integer := SHORT(number);
+					token.hugeint := number;
+					token.integer := SHORT(number);
 					IF (digits > MaxHexDigits) OR (digits = MaxHexDigits) & (number > MAX(LONGINT)) THEN
-						symbol.numberType := Hugeint
+						token.numberType := Hugeint
 					ELSE
-						symbol.numberType := Integer
+						token.numberType := Integer
 					END;
 					RETURN result;
 				ELSIF reader.Peek() = "b" THEN (* binary number *)
@@ -678,12 +678,12 @@ TYPE
 						GetNextCharacter;
 						IF (ch = "'") & IsBinaryDigit(reader.Peek()) THEN GetNextCharacter END;
 					END;
-					symbol.hugeint := number;
-					symbol.integer := SHORT(number);
+					token.hugeint := number;
+					token.integer := SHORT(number);
 					IF digits > 32 THEN
-						symbol.numberType := Hugeint
+						token.numberType := Hugeint
 					ELSE
-						symbol.numberType := Integer
+						token.numberType := Integer
 					END;
 					RETURN result;
 				END;
@@ -695,9 +695,9 @@ TYPE
 						IF n < LEN( dig ) THEN dig[n] := ch;  INC( n ) END;
 						INC( m )
 					END;
-					symbol.identifierString[si] := ch;  INC( si );  GetNextCharacter;  INC( i )
+					token.identifierString[si] := ch;  INC( si );  GetNextCharacter;  INC( i )
 				ELSIF ch = "." THEN
-					symbol.identifierString[si] := ch;  INC( si );  GetNextCharacter;
+					token.identifierString[si] := ch;  INC( si );  GetNextCharacter;
 					IF ch = "." THEN ch := Ellipsis;  EXIT
 					ELSIF d = 0 THEN  (* i > 0 *) d := i
 					ELSE Error( Basic.NumberIllegalCharacter )
@@ -708,70 +708,70 @@ TYPE
 			END;   (* 0 <= n <= m <= i, 0 <= d <= i *)
 			IF d = 0 THEN  (* integer *)
 				IF n = m THEN
-					symbol.integer := 0;  i := 0;  symbol.hugeint := 0;
+					token.integer := 0;  i := 0;  token.hugeint := 0;
 					IF ch = "X" THEN  (* character *)
-						symbol.identifierString[si] := ch;  INC( si );  GetNextCharacter;  result := Character;
+						token.identifierString[si] := ch;  INC( si );  GetNextCharacter;  result := Character;
 						IF  (n <= 2) THEN
-							WHILE i < n DO symbol.integer := symbol.integer * 10H + Hexadecimal( dig[i] );  INC( i ) END;
-							symbol.character := CHR(symbol.integer);
+							WHILE i < n DO token.integer := token.integer * 10H + Hexadecimal( dig[i] );  INC( i ) END;
+							token.character := CHR(token.integer);
 						ELSE Error( Basic.NumberTooLarge )
 						END
 					ELSIF ch = "H" THEN  (* hexadecimal *)
-						symbol.identifierString[si] := ch;  INC( si );  GetNextCharacter;
+						token.identifierString[si] := ch;  INC( si );  GetNextCharacter;
 						IF (n < MaxHexDigits) OR (n=MaxHexDigits) & (dig[0] <= "7")  THEN (* otherwise the positive (!) number is not in the range of longints *)
-							symbol.numberType := Integer;
-							(* IF (n = MaxHexDigits) & (dig[0] > "7") THEN  (* prevent overflow *) symbol.integer := -1 END;  *)
-							WHILE i < n DO symbol.integer := symbol.integer * 10H + Hexadecimal( dig[i] );  INC( i ) END;
-							symbol.hugeint := symbol.integer;
+							token.numberType := Integer;
+							(* IF (n = MaxHexDigits) & (dig[0] > "7") THEN  (* prevent overflow *) token.integer := -1 END;  *)
+							WHILE i < n DO token.integer := token.integer * 10H + Hexadecimal( dig[i] );  INC( i ) END;
+							token.hugeint := token.integer;
 						ELSIF n <= MaxHugeHexDigits THEN
-							symbol.numberType := Hugeint;
-							IF (n = MaxHugeHexDigits) & (dig[0] > "7") THEN  (* prevent overflow *) symbol.hugeint := -1 END;
-							WHILE i < n DO symbol.hugeint := Hexadecimal( dig[i] ) + symbol.hugeint * 10H; INC( i ) END;
-							symbol.integer :=SHORT(symbol.hugeint);
+							token.numberType := Hugeint;
+							IF (n = MaxHugeHexDigits) & (dig[0] > "7") THEN  (* prevent overflow *) token.hugeint := -1 END;
+							WHILE i < n DO token.hugeint := Hexadecimal( dig[i] ) + token.hugeint * 10H; INC( i ) END;
+							token.integer :=SHORT(token.hugeint);
 						ELSE
-							symbol.numberType := Hugeint; (* to make parser able to go on *)
+							token.numberType := Hugeint; (* to make parser able to go on *)
 							Error( Basic.NumberTooLarge )
 						END
 					ELSE  (* decimal *)
-						symbol.numberType := Integer;
+						token.numberType := Integer;
 						WHILE (i < n) & ~long  DO
 							d := Decimal( dig[i] );  INC( i );
-							IF symbol.integer >= MAX(LONGINT) DIV 10 THEN (* multiplication overflow *)long := TRUE END;
-							nextInt := symbol.integer*10+d;
-							IF nextInt >=0 THEN symbol.integer := nextInt ELSE (* overflow *) long := TRUE END;
+							IF token.integer >= MAX(LONGINT) DIV 10 THEN (* multiplication overflow *)long := TRUE END;
+							nextInt := token.integer*10+d;
+							IF nextInt >=0 THEN token.integer := nextInt ELSE (* overflow *) long := TRUE END;
 						END;
 						IF long THEN
 							i := 0; (* restart computation , artificial limit because of compiler problems with hugeint *)
 							hugeint := 0;
 							tenh := 10; (* compiler does not like constants here ! *)
-							symbol.numberType := Hugeint;
+							token.numberType := Hugeint;
 							WHILE i < n DO
 								d := Decimal( dig[i] );  INC( i );
 								IF hugeint > MAX(HUGEINT) DIV 10 THEN Error( Basic.NumberTooLarge) END;
 								hugeint := hugeint * tenh + d;
 								IF hugeint < 0 THEN Error( Basic.NumberTooLarge ) END
 							END;
-							symbol.hugeint := hugeint;
-							symbol.integer := SHORT(symbol.hugeint);
+							token.hugeint := hugeint;
+							token.integer := SHORT(token.hugeint);
 						ELSE
-							symbol.hugeint := symbol.integer;
+							token.hugeint := token.integer;
 						END
 					END
 				ELSE
-					symbol.numberType := Hugeint;
+					token.numberType := Hugeint;
 					Error( Basic.NumberTooLarge )
 				END
 			ELSE  (* fraction *)
 				f := 0;  e := 0;  expCh := "E";
 				WHILE n > 0 DO  (* 0 <= f < 1 *) DEC( n );  f := (Decimal( dig[n] ) + f) / 10 END;
 				IF (ch = "E") OR (ch = "D") THEN
-					expCh := ch;  symbol.identifierString[si] := ch;  INC( si );  GetNextCharacter;  neg := FALSE;
-					IF ch = "-" THEN neg := TRUE;  symbol.identifierString[si] := ch;  INC( si );  GetNextCharacter
-					ELSIF ch = "+" THEN symbol.identifierString[si] := ch;  INC( si );  GetNextCharacter
+					expCh := ch;  token.identifierString[si] := ch;  INC( si );  GetNextCharacter;  neg := FALSE;
+					IF ch = "-" THEN neg := TRUE;  token.identifierString[si] := ch;  INC( si );  GetNextCharacter
+					ELSIF ch = "+" THEN token.identifierString[si] := ch;  INC( si );  GetNextCharacter
 					END;
 					IF ("0" <= ch) & (ch <= "9") THEN
 						REPEAT
-							n := Decimal( ch );  symbol.identifierString[si] := ch;  INC( si );  GetNextCharacter;
+							n := Decimal( ch );  token.identifierString[si] := ch;  INC( si );  GetNextCharacter;
 							IF e <= (MAX( INTEGER ) - n) DIV 10 THEN e := e * 10 + n ELSE Error( Basic.NumberTooLarge ) END
 						UNTIL (ch < "0") OR ("9" < ch);
 						IF neg THEN e := -e END
@@ -780,25 +780,25 @@ TYPE
 				END;
 				DEC( e, i - d - m );   (* decimal point shift *)
 				IF expCh = "E" THEN
-					symbol.numberType := Real;
+					token.numberType := Real;
 					IF (1 - MaxRealExponent < e) & (e <= MaxRealExponent) THEN
-						IF e < 0 THEN symbol.real :=  f / Ten( -e ) ELSE symbol.real := f * Ten( e )  END
+						IF e < 0 THEN token.real :=  f / Ten( -e ) ELSE token.real := f * Ten( e )  END
 					ELSE Error( Basic.NumberTooLarge )
 					END
 				ELSE
-					symbol.numberType := Longreal;
+					token.numberType := Longreal;
 					IF (1 - MaxLongrealExponent < e) & (e <= MaxLongrealExponent) THEN
-						IF e < 0 THEN symbol.real := f / Ten( -e ) ELSE symbol.real := f * Ten( e ) END
+						IF e < 0 THEN token.real := f / Ten( -e ) ELSE token.real := f * Ten( e ) END
 					ELSE Error( Basic.NumberTooLarge )
 					END
 				END
 			END;
-			symbol.identifierString[si] := 0X;
+			token.identifierString[si] := 0X;
 			RETURN result;
 		END GetNumber;
 
 		(** read / skip a comment **)
-		PROCEDURE ReadComment(VAR symbol: Symbol);
+		PROCEDURE ReadComment(VAR token: Token);
 		VAR level: LONGINT;
 		BEGIN
 			stringMaker.Clear;
@@ -825,29 +825,29 @@ TYPE
 			stringWriter.Char(0X);
 			stringWriter.Update;
 			stringMaker.Shorten(2); (* remove comment closing *)
-			symbol.token := Comment;
-			symbol.string := stringMaker.GetString(symbol.stringLength);
+			token.symbol := Comment;
+			token.string := stringMaker.GetString(token.stringLength);
 		END ReadComment;
 
-		PROCEDURE SkipToEndOfCode*(VAR startPos,endPos: LONGINT; VAR symbol: Symbol): Token;
+		PROCEDURE SkipToEndOfCode*(VAR startPos,endPos: LONGINT; VAR token: Token): Symbol;
 		VAR s: LONGINT; newline: BOOLEAN;
 		BEGIN
 			ASSERT(case # Unknown);
 			stringMaker.Clear;
-			startPos := symbol.position.end;
+			startPos := token.position.end;
 			s := Code; newline := FALSE;
 			WHILE (s # EndOfText) & (s # End) & (s # With) & (s # Unequal) DO
-				symbol.position := position;
+				token.position := position;
 				endPos := position.start;
 				IF (ch >= 'A') & (ch <= 'Z') OR (ch >= 'a') & (ch <= 'z') THEN
 					newline := FALSE;
-					GetIdentifier(symbol);
-					IF (case=Uppercase) & (symbol.identifierString = "END") OR (case=Lowercase) & (symbol.identifierString = "end") THEN
+					GetIdentifier(token);
+					IF (case=Uppercase) & (token.identifierString = "END") OR (case=Lowercase) & (token.identifierString = "end") THEN
 						s := End
-					ELSIF (case = Uppercase) & (symbol.identifierString = "WITH") OR (case = Lowercase) & (symbol.identifierString = "with") THEN
+					ELSIF (case = Uppercase) & (token.identifierString = "WITH") OR (case = Lowercase) & (token.identifierString = "with") THEN
 						s := With
 					ELSE
-						stringWriter.String(symbol.identifierString);
+						stringWriter.String(token.identifierString);
 					END;
 				ELSIF (ch = '#') & newline THEN
 					s := Unequal;
@@ -859,15 +859,15 @@ TYPE
 					stringWriter.Char(ch);
 					GetNextCharacter;
 				END;
-				symbol.position.end := position.start;
+				token.position.end := position.start;
 			END;
 			stringWriter.Update;
-			symbol.string := stringMaker.GetStringCopy(symbol.stringLength);
-			symbol.token := s;
+			token.string := stringMaker.GetStringCopy(token.stringLength);
+			token.symbol := s;
 
 			IF Trace THEN
 				D.String("skip to end: "); D.Int(startPos,1); D.String(","); D.Int(endPos,1); D.Ln;
-				OutSymbol(D.Log,symbol); D.Ln;
+				PrintToken(D.Log,token); D.Ln;
 			END;
 			RETURN s
 		END SkipToEndOfCode;
@@ -883,30 +883,30 @@ TYPE
 			END;
 		END SkipBlanks;
 
-		(** get next symbol **)
-		PROCEDURE GetNextSymbol*(VAR symbol: Symbol ): BOOLEAN;
-		VAR s,token: LONGINT;
+		(** get next token **)
+		PROCEDURE GetNextToken*(VAR token: Token ): BOOLEAN;
+		VAR s,symbol: LONGINT;
 		BEGIN
 			SkipBlanks;
-			symbol.position := position;
+			token.position := position;
 			stringMaker.Clear;
 			CASE ch OF  (* ch > " " *)
 			EOT: s := EndOfText
 			|ESC: s := Escape; GetNextCharacter
 			| DoubleQuote:
-					s := String; GetString(symbol,TRUE, TRUE, FALSE);
+					s := String; GetString(token,TRUE, TRUE, FALSE);
 			| SingleQuote:
-					s := String; GetString(symbol,FALSE, FALSE,FALSE);
+					s := String; GetString(token,FALSE, FALSE,FALSE);
 					(* to be replaced by:
-					s := Character; GetString(symbol);
-					IF symbol.stringLength #2 THEN  (* stringlength = 1 for empty string '' *)
+					s := Character; GetString(token);
+					IF token.stringLength #2 THEN  (* stringlength = 1 for empty string '' *)
 						Error(Basic.IllegalCharacterValue)
 					END;
 					*)
 			| '#':     s := Unequal;  GetNextCharacter
 			| '&':     s := And;  GetNextCharacter
 			| '(':     GetNextCharacter;
-					IF ch = '*' THEN GetNextCharacter; ReadComment(symbol);  s := Comment; ELSE s := LeftParenthesis END
+					IF ch = '*' THEN GetNextCharacter; ReadComment(token);  s := Comment; ELSE s := LeftParenthesis END
 			| ')':     s := RightParenthesis;  GetNextCharacter
 			| '*':    GetNextCharacter; IF ch = '*' THEN GetNextCharacter;  s := TimesTimes ELSE s := Times END
 			| '+':    GetNextCharacter; IF ch = '*' THEN GetNextCharacter; s := PlusTimes ELSE s := Plus END
@@ -928,7 +928,7 @@ TYPE
 						END
 					ELSE s := Period END
 			| '/':     s := Slash;  GetNextCharacter
-			| '0'..'9':   s := GetNumber(symbol);
+			| '0'..'9':   s := GetNumber(token);
 			| ':':     GetNextCharacter;
 					IF ch = '=' THEN GetNextCharacter;  s := Becomes  ELSE s := Colon END
 			| ';':     s := Semicolon;  GetNextCharacter
@@ -958,50 +958,50 @@ TYPE
 			| '\':     s := Backslash;  GetNextCharacter;
 					IF ch = DoubleQuote THEN
 						s := String;
-						GetEscapedString(symbol);
+						GetEscapedString(token);
 						(*
-						GetString(symbol, TRUE, TRUE, TRUE)
+						GetString(token, TRUE, TRUE, TRUE)
 						*)
 					ELSIF (ch > " ") & (reader.Peek() = DoubleQuote) THEN
 						s := String;
-						GetEscapedString(symbol);
+						GetEscapedString(token);
 					END;
 			| '`':	s := Transpose; GetNextCharacter
 			| '?': 	s := Questionmark; GetNextCharacter; IF ch = '?' THEN s := Questionmarks; GetNextCharacter END;
 			| '!':     s := ExclamationMark; GetNextCharacter; IF ch = '!' THEN s := ExclamationMarks; GetNextCharacter END;
 			| Ellipsis:
 					s := Upto;  GetNextCharacter
-			| 'A'..'Z': s := Identifier; GetIdentifier( symbol );
+			| 'A'..'Z': s := Identifier; GetIdentifier( token );
 					IF (case=Uppercase) OR (case=Unknown) THEN
-						token := keywordsUpper.IndexByIdentifier(symbol.identifier);
-						IF  (token >= 0) THEN s := token END;
+						symbol := keywordsUpper.IndexByIdentifier(token.identifier);
+						IF  (symbol >= 0) THEN s := symbol END;
 						IF (s = Module) OR (s=CellNet) THEN case := Uppercase END;
 					END;
-			| 'a'..'z': s := Identifier; GetIdentifier( symbol);
+			| 'a'..'z': s := Identifier; GetIdentifier( token);
 					IF (case = Lowercase) OR (case=Unknown) THEN
-						token := keywordsLower.IndexByIdentifier(symbol.identifier);
-						IF  (token >= 0) THEN s := token END;
+						symbol := keywordsLower.IndexByIdentifier(token.identifier);
+						IF  (symbol >= 0) THEN s := symbol END;
 						IF (s = Module) OR (s=CellNet) THEN case := Lowercase END;
 					END;
 					IF firstIdentifier & (s # Module) & (s # CellNet) & (case = Unknown) THEN case := Uppercase; s := Identifier END;
-			ELSE s := Identifier;  GetIdentifier( symbol );
+			ELSE s := Identifier;  GetIdentifier( token );
 			END;
 			firstIdentifier := FALSE;
 
-			symbol.token := s;
-			symbol.position.end := position.start;
+			token.symbol := s;
+			token.position.end := position.start;
 
-			IF Trace THEN OutSymbol(D.Log,symbol); D.Ln; END;
+			IF Trace THEN PrintToken(D.Log,token); D.Ln; END;
 
 			RETURN ~error
-		END GetNextSymbol;
+		END GetNextToken;
 
 		PROCEDURE ResetError*();
 		BEGIN error := FALSE
 		END ResetError;
 
 		(** set the diagnostics mode of the scanner (diagnostics = NIL ==> no report) and reset the error state
-			intended for silent symbol peeeking after the end of a module *)
+			intended for silent token peeeking after the end of a module *)
 		PROCEDURE ResetErrorDiagnostics*(VAR diagnostics: Diagnostics.Diagnostics);
 		VAR d: Diagnostics.Diagnostics;
 		BEGIN
@@ -1018,8 +1018,8 @@ TYPE
 	END;
 
 	(** assembler scanner reflects the following EBNF
-		Symbol 			= String | Token | Number | Identifier.
-		Token 			= '\' | '#' | '(' ['*' any '*' ')'] | ')' | CR [LF] | LF | '*' | '+' | ',' | '-' | '~' | '.' | '/' | '%' | ':' | ';' | '=' | '[' | ']' | '{' | '}' | '!' | '^' | '$'['$'].
+		Token 			= String | Symbol | Number | Identifier.
+		Symbol 			= '\' | '#' | '(' ['*' any '*' ')'] | ')' | CR [LF] | LF | '*' | '+' | ',' | '-' | '~' | '.' | '/' | '%' | ':' | ';' | '=' | '[' | ']' | '{' | '}' | '!' | '^' | '$'['$'].
 		String				= '"' {Character} '"' | "'" {Character} "'".
 		Identifier		= '@' | Letter {'@' | '.' | Letter | Digit | '_'} .
 		Letter 				= 'A' | 'B' | .. |  'Z' | 'a' | 'b' |  .. | 'z' .
@@ -1066,7 +1066,7 @@ TYPE
 		END SkipToEndOfLine;
 
 		(**
-			note: in contrast to a regular identifier, an assembler scanner identifier may also contain periods and the '@'-symbol
+			note: in contrast to a regular identifier, an assembler scanner identifier may also contain periods and the '@'-token
 
 			Identifier = '@' | Letter {'@' | '.' | Letter | Digit | '_'} .
 			Letter = 'A' | 'B' | .. |  'Z' | 'a' | 'b' |  .. | 'z' .
@@ -1074,7 +1074,7 @@ TYPE
 
 			'_' is the underscore character
 		**)
-		PROCEDURE GetIdentifier( VAR symbol: Symbol );
+		PROCEDURE GetIdentifier( VAR token: Token );
 		VAR
 			i: LONGINT;
 
@@ -1088,15 +1088,15 @@ TYPE
 		BEGIN
 			i := 0;
 			REPEAT
-				symbol.identifierString[i] := ch; INC( i );  GetNextCharacter
+				token.identifierString[i] := ch; INC( i );  GetNextCharacter
 			UNTIL ~CharacterIsAllowed(ch) OR (i = MaxIdentifierLength);
 
 			IF i = MaxIdentifierLength THEN Error( Basic.IdentifierTooLong );  DEC( i ) END;
-			symbol.identifierString[i] := 0X;
+			token.identifierString[i] := 0X;
 		END GetIdentifier;
 
-		(** get next symbol **)
-		PROCEDURE GetNextSymbol*(VAR symbol: Symbol ): BOOLEAN;
+		(** get next token **)
+		PROCEDURE GetNextToken*(VAR token: Token ): BOOLEAN;
 		VAR s: LONGINT;
 
 			PROCEDURE SkipBlanks;
@@ -1109,21 +1109,21 @@ TYPE
 		BEGIN
 			REPEAT
 				SkipBlanks;
-				symbol.position := position;
+				token.position := position;
 				CASE ch OF  (* ch > ' ' *)
 				| EOT: 	s := EndOfText;
 				| DoubleQuote:
-						s := String; GetString(symbol, TRUE, FALSE, TRUE);
+						s := String; GetString(token, TRUE, FALSE, TRUE);
 				| SingleQuote:
-						s := Character; GetString(symbol, FALSE, FALSE, FALSE); symbol.character := symbol.string[0];
-						IF symbol.stringLength #2 THEN  (* stringlength = 1 for empty string '' *)
+						s := Character; GetString(token, FALSE, FALSE, FALSE); token.character := token.string[0];
+						IF token.stringLength #2 THEN  (* stringlength = 1 for empty string '' *)
 							Error(Basic.IllegalCharacterValue)
 						END;
 				| '\':     s := Backslash;  GetNextCharacter;
-						IF ch = DoubleQuote THEN s := String; GetString(symbol, FALSE, FALSE, TRUE) END;
+						IF ch = DoubleQuote THEN s := String; GetString(token, FALSE, FALSE, TRUE) END;
 				| '#':     s := Unequal;  GetNextCharacter; (* for the ARM assembler *)
 				| '(': GetNextCharacter;
-						IF ch = '*' THEN GetNextCharacter; ReadComment(symbol);  s := Comment; ELSE s := LeftParenthesis END
+						IF ch = '*' THEN GetNextCharacter; ReadComment(token);  s := Comment; ELSE s := LeftParenthesis END
 				| ')':     s := RightParenthesis;  GetNextCharacter
 				| CR: GetNextCharacter; s := Ln;IF ch = LF THEN GetNextCharacter END;
 				| LF: GetNextCharacter; s := Ln; IF ch = CR THEN GetNextCharacter END;
@@ -1135,7 +1135,7 @@ TYPE
 				| '.':     s:= Period; GetNextCharacter
 				| '/':     s := Div;  GetNextCharacter
 				| '%':	s := Mod; GetNextCharacter
-				| '0'..'9':   s := GetNumber(symbol);
+				| '0'..'9':   s := GetNumber(token);
 				| ':':     s := Colon; GetNextCharacter;
 				| ';':    s := Comment; SkipToEndOfLine;
 				| '=':     s := Equal;  GetNextCharacter
@@ -1146,28 +1146,28 @@ TYPE
 				| '!':     s := ExclamationMark; GetNextCharacter; 
 				| '^':     s := Arrow; GetNextCharacter; 
 
-				| 'A'..'Z': s := Identifier; GetIdentifier( symbol );
-				| 'a'..'z': s := Identifier; GetIdentifier( symbol);
-				| '@':     s := Identifier; GetIdentifier( symbol); (* the '@'-symbol initiates an assembly scanner identifier *)
+				| 'A'..'Z': s := Identifier; GetIdentifier( token );
+				| 'a'..'z': s := Identifier; GetIdentifier( token);
+				| '@':     s := Identifier; GetIdentifier( token); (* the '@'-token initiates an assembly scanner identifier *)
 				| '$': GetNextCharacter;
 					IF ch = '$' THEN s := PCOffset; GetNextCharacter ELSE s := PC; END
 				ELSE s := None; GetNextCharacter;
 				END;
-				symbol.position.end := position.start;
+				token.position.end := position.start;
 			UNTIL s # Comment;
 
-			symbol.token := s;
+			token.symbol := s;
 
-			IF Trace THEN D.Ln;  D.Str( "Scan at " );  D.Int( symbol.position.start,1 );  D.Str( ": " );  OutSymbol(D.Log,symbol); D.Update;  END;
+			IF Trace THEN D.Ln;  D.Str( "Scan at " );  D.Int( token.position.start,1 );  D.Str( ": " );  PrintToken(D.Log,token); D.Update;  END;
 			RETURN ~error
-		END GetNextSymbol;
+		END GetNextToken;
 
 	END AssemblerScanner;
 
 
 	VAR
 		reservedCharacter: ARRAY 256 OF BOOLEAN;
-		tokens-: ARRAY EndOfText+1 OF Keyword;
+		symbols-: ARRAY EndOfText+1 OF Keyword;
 		keywordsLower, keywordsUpper: KeywordTable;
 
 
@@ -1192,40 +1192,40 @@ TYPE
 		NEW( s, source, reader, pos, diagnostics );  RETURN s;
 	END NewAssemblerScanner;
 
-	PROCEDURE SymbolToString*(CONST symbol: Symbol; case: LONGINT; VAR str: ARRAY OF CHAR);
+	PROCEDURE TokenToString*(CONST token: Token; case: LONGINT; VAR str: ARRAY OF CHAR);
 	VAR id: StringPool.Index;
 	BEGIN
-		CASE symbol.token OF
-		Identifier, Number: COPY(symbol.identifierString, str)
-		| String, Comment: ASSERT(LEN(str) >= LEN(symbol.string^)); COPY(symbol.string^, str);
+		CASE token.symbol OF
+		Identifier, Number: COPY(token.identifierString, str)
+		| String, Comment: ASSERT(LEN(str) >= LEN(token.string^)); COPY(token.string^, str);
 		ELSE
-			GetKeyword(case, symbol.token, id);
+			GetKeyword(case, token.symbol, id);
 			IF id < 0 THEN str := "" ELSE StringPool.GetString(id, str) END;
 		END;
-	END SymbolToString;
+	END TokenToString;
 
 	(** debugging output **)
-	PROCEDURE OutSymbol*(w: Streams.Writer; CONST symbol: Symbol);
+	PROCEDURE PrintToken*(w: Streams.Writer; CONST token: Token);
 	VAR str: ARRAY 256 OF CHAR;
 	BEGIN
-		w.Int(symbol.position.start,1); w.String("-");w.Int(symbol.position.end,1); w.String(":");
-		w.String(tokens[symbol.token]);
-		IF symbol.token= Number THEN
-			CASE symbol.numberType OF
+		w.Int(token.position.start,1); w.String("-");w.Int(token.position.end,1); w.String(":");
+		w.String(symbols[token.symbol]);
+		IF token.symbol= Number THEN
+			CASE token.numberType OF
 				Integer: w.String("(integer)")
 				|Hugeint: w.String("(hugeint)")
 				|Real: w.String("(real)")
 				|Longreal: w.String("(longreal)")
 			END;
 		END;
-		IF symbol.token = String THEN
-			w.String(":"); w.Char('"'); w.String(symbol.string^); w.Char('"');
-		ELSIF symbol.token = Comment THEN
-			w.String("(*"); w.String(symbol.string^); w.String("*)");
+		IF token.symbol = String THEN
+			w.String(":"); w.Char('"'); w.String(token.string^); w.Char('"');
+		ELSIF token.symbol = Comment THEN
+			w.String("(*"); w.String(token.string^); w.String("*)");
 		ELSE
-			SymbolToString(symbol, Uppercase, str); w.String(": "); w.String(str);
+			TokenToString(token, Uppercase, str); w.String(": "); w.String(str);
 		END
-	END OutSymbol;
+	END PrintToken;
 
 	(** reserved characters are the characters that may not occur within an identifier **)
 	PROCEDURE InitReservedCharacters;
@@ -1242,139 +1242,139 @@ TYPE
 		END;
 	END InitReservedCharacters;
 
-	(* get keyword by token *)
-	PROCEDURE GetKeyword*(case:LONGINT; token: LONGINT; VAR identifier: IdentifierType);
+	(* get keyword by symbol *)
+	PROCEDURE GetKeyword*(case:LONGINT; symbol: LONGINT; VAR identifier: IdentifierType);
 	BEGIN
 		IF case = Uppercase THEN
-			keywordsUpper.IdentifierByIndex(token,identifier);
+			keywordsUpper.IdentifierByIndex(symbol,identifier);
 		ELSE ASSERT(case=Lowercase);
-			keywordsLower.IdentifierByIndex(token,identifier);
+			keywordsLower.IdentifierByIndex(symbol,identifier);
 		END;
 	END GetKeyword;
 
-	PROCEDURE InitTokens;
+	PROCEDURE InitSymbols;
 	VAR i: LONGINT;
 	BEGIN
-		tokens[None] := "None";
-		tokens[Equal] := "Equal";
-		tokens[DotEqual] := "DotEqual";
-		tokens[Unequal] := "Unequal";
-		tokens[DotUnequal] := "DotUnequal";
-		tokens[Less] := "Less";
-		tokens[DotLess] := "DotLess";
-		tokens[LessEqual] := "LessEqual";
-		tokens[DotLessEqual] := "DotLessEqual";
-		tokens[Greater] := "Greater";
-		tokens[DotGreater] := "DotGreater";
-		tokens[GreaterEqual] := "GreaterEqual";
-		tokens[DotGreaterEqual] := "DotGreaterEqual";
-		tokens[LessLessQ] := "LessLessQ";
-		tokens[GreaterGreaterQ] := "GreaterGreaterQ";
-		tokens[In] := "In";
-		tokens[Is] := "Is";
-		tokens[Times] := "Times";
-		tokens[TimesTimes] := "TimesTimes";
-		tokens[DotTimes] := "DotTimes";
-		tokens[PlusTimes] := "PlusTimes";
-		tokens[Slash] := "Slash";
-		tokens[Backslash] := "Backslash";
-		tokens[DotSlash] := "DotSlash";
-		tokens[Div] := "Div";
-		tokens[Mod] := "Mod";
-		tokens[And] := "And";
-		tokens[Or] := "Or";
-		tokens[Plus] := "Plus";
-		tokens[Minus] := "Minus";
-		tokens[Not] := "Not";
-		tokens[LeftParenthesis] := "LeftParenthesis";
-		tokens[LeftBracket] := "LeftBracket";
-		tokens[LeftBrace] := "LeftBrace";
-		tokens[Number] := "Number";
-		tokens[Character] := "Character";
-		tokens[String] := "String";
-		tokens[Nil] := "Nil";
-		tokens[Imag] := "Imag";
-		tokens[True] := "True";
-		tokens[False] := "False";
-		tokens[Self] := "Self";
-		tokens[New] := "New";
-		tokens[Result] := "Result";
-		tokens[Identifier] := "Identifier";
-		tokens[If] := "If";
-		tokens[Case] := "Case";
-		tokens[While] := "While";
-		tokens[Repeat] := "Repeat";
-		tokens[For] := "For";
-		tokens[Loop] := "Loop";
-		tokens[With] := "With";
-		tokens[Exit] := "Exit";
-		tokens[Await] := "Await";
-		tokens[Return] := "Return";
-		tokens[Ignore] := "Ignore";
-		tokens[Begin] := "Begin";
-		tokens[Semicolon] := "Semicolon";
-		tokens[Transpose] := "Transpose";
-		tokens[RightBrace] := "RightBrace";
-		tokens[RightBracket] := "RightBracket";
-		tokens[RightParenthesis] := "RightParenthesis";
-		tokens[Questionmark] := "Questionmark";
-		tokens[ExclamationMark] := "ExclamationMark";
-		tokens[Questionmarks] := "Questionmarks";
-		tokens[ExclamationMarks] := "ExclamationMarks";
-		tokens[LessLess] := "LessLess";
-		tokens[GreaterGreater] := "GreaterGreater";
-		tokens[Upto] := "Upto";
-		tokens[Arrow] := "Arrow";
-		tokens[Period] := "Period";
-		tokens[Comma] := "Comma";
-		tokens[Colon] := "Colon";
-		tokens[Of] := "Of";
-		tokens[Then] := "Then";
-		tokens[Do] := "Do";
-		tokens[To] := "To";
-		tokens[By] := "By";
-		tokens[Becomes] := "Becomes";
-		tokens[Bar] := "Bar";
-		tokens[End] := "End";
-		tokens[Else] := "Else";
-		tokens[Elsif] := "Elsif";
-		tokens[Extern] := "Extern";
-		tokens[Until] := "Until";
-		tokens[Finally] := "Finally";
-		tokens[Code] := "Code";
-		tokens[Const] := "Const";
-		tokens[Type] := "Type";
-		tokens[Var] := "Var";
-		tokens[Out] := "Out";
-		tokens[Procedure] := "Procedure";
-		tokens[Operator] := "Operator";
-		tokens[Import] := "Import";
-		tokens[Definition] := "Definition";
-		tokens[Module] := "Module";
-		tokens[Cell] := "Cell";
-		tokens[CellNet] := "CellNet";
-		tokens[Array] := "Array";
-		tokens[Object] := "Object";
-		tokens[Record] := "Record";
-		tokens[Pointer] := "Pointer";
-		tokens[Enum] := "Enum";
-		tokens[Port] := "Port";
-		tokens[Address] := "Address";
-		tokens[Alias] := "Alias";
-		tokens[Size] := "Size";
-		tokens[Ln] := "Ln";
-		tokens[PC] := "PC";
-		tokens[PCOffset] := "PCOffset";
-		tokens[Shortint] := "Shortint";
-		tokens[Integer] := "Integer";
-		tokens[Longint] := "Longint";
-		tokens[Hugeint] := "Hugeint";
-		tokens[Real] := "Real";
-		tokens[Longreal] := "Longreal";
-		tokens[Comment] := "Comment";
-		tokens[EndOfText] := "EndOfText";
-		FOR i := 0 TO EndOfText DO ASSERT(tokens[i] # "") END;
-	END InitTokens;
+		symbols[None] := "None";
+		symbols[Equal] := "Equal";
+		symbols[DotEqual] := "DotEqual";
+		symbols[Unequal] := "Unequal";
+		symbols[DotUnequal] := "DotUnequal";
+		symbols[Less] := "Less";
+		symbols[DotLess] := "DotLess";
+		symbols[LessEqual] := "LessEqual";
+		symbols[DotLessEqual] := "DotLessEqual";
+		symbols[Greater] := "Greater";
+		symbols[DotGreater] := "DotGreater";
+		symbols[GreaterEqual] := "GreaterEqual";
+		symbols[DotGreaterEqual] := "DotGreaterEqual";
+		symbols[LessLessQ] := "LessLessQ";
+		symbols[GreaterGreaterQ] := "GreaterGreaterQ";
+		symbols[In] := "In";
+		symbols[Is] := "Is";
+		symbols[Times] := "Times";
+		symbols[TimesTimes] := "TimesTimes";
+		symbols[DotTimes] := "DotTimes";
+		symbols[PlusTimes] := "PlusTimes";
+		symbols[Slash] := "Slash";
+		symbols[Backslash] := "Backslash";
+		symbols[DotSlash] := "DotSlash";
+		symbols[Div] := "Div";
+		symbols[Mod] := "Mod";
+		symbols[And] := "And";
+		symbols[Or] := "Or";
+		symbols[Plus] := "Plus";
+		symbols[Minus] := "Minus";
+		symbols[Not] := "Not";
+		symbols[LeftParenthesis] := "LeftParenthesis";
+		symbols[LeftBracket] := "LeftBracket";
+		symbols[LeftBrace] := "LeftBrace";
+		symbols[Number] := "Number";
+		symbols[Character] := "Character";
+		symbols[String] := "String";
+		symbols[Nil] := "Nil";
+		symbols[Imag] := "Imag";
+		symbols[True] := "True";
+		symbols[False] := "False";
+		symbols[Self] := "Self";
+		symbols[New] := "New";
+		symbols[Result] := "Result";
+		symbols[Identifier] := "Identifier";
+		symbols[If] := "If";
+		symbols[Case] := "Case";
+		symbols[While] := "While";
+		symbols[Repeat] := "Repeat";
+		symbols[For] := "For";
+		symbols[Loop] := "Loop";
+		symbols[With] := "With";
+		symbols[Exit] := "Exit";
+		symbols[Await] := "Await";
+		symbols[Return] := "Return";
+		symbols[Ignore] := "Ignore";
+		symbols[Begin] := "Begin";
+		symbols[Semicolon] := "Semicolon";
+		symbols[Transpose] := "Transpose";
+		symbols[RightBrace] := "RightBrace";
+		symbols[RightBracket] := "RightBracket";
+		symbols[RightParenthesis] := "RightParenthesis";
+		symbols[Questionmark] := "Questionmark";
+		symbols[ExclamationMark] := "ExclamationMark";
+		symbols[Questionmarks] := "Questionmarks";
+		symbols[ExclamationMarks] := "ExclamationMarks";
+		symbols[LessLess] := "LessLess";
+		symbols[GreaterGreater] := "GreaterGreater";
+		symbols[Upto] := "Upto";
+		symbols[Arrow] := "Arrow";
+		symbols[Period] := "Period";
+		symbols[Comma] := "Comma";
+		symbols[Colon] := "Colon";
+		symbols[Of] := "Of";
+		symbols[Then] := "Then";
+		symbols[Do] := "Do";
+		symbols[To] := "To";
+		symbols[By] := "By";
+		symbols[Becomes] := "Becomes";
+		symbols[Bar] := "Bar";
+		symbols[End] := "End";
+		symbols[Else] := "Else";
+		symbols[Elsif] := "Elsif";
+		symbols[Extern] := "Extern";
+		symbols[Until] := "Until";
+		symbols[Finally] := "Finally";
+		symbols[Code] := "Code";
+		symbols[Const] := "Const";
+		symbols[Type] := "Type";
+		symbols[Var] := "Var";
+		symbols[Out] := "Out";
+		symbols[Procedure] := "Procedure";
+		symbols[Operator] := "Operator";
+		symbols[Import] := "Import";
+		symbols[Definition] := "Definition";
+		symbols[Module] := "Module";
+		symbols[Cell] := "Cell";
+		symbols[CellNet] := "CellNet";
+		symbols[Array] := "Array";
+		symbols[Object] := "Object";
+		symbols[Record] := "Record";
+		symbols[Pointer] := "Pointer";
+		symbols[Enum] := "Enum";
+		symbols[Port] := "Port";
+		symbols[Address] := "Address";
+		symbols[Alias] := "Alias";
+		symbols[Size] := "Size";
+		symbols[Ln] := "Ln";
+		symbols[PC] := "PC";
+		symbols[PCOffset] := "PCOffset";
+		symbols[Shortint] := "Shortint";
+		symbols[Integer] := "Integer";
+		symbols[Longint] := "Longint";
+		symbols[Hugeint] := "Hugeint";
+		symbols[Real] := "Real";
+		symbols[Longreal] := "Longreal";
+		symbols[Comment] := "Comment";
+		symbols[EndOfText] := "EndOfText";
+		FOR i := 0 TO EndOfText DO ASSERT(symbols[i] # "") END;
+	END InitSymbols;
 
 	(** enter keywords in the list of keywords (both upper- and lowercase)  **)
 	PROCEDURE InitKeywords;
@@ -1390,24 +1390,24 @@ TYPE
 			UNTIL c = 0X;
 		END Upper;
 
-		PROCEDURE Enter1(CONST name: ARRAY OF CHAR; token: LONGINT; case: SET);
+		PROCEDURE Enter1(CONST name: ARRAY OF CHAR; symbol: LONGINT; case: SET);
 		BEGIN
-			IF Lowercase IN case THEN keywordsLower.PutString(name,token) END;
-			IF Uppercase IN case THEN keywordsUpper.PutString(name,token) END;
-			Basic.SetErrorExpected(token,name);
+			IF Lowercase IN case THEN keywordsLower.PutString(name,symbol) END;
+			IF Uppercase IN case THEN keywordsUpper.PutString(name,symbol) END;
+			Basic.SetErrorExpected(symbol,name);
 		END Enter1;
 
-		PROCEDURE Enter(CONST name: ARRAY OF CHAR; token: LONGINT);
+		PROCEDURE Enter(CONST name: ARRAY OF CHAR; symbol: LONGINT);
 		VAR upper: Keyword;
 		BEGIN
-			Enter1(name,token,{Lowercase});
+			Enter1(name,symbol,{Lowercase});
 			Upper(name,upper);
-			Enter1(upper,token,{Uppercase});
+			Enter1(upper,symbol,{Uppercase});
 		END Enter;
 
-		PROCEDURE EnterSymbol(CONST name: ARRAY OF CHAR; token: LONGINT);
+		PROCEDURE EnterSymbol(CONST name: ARRAY OF CHAR; symbol: LONGINT);
 		BEGIN
-			Enter1(name,token,{Lowercase,Uppercase});
+			Enter1(name,symbol,{Lowercase,Uppercase});
 		END EnterSymbol;
 
 	BEGIN
@@ -1474,7 +1474,7 @@ TYPE
 		Enter( "size" , Size);
 		Enter( "alias" , Alias);
 
-		(* symbols *)
+		(* tokens *)
 		EnterSymbol( "#", Unequal);
 		EnterSymbol( "&", And);
 		EnterSymbol( "(", LeftParenthesis);
@@ -1526,7 +1526,7 @@ TYPE
 		Basic.SetErrorMessage(String,"missing string");
 		Basic.SetErrorMessage(Character,"missing character");
 		Basic.SetErrorMessage(Identifier,"missing identifier");
-		Basic.SetErrorMessage(EndOfText,"unexpected symbol before end");
+		Basic.SetErrorMessage(EndOfText,"unexpected token before end");
 	  END InitKeywords;
 
 	(** debugging / reporting **)
@@ -1551,21 +1551,21 @@ TYPE
 
 	(*
 	PROCEDURE TestScanner*(context: Commands.Context);
-	VAR filename: ARRAY 256 OF CHAR; reader: Streams.Reader; scanner: Scanner;sym: Symbol;
+	VAR filename: ARRAY 256 OF CHAR; reader: Streams.Reader; scanner: Scanner;token: Token;
 	BEGIN
 		context.arg.SkipWhitespace; context.arg.String(filename);
 		reader := TextUtilities.GetTextReader(filename);
 		scanner := NewScanner(filename,reader,0,NIL);
 		REPEAT
-			IF scanner.GetNextSymbol(sym) THEN
-				OutSymbol(context.out,sym);context.out.Ln;
+			IF scanner.GetNextToken(token) THEN
+				PrintToken(context.out,token);context.out.Ln;
 			END;
-		UNTIL scanner.error OR (sym.token=EndOfText)
+		UNTIL scanner.error OR (token.symbol=EndOfText)
 	END TestScanner;
 	*)
 
 BEGIN
-	InitReservedCharacters;   InitTokens; InitKeywords
+	InitReservedCharacters; InitSymbols; InitKeywords
 END FoxScanner.
 
 FoxScanner.ReportKeywords

source/FoxTRMAssembler.Mod

@@ -39,23 +39,23 @@ TYPE
 
 				IF numberOperands >= 2 THEN Error(errorPosition,"too many operands")
 				ELSE
-					memory := ThisToken(Scanner.LeftBracket);
-					IF (symbol.token = Scanner.Identifier) & GetRegister(symbol.identifierString,register1) THEN
-						NextSymbol;
-						stop := ~ThisToken(Scanner.Plus);
+					memory := ThisSymbol(Scanner.LeftBracket);
+					IF (token.symbol = Scanner.Identifier) & GetRegister(token.identifierString,register1) THEN
+						NextToken;
+						stop := ~ThisSymbol(Scanner.Plus);
 					END;
 					IF ~stop THEN
-						IF (symbol.token = Scanner.Identifier) THEN
-							IF GetRegister(symbol.identifierString,register2) THEN
-								NextSymbol;
-							ELSIF GetNonConstant(errorPosition,symbol.identifierString, result) THEN
-								NextSymbol;
+						IF (token.symbol = Scanner.Identifier) THEN
+							IF GetRegister(token.identifierString,register2) THEN
+								NextToken;
+							ELSIF GetNonConstant(errorPosition,token.identifierString, result) THEN
+								NextToken;
 							ELSIF Expression(result,FALSE) THEN
 							END;
 						ELSIF Expression(result,FALSE) THEN
 						END;
 					END;
-					IF memory & ExpectToken(Scanner.RightBracket) THEN
+					IF memory & ExpectSymbol(Scanner.RightBracket) THEN
 						instructionSet.InitMemory(operand,register1,LONGINT(result.value));
 					ELSIF register1 # -1 THEN
 						instructionSet.InitRegister(operand,register1);
@@ -78,11 +78,11 @@ TYPE
 			IF mnem >= 0 THEN
 				FOR i := 0 TO 2 DO instructionSet.InitOperand(operands[i]) END;
 				numberOperands := 0;
-				IF symbol.token # Scanner.Ln THEN
+				IF token.symbol # Scanner.Ln THEN
 					REPEAT
 						ParseOperand;
 						INC(numberOperands);
-					UNTIL error OR ~ThisToken(Scanner.Comma);
+					UNTIL error OR ~ThisSymbol(Scanner.Comma);
 				END;
 				IF ~error THEN
 					instructionSet.MakeInstruction(instruction,mnem,operands[0],operands[1]);

source/ModuleParser.Mod

@@ -372,7 +372,7 @@ TYPE
 
 	Parser = OBJECT
 	VAR
-		symbol : FoxScanner.Symbol;
+		token : FoxScanner.Token;
 		scanner: FoxScanner.Scanner;
 		hasError: BOOLEAN;
 
@@ -383,70 +383,70 @@ TYPE
 			hasError := FALSE;
 		END Init;
 
-		PROCEDURE NextSymbol;
+		PROCEDURE NextToken;
 		VAR ignore : BOOLEAN;
 		BEGIN
-			ignore := scanner.GetNextSymbol(symbol);
-			WHILE (symbol.token = FoxScanner.Comment) DO ignore := scanner.GetNextSymbol(symbol); END;
-		END NextSymbol;
+			ignore := scanner.GetNextToken(token);
+			WHILE (token.symbol = FoxScanner.Comment) DO ignore := scanner.GetNextToken(token); END;
+		END NextToken;
 
 		PROCEDURE ModuleP(VAR module: Module);
 		VAR
 			modName: FoxScanner.IdentifierString;
 			definition: Definition;
 		BEGIN
-			NextSymbol;
-			IF (symbol.token = FoxScanner.Module) OR (symbol.token = FoxScanner.CellNet) THEN
+			NextToken;
+			IF (token.symbol = FoxScanner.Module) OR (token.symbol = FoxScanner.CellNet) THEN
 				NEW(module, NIL); module.parent := module;
-				NextSymbol;
-				IF symbol.token = FoxScanner.Identifier THEN
+				NextToken;
+				IF token.symbol = FoxScanner.Identifier THEN
 					NEW(module.ident);
-					COPY(symbol.identifierString, modName);
-					module.ident.name := Strings.NewString(symbol.identifierString);
-					module.ident.pos := symbol.position.start;
+					COPY(token.identifierString, modName);
+					module.ident.name := Strings.NewString(token.identifierString);
+					module.ident.pos := token.position.start;
 				END;
-				NextSymbol;
-				IF symbol.token = FoxScanner.In THEN
-					NextSymbol;
-					IF symbol.token = FoxScanner.Identifier THEN
+				NextToken;
+				IF token.symbol = FoxScanner.In THEN
+					NextToken;
+					IF token.symbol = FoxScanner.Identifier THEN
 						NEW(module.context);
-						module.context.name := Strings.NewString(symbol.identifierString);
-						module.context.pos := symbol.position.start;
+						module.context.name := Strings.NewString(token.identifierString);
+						module.context.pos := token.position.start;
 					END;
 					Check (FoxScanner.Identifier);
 				END;
-				IF symbol.token = FoxScanner.LeftBrace THEN
-					WHILE (symbol.token # FoxScanner.Semicolon) & (symbol.token # FoxScanner.EndOfText) DO NextSymbol END;
+				IF token.symbol = FoxScanner.LeftBrace THEN
+					WHILE (token.symbol # FoxScanner.Semicolon) & (token.symbol # FoxScanner.EndOfText) DO NextToken END;
 				END;
 				Check(FoxScanner.Semicolon);
-				IF symbol.token = FoxScanner.Import THEN
+				IF token.symbol = FoxScanner.Import THEN
 					NEW(module.importList, module);
 					ImportListP(module.importList);
 				END;
-				WHILE symbol.token = FoxScanner.Definition DO
+				WHILE token.symbol = FoxScanner.Definition DO
 					NEW(definition, module);
 					DefinitionP(definition);
 					IF module.definitions = NIL THEN module.definitions := definition
 					ELSE AppendLast(module.definitions, definition)
 					END;
 				END;
-				IF 	(symbol.token = FoxScanner.Const) OR (symbol.token = FoxScanner.Type) OR
-					(symbol.token = FoxScanner.Var) OR (symbol.token = FoxScanner.Procedure) OR (symbol.token = FoxScanner.Operator) THEN
+				IF 	(token.symbol = FoxScanner.Const) OR (token.symbol = FoxScanner.Type) OR
+					(token.symbol = FoxScanner.Var) OR (token.symbol = FoxScanner.Procedure) OR (token.symbol = FoxScanner.Operator) THEN
 					NEW(module.declSeq, module);
 					DeclSeqP(module.declSeq);
 				END;
-				IF (symbol.token = FoxScanner.Begin) THEN
-					module.bodyPos := symbol.position.start;
+				IF (token.symbol = FoxScanner.Begin) THEN
+					module.bodyPos := token.position.start;
 				ELSE
 					module.bodyPos := 0;
 				END;
 				BodyP(FALSE, module.modifiers);
-				IF (symbol.token = FoxScanner.Identifier) & (symbol.identifierString = modName) THEN
+				IF (token.symbol = FoxScanner.Identifier) & (token.identifierString = modName) THEN
 					(* correct *)
 				ELSE
 					(* maybe missing END or wrong module name *)
 					hasError := TRUE;
-					KernelLog.String("err3: "); KernelLog.Int(symbol.position.start, 0); KernelLog.Ln;
+					KernelLog.String("err3: "); KernelLog.Int(token.position.start, 0); KernelLog.Ln;
 				END;
 				module.hasError := hasError;
 			END;
@@ -455,36 +455,36 @@ TYPE
 		PROCEDURE ImportListP(import: Import);
 		VAR newImport: Import;
 		BEGIN
-			NextSymbol;
-			WHILE symbol.token = FoxScanner.Identifier DO
+			NextToken;
+			WHILE token.symbol = FoxScanner.Identifier DO
 				NEW(import.ident);
-				import.ident.name := Strings.NewString(symbol.identifierString);
-				import.ident.pos := symbol.position.start;
-				NextSymbol;	(* avoids endless loop *)
-				IF symbol.token = FoxScanner.Becomes THEN
-					NextSymbol;
-					IF symbol.token = FoxScanner.Identifier THEN
+				import.ident.name := Strings.NewString(token.identifierString);
+				import.ident.pos := token.position.start;
+				NextToken;	(* avoids endless loop *)
+				IF token.symbol = FoxScanner.Becomes THEN
+					NextToken;
+					IF token.symbol = FoxScanner.Identifier THEN
 						NEW(import.alias);
-						import.alias.name := Strings.NewString(symbol.identifierString);
-						import.alias.pos := symbol.position.start;
-						NextSymbol;
+						import.alias.name := Strings.NewString(token.identifierString);
+						import.alias.pos := token.position.start;
+						NextToken;
 					ELSE
 						(* Error *)
 						hasError := TRUE;
-						KernelLog.String("err2: "); KernelLog.Int(symbol.position.start, 0); KernelLog.Ln;
+						KernelLog.String("err2: "); KernelLog.Int(token.position.start, 0); KernelLog.Ln;
 					END;
 				END;
-				IF symbol.token = FoxScanner.In THEN
-					NextSymbol;
-					IF symbol.token = FoxScanner.Identifier THEN
+				IF token.symbol = FoxScanner.In THEN
+					NextToken;
+					IF token.symbol = FoxScanner.Identifier THEN
 						NEW(import.context);
-						import.context.name := Strings.NewString(symbol.identifierString);
-						import.context.pos := symbol.position.start;
+						import.context.name := Strings.NewString(token.identifierString);
+						import.context.pos := token.position.start;
 					END;
 					Check (FoxScanner.Identifier);
 				END;
-				IF symbol.token = FoxScanner.Comma THEN
-					NextSymbol;
+				IF token.symbol = FoxScanner.Comma THEN
+					NextToken;
 				END;
 				NEW(newImport, import.parent);
 				import.next := newImport;
@@ -497,23 +497,23 @@ TYPE
 		VAR
 			procHead: ProcHead;
 		BEGIN
-			IF symbol.token = FoxScanner.Definition THEN
-				NextSymbol;
-				IF symbol.token = FoxScanner.Identifier THEN
+			IF token.symbol = FoxScanner.Definition THEN
+				NextToken;
+				IF token.symbol = FoxScanner.Identifier THEN
 					NEW(definition.ident);
-					definition.ident.name := Strings.NewString(symbol.identifierString);
-					definition.ident.pos := symbol.position.start;
-					NextSymbol;
+					definition.ident.name := Strings.NewString(token.identifierString);
+					definition.ident.pos := token.position.start;
+					NextToken;
 				END;
-				WHILE symbol.token = FoxScanner.Semicolon DO NextSymbol END;
-		(*?		IF symbol.token = FoxScanner.Refines THEN
-					NextSymbol;
+				WHILE token.symbol = FoxScanner.Semicolon DO NextToken END;
+		(*?		IF token.symbol = FoxScanner.Refines THEN
+					NextToken;
 					NEW(definition.refines, definition);
 					QualidentP(definition.refines);
 				END; *)
-				WHILE (symbol.token = FoxScanner.Procedure) OR (symbol.token = FoxScanner.Operator) DO
+				WHILE (token.symbol = FoxScanner.Procedure) OR (token.symbol = FoxScanner.Operator) DO
 					NEW(procHead, definition);
-					NextSymbol;
+					NextToken;
 					ProcHeadP(procHead);
 					IF definition.procs = NIL THEN definition.procs := procHead
 					ELSE AppendLast(definition.procs, procHead)
@@ -522,7 +522,7 @@ TYPE
 				END;
 				Check(FoxScanner.End);
 				Check(FoxScanner.Identifier);
-				WHILE symbol.token = FoxScanner.Semicolon DO NextSymbol END;
+				WHILE token.symbol = FoxScanner.Semicolon DO NextToken END;
 			END;
 		END DefinitionP;
 
@@ -535,17 +535,17 @@ TYPE
 
 			PROCEDURE CheckEndOrSemicolon;
 			BEGIN
-				IF symbol.token # FoxScanner.End THEN
-					REPEAT Check(FoxScanner.Semicolon) UNTIL symbol.token # FoxScanner.Semicolon
+				IF token.symbol # FoxScanner.End THEN
+					REPEAT Check(FoxScanner.Semicolon) UNTIL token.symbol # FoxScanner.Semicolon
 				END;
 			END CheckEndOrSemicolon;
 
 		BEGIN
 			LOOP
-				CASE symbol.token OF
+				CASE token.symbol OF
 				| FoxScanner.Const:
-					NextSymbol;
-					WHILE symbol.token = FoxScanner.Identifier DO
+					NextToken;
+					WHILE token.symbol = FoxScanner.Identifier DO
 						NEW(constDecl, declSeq);
 						ConstDeclP(constDecl);
 						IF declSeq.constDecl = NIL THEN declSeq.constDecl := constDecl;
@@ -555,8 +555,8 @@ TYPE
 						(*Check(FoxScanner.Semicolon);*)
 					END;
 				| FoxScanner.Type:
-					NextSymbol;
-					WHILE symbol.token = FoxScanner.Identifier DO
+					NextToken;
+					WHILE token.symbol = FoxScanner.Identifier DO
 						NEW(typeDecl, declSeq);
 						TypeDeclP(typeDecl);
 						IF declSeq.typeDecl = NIL THEN declSeq.typeDecl := typeDecl;
@@ -566,8 +566,8 @@ TYPE
 						(*Check(FoxScanner.Semicolon);*)
 					END;
 				| FoxScanner.Var:
-					NextSymbol;
-					WHILE symbol.token = FoxScanner.Identifier DO
+					NextToken;
+					WHILE token.symbol = FoxScanner.Identifier DO
 						NEW(varDecl, declSeq);
 						VarDeclP(varDecl);
 						IF declSeq.varDecl = NIL THEN declSeq.varDecl := varDecl;
@@ -577,8 +577,8 @@ TYPE
 						(*Check(FoxScanner.Semicolon);*)
 					END;
 				| FoxScanner.Procedure, FoxScanner.Operator:
-					WHILE (symbol.token = FoxScanner.Procedure) OR (symbol.token = FoxScanner.Operator) DO
-						NextSymbol;
+					WHILE (token.symbol = FoxScanner.Procedure) OR (token.symbol = FoxScanner.Operator) DO
+						NextToken;
 						NEW(procDecl, declSeq);
 						ProcDeclP(procDecl);
 						IF procDecl.head = NIL THEN
@@ -635,13 +635,13 @@ TYPE
 			NEW(var.identList.identDef);
 			IdentDefP(var.identList.identDef);
 			SysFlag;
-			IF symbol.token = FoxScanner.Becomes THEN Initializer END;
-			WHILE symbol.token = FoxScanner.Comma DO
-				NextSymbol;	(* avoids endless loop *)
+			IF token.symbol = FoxScanner.Becomes THEN Initializer END;
+			WHILE token.symbol = FoxScanner.Comma DO
+				NextToken;	(* avoids endless loop *)
 				NEW(identDef);
 				IdentDefP(identDef);
 				SysFlag;
-				IF symbol.token = FoxScanner.Becomes THEN Initializer END;
+				IF token.symbol = FoxScanner.Becomes THEN Initializer END;
 				NEW(identList, var);
 				identList.identDef := identDef;
 				AppendLast(var.identList, identList);
@@ -660,21 +660,21 @@ TYPE
 			IF proc.head.identDef = NIL THEN proc.head := NIL; RETURN END;
 			IF proc.head.identDef.external # NIL THEN RETURN END;
 			Check(FoxScanner.Semicolon);
-			IF 	(symbol.token = FoxScanner.Const) OR (symbol.token = FoxScanner.Var) OR
-				(symbol.token = FoxScanner.Type) OR (symbol.token = FoxScanner.Procedure) OR (symbol.token = FoxScanner.Operator) THEN
+			IF 	(token.symbol = FoxScanner.Const) OR (token.symbol = FoxScanner.Var) OR
+				(token.symbol = FoxScanner.Type) OR (token.symbol = FoxScanner.Procedure) OR (token.symbol = FoxScanner.Operator) THEN
 				NEW(declSeq, proc);
 				DeclSeqP(declSeq);
 				IF proc.declSeq = NIL THEN proc.declSeq := declSeq;
 				ELSE AppendLast(proc.declSeq, declSeq);
 				END;
 			END;
-			IF (symbol.token = FoxScanner.Begin) THEN
-				proc.bodyPos := symbol.position.start;
+			IF (token.symbol = FoxScanner.Begin) THEN
+				proc.bodyPos := token.position.start;
 			ELSE
 				proc.bodyPos := 0;
 			END;
 			BodyP(FALSE, proc.head.modifiers);
-			NextSymbol;	(* skip ident *)
+			NextToken;	(* skip ident *)
 		END ProcDeclP;
 
 		PROCEDURE ProcHeadP(head: ProcHead);
@@ -683,14 +683,14 @@ TYPE
 			ProcedureModifierP(head);
 			(*SysFlag;*)
 
-			CASE symbol.token OF
-			| FoxScanner.Minus: head.inline := TRUE; NextSymbol;
-			| FoxScanner.And: head.constructor := TRUE; NextSymbol;
-			| FoxScanner.Times: (* ignore *) NextSymbol;
-			| FoxScanner.Not: (* ignore *) NextSymbol;
-			| FoxScanner.Arrow: (* ignore *) NextSymbol; forward := TRUE;
+			CASE token.symbol OF
+			| FoxScanner.Minus: head.inline := TRUE; NextToken;
+			| FoxScanner.And: head.constructor := TRUE; NextToken;
+			| FoxScanner.Times: (* ignore *) NextToken;
+			| FoxScanner.Not: (* ignore *) NextToken;
+			| FoxScanner.Arrow: (* ignore *) NextToken; forward := TRUE;
 			| FoxScanner.String: head.operator := TRUE;
-			| FoxScanner.Number: IF symbol.numberType = FoxScanner.Character THEN head.operator := TRUE END;
+			| FoxScanner.Number: IF token.numberType = FoxScanner.Character THEN head.operator := TRUE END;
 			ELSE
 			END;
 
@@ -698,7 +698,7 @@ TYPE
 			IdentDefP(head.identDef);
 			OSAIrq;		(* tk: Compatibility to OSACompiler*)
 
-			IF symbol.token = FoxScanner.LeftParenthesis THEN
+			IF token.symbol = FoxScanner.LeftParenthesis THEN
 				NEW(head.formalPars, head);
 				FormalParsP(head.formalPars);
 			END;
@@ -711,23 +711,23 @@ TYPE
 		PROCEDURE SysFlag;
 		VAR ignore: InfoItem;
 		BEGIN
-			IF symbol.token = FoxScanner.LeftBrace THEN
-				NextSymbol;
-				IF symbol.token # FoxScanner.RightBrace THEN
+			IF token.symbol = FoxScanner.LeftBrace THEN
+				NextToken;
+				IF token.symbol # FoxScanner.RightBrace THEN
 					LOOP
 						Check(FoxScanner.Identifier);
-						IF (symbol.token = FoxScanner.LeftParenthesis) THEN
-							NextSymbol;
+						IF (token.symbol = FoxScanner.LeftParenthesis) THEN
+							NextToken;
 							NEW (ignore);
 							ConstExprP	 (FoxScanner.RightParenthesis, -1, ignore);
 							Check (FoxScanner.RightParenthesis);
-						ELSIF  (symbol.token = FoxScanner.Equal) THEN
-							NextSymbol;
+						ELSIF  (token.symbol = FoxScanner.Equal) THEN
+							NextToken;
 							NEW (ignore);
 							ConstExprP	 (FoxScanner.RightBrace, FoxScanner.Comma, ignore);
 						END;
-						IF symbol.token # FoxScanner.Comma THEN EXIT END;
-						NextSymbol;
+						IF token.symbol # FoxScanner.Comma THEN EXIT END;
+						NextToken;
 					END;
 				END;
 				Check(FoxScanner.RightBrace);
@@ -737,8 +737,8 @@ TYPE
 		(* tk: For OSA Compatibility *)
 		PROCEDURE OSAIrq;
 		BEGIN
-			IF symbol.token = FoxScanner.LeftBracket THEN
-				NextSymbol;
+			IF token.symbol = FoxScanner.LeftBracket THEN
+				NextToken;
 				Check(FoxScanner.Number);
 				Check(FoxScanner.RightBracket);
 			END;
@@ -748,20 +748,20 @@ TYPE
 		VAR
 			fpSection: FPSection;
 		BEGIN
-			NextSymbol;
-			IF (symbol.token = FoxScanner.Var) OR (symbol.token = FoxScanner.Const) OR (symbol.token = FoxScanner.Identifier) THEN
+			NextToken;
+			IF (token.symbol = FoxScanner.Var) OR (token.symbol = FoxScanner.Const) OR (token.symbol = FoxScanner.Identifier) THEN
 				NEW(pars.fpSectionList, pars);
 				FPSectionP(pars.fpSectionList);
-				WHILE symbol.token = FoxScanner.Semicolon DO
-					NextSymbol;	(* avoids endless loop *)
+				WHILE token.symbol = FoxScanner.Semicolon DO
+					NextToken;	(* avoids endless loop *)
 					NEW(fpSection, pars.fpSectionList);
 					FPSectionP(fpSection);
 					AppendLast(pars.fpSectionList, fpSection);
 				END;
 			END;
 			Check(FoxScanner.RightParenthesis);
-			IF symbol.token = FoxScanner.Colon THEN
-				NextSymbol;
+			IF token.symbol = FoxScanner.Colon THEN
+				NextToken;
 				SysFlag;
 				NEW(pars.returnType, pars);
 				TypeP(pars.returnType)
@@ -773,14 +773,14 @@ TYPE
 			identList: IdentList; dummy: InfoItem;
 		BEGIN
 			NEW(dummy);
-			IF symbol.token = FoxScanner.Var THEN
+			IF token.symbol = FoxScanner.Var THEN
 				fpSection.var := TRUE;
-				NextSymbol;
-			ELSIF symbol.token = FoxScanner.Const THEN
+				NextToken;
+			ELSIF token.symbol = FoxScanner.Const THEN
 				fpSection.const := TRUE;
-				NextSymbol;
+				NextToken;
 			END;
-			IF symbol.token = FoxScanner.Identifier THEN
+			IF token.symbol = FoxScanner.Identifier THEN
 				(*StringPool.GetString(scanner.name, name);*)
 				NEW(fpSection.identList, fpSection);
 				NEW(fpSection.identList.identDef);
@@ -788,30 +788,30 @@ TYPE
 				SysFlag;
 				(*
 				fpSection.identList.ident.name := Strings.NewString(name);
-				fpSection.identList.ident.pos := symbol.position.start;
-				NextSymbol;
+				fpSection.identList.ident.pos := token.position.start;
+				NextToken;
 				*)
-				IF symbol.token = FoxScanner.Equal THEN NextSymbol; ConstExprP(FoxScanner.Comma, FoxScanner.Colon, dummy) END; (* added for optional parameters *)
+				IF token.symbol = FoxScanner.Equal THEN NextToken; ConstExprP(FoxScanner.Comma, FoxScanner.Colon, dummy) END; (* added for optional parameters *)
 
-				WHILE symbol.token = FoxScanner.Comma DO
+				WHILE token.symbol = FoxScanner.Comma DO
 					NEW(identList, fpSection.identList);
-					NextSymbol;
+					NextToken;
 					NEW(identList.identDef);
 					IdentDefP(identList.identDef);
 					SysFlag;
 					AppendLast(fpSection.identList, identList);
 					(*
-					IF symbol.token = FoxScanner.Identifier THEN
+					IF token.symbol = FoxScanner.Identifier THEN
 						StringPool.GetString(scanner.name, name);
 						NEW(identDef);
 						NEW(identDef.ident);
 						identDef.ident.name := Strings.NewString(name);
-						identDef.ident.pos := symbol.position.start;
+						identDef.ident.pos := token.position.start;
 						AppendLast(fpSection.identlist, identDef);
-						NextSymbol;
+						NextToken;
 					END;
 					*)
-					IF symbol.token = FoxScanner.Equal THEN NextSymbol; ConstExprP(FoxScanner.Comma, FoxScanner.Colon, dummy) END; (* added for optional parameters *)
+					IF token.symbol = FoxScanner.Equal THEN NextToken; ConstExprP(FoxScanner.Comma, FoxScanner.Colon, dummy) END; (* added for optional parameters *)
 				END;
 				Check(FoxScanner.Colon);
 				NEW(fpSection.type, fpSection);
@@ -821,32 +821,32 @@ TYPE
 
 		PROCEDURE TypeP(type: Type);
 		BEGIN
-			CASE symbol.token OF
-			| FoxScanner.Array: NextSymbol; NEW(type.array, type); ArrayP(type.array);
-			| FoxScanner.Record: NextSymbol; NEW(type.record, type); RecordP(type.record);
-			| FoxScanner.Pointer: NextSymbol; NEW(type.pointer, type); PointerP(type.pointer);
-			| FoxScanner.Object: NextSymbol; NEW(type.object, type); ObjectP(type.object);
-			| FoxScanner.Port: NextSymbol; NEW(type.port, type); PortP(type.port);
-			| FoxScanner.Cell, FoxScanner.CellNet: NextSymbol; NEW(type.cell, type); CellP(type.cell);
-			| FoxScanner.Enum: NextSymbol; NEW(type.enum, type); EnumP(type.enum);
-			| FoxScanner.Procedure, FoxScanner.Operator: NextSymbol; NEW(type.procedure, type); ProcedureP(type.procedure);
+			CASE token.symbol OF
+			| FoxScanner.Array: NextToken; NEW(type.array, type); ArrayP(type.array);
+			| FoxScanner.Record: NextToken; NEW(type.record, type); RecordP(type.record);
+			| FoxScanner.Pointer: NextToken; NEW(type.pointer, type); PointerP(type.pointer);
+			| FoxScanner.Object: NextToken; NEW(type.object, type); ObjectP(type.object);
+			| FoxScanner.Port: NextToken; NEW(type.port, type); PortP(type.port);
+			| FoxScanner.Cell, FoxScanner.CellNet: NextToken; NEW(type.cell, type); CellP(type.cell);
+			| FoxScanner.Enum: NextToken; NEW(type.enum, type); EnumP(type.enum);
+			| FoxScanner.Procedure, FoxScanner.Operator: NextToken; NEW(type.procedure, type); ProcedureP(type.procedure);
 			| FoxScanner.Identifier: NEW(type.qualident, type); QualidentP(type.qualident);
 			| FoxScanner.Address, FoxScanner.Size: NEW(type.qualident, type); NEW(type.qualident.ident);
-				type.qualident.ident.name := Strings.NewString(symbol.identifierString); type.qualident.ident.pos := symbol.position.start; NextSymbol;
+				type.qualident.ident.name := Strings.NewString(token.identifierString); type.qualident.ident.pos := token.position.start; NextToken;
 			ELSE
 				(* Error *)
-				hasError := TRUE; KernelLog.String("err4: "); KernelLog.Int(symbol.position.start, 0); KernelLog.Ln;
-				NextSymbol;	(* ??? *)
+				hasError := TRUE; KernelLog.String("err4: "); KernelLog.Int(token.position.start, 0); KernelLog.Ln;
+				NextToken;	(* ??? *)
 			END;
 		END TypeP;
 
 		PROCEDURE ArrayP(array: Array);
 		BEGIN
 			SysFlag;
-			IF symbol.token = FoxScanner.Of THEN
+			IF token.symbol = FoxScanner.Of THEN
 				array.open := TRUE;
 				NEW(array.base, array);
-				NextSymbol;
+				NextToken;
 				TypeP(array.base);
 			ELSE
 				NEW(array.len);
@@ -854,19 +854,19 @@ TYPE
 				(*
 				SimpleExprP(array.len);
 				*)
-				IF symbol.token = FoxScanner.Of THEN
+				IF token.symbol = FoxScanner.Of THEN
 					NEW(array.base, array);
-					NextSymbol;
+					NextToken;
 					TypeP(array.base);
-				ELSIF symbol.token = FoxScanner.Comma THEN
+				ELSIF token.symbol = FoxScanner.Comma THEN
 					NEW(array.base, array);
 					NEW(array.base.array, array);
-					NextSymbol;
+					NextToken;
 					ArrayP(array.base.array)
 				ELSE
 					(* Error *)
 					hasError := TRUE;
-					KernelLog.String("err1: "); KernelLog.Int(symbol.position.start, 0); KernelLog.Ln;
+					KernelLog.String("err1: "); KernelLog.Int(token.position.start, 0); KernelLog.Ln;
 				END;
 			END;
 		END ArrayP;
@@ -874,14 +874,14 @@ TYPE
 		PROCEDURE RecordP(record: Record);
 		BEGIN
 			SysFlag;
-			IF symbol.token = FoxScanner.LeftParenthesis THEN
-				NextSymbol;
+			IF token.symbol = FoxScanner.LeftParenthesis THEN
+				NextToken;
 				NEW(record.super, record);
 				QualidentP(record.super);
 				Check(FoxScanner.RightParenthesis);
 			END;
-			WHILE symbol.token = FoxScanner.Semicolon DO NextSymbol END;
-			IF symbol.token = FoxScanner.Identifier THEN
+			WHILE token.symbol = FoxScanner.Semicolon DO NextToken END;
+			IF token.symbol = FoxScanner.Identifier THEN
 				NEW(record.fieldList, record);
 				FieldListP(record.fieldList);
 			END;
@@ -892,8 +892,8 @@ TYPE
 		VAR fieldDecl: FieldDecl;
 		BEGIN
 			FieldDeclP(fieldList);
-			WHILE symbol.token = FoxScanner.Semicolon DO
-				NextSymbol;
+			WHILE token.symbol = FoxScanner.Semicolon DO
+				NextToken;
 				NEW(fieldDecl, fieldList);
 				FieldDeclP(fieldDecl);
 				AppendLast(fieldList, fieldDecl);
@@ -905,13 +905,13 @@ TYPE
 			identDef: IdentDef;
 			identList: IdentList;
 		BEGIN
-			IF symbol.token = FoxScanner.Identifier THEN
+			IF token.symbol = FoxScanner.Identifier THEN
 				NEW(fieldDecl.identList, fieldDecl);
 				NEW(fieldDecl.identList.identDef);
 				IdentDefP(fieldDecl.identList.identDef);
 				SysFlag;
-				WHILE symbol.token = FoxScanner.Comma DO
-					NextSymbol;
+				WHILE token.symbol = FoxScanner.Comma DO
+					NextToken;
 					NEW(identDef);
 					IdentDefP(identDef);
 					SysFlag;
@@ -940,8 +940,8 @@ TYPE
 			NEW(enum.identList.identDef);
 			IdentDefP(enum.identList.identDef);
 			SysFlag;
-			WHILE symbol.token = FoxScanner.Comma DO
-				NextSymbol;	(* avoids endless loop *)
+			WHILE token.symbol = FoxScanner.Comma DO
+				NextToken;	(* avoids endless loop *)
 				NEW(identDef);
 				IdentDefP(identDef);
 				NEW(identList, enum);
@@ -953,8 +953,8 @@ TYPE
 
 		PROCEDURE PortP(port: Port);
 		BEGIN
-			IF (symbol.token = FoxScanner.Out) OR (symbol.token = FoxScanner.In) THEN
-				NextSymbol
+			IF (token.symbol = FoxScanner.Out) OR (token.symbol = FoxScanner.In) THEN
+				NextToken
 			END;
 		END PortP;
 
@@ -964,43 +964,43 @@ TYPE
 			pos: LONGINT;
 		(*?	qualident: Qualident; *)
 		BEGIN
-			IF (symbol.token = FoxScanner.Semicolon) OR (symbol.token = FoxScanner.RightParenthesis) THEN RETURN END;
+			IF (token.symbol = FoxScanner.Semicolon) OR (token.symbol = FoxScanner.RightParenthesis) THEN RETURN END;
 			SysFlag;
-			IF symbol.token = FoxScanner.LeftParenthesis THEN
+			IF token.symbol = FoxScanner.LeftParenthesis THEN
 				NEW(object.super, object);
-				NextSymbol;
+				NextToken;
 				QualidentP(object.super);
 				Check(FoxScanner.RightParenthesis);
 			END;
-		(*?	IF symbol.token = FoxScanner.Implements THEN
+		(*?	IF token.symbol = FoxScanner.Implements THEN
 				NEW(object.implements, object);
-				NextSymbol;
+				NextToken;
 				QualidentP(object.implements);
-				WHILE symbol.token = FoxScanner.Comma DO
+				WHILE token.symbol = FoxScanner.Comma DO
 					NEW(qualident, object.implements);
-					NextSymbol;
+					NextToken;
 					QualidentP(qualident);
 					AppendLast(object.implements, qualident);
 				END;
 			END; *)
 			pos := -1;
-			WHILE (symbol.token # FoxScanner.Begin) & (symbol.token # FoxScanner.End) & (symbol.token # FoxScanner.EndOfText) DO
+			WHILE (token.symbol # FoxScanner.Begin) & (token.symbol # FoxScanner.End) & (token.symbol # FoxScanner.EndOfText) DO
 					(* avoid endless-loop *)
-				IF pos = symbol.position.start THEN NextSymbol END;
-				pos := symbol.position.start;
+				IF pos = token.position.start THEN NextToken END;
+				pos := token.position.start;
 				NEW(declSeq, object);
 				DeclSeqP(declSeq);
 				IF object.declSeq = NIL THEN object.declSeq := declSeq;
 				ELSE AppendLast(object.declSeq, declSeq);
 				END;
 			END;
-			IF (symbol.token = FoxScanner.Begin) THEN
-				object.bodyPos := symbol.position.start;
+			IF (token.symbol = FoxScanner.Begin) THEN
+				object.bodyPos := token.position.start;
 			ELSE
 				object.bodyPos := 0;
 			END;
 			BodyP(TRUE, object.modifiers);
-			IF symbol.token = FoxScanner.Identifier THEN NextSymbol END;
+			IF token.symbol = FoxScanner.Identifier THEN NextToken END;
 		END ObjectP;
 
 		PROCEDURE CellP(cell: Cell);
@@ -1009,50 +1009,50 @@ TYPE
 		(*?	qualident: Qualident; *)
 		BEGIN
 			SysFlag;
-			IF symbol.token = FoxScanner.LeftParenthesis THEN
+			IF token.symbol = FoxScanner.LeftParenthesis THEN
 				NEW(cell.formalPars, cell);
 				FormalParsP(cell.formalPars);
 			END;
 			pos := -1;
-			WHILE (symbol.token # FoxScanner.Begin) & (symbol.token # FoxScanner.End) & (symbol.token # FoxScanner.EndOfText) DO
+			WHILE (token.symbol # FoxScanner.Begin) & (token.symbol # FoxScanner.End) & (token.symbol # FoxScanner.EndOfText) DO
 					(* avoid endless-loop *)
-				IF pos = symbol.position.start THEN NextSymbol END;
-				pos := symbol.position.start;
+				IF pos = token.position.start THEN NextToken END;
+				pos := token.position.start;
 				NEW(declSeq, cell);
 				DeclSeqP(declSeq);
 				IF cell.declSeq = NIL THEN cell.declSeq := declSeq;
 				ELSE AppendLast(cell.declSeq, declSeq);
 				END;
 			END;
-			IF (symbol.token = FoxScanner.Begin) THEN
-				cell.bodyPos := symbol.position.start;
+			IF (token.symbol = FoxScanner.Begin) THEN
+				cell.bodyPos := token.position.start;
 			ELSE
 				cell.bodyPos := 0;
 			END;
 			BodyP(TRUE, cell.modifiers);
-			IF symbol.token = FoxScanner.Identifier THEN NextSymbol END;
+			IF token.symbol = FoxScanner.Identifier THEN NextToken END;
 		END CellP;
 
 		PROCEDURE ProcedureP(proc: Procedure);
 		BEGIN
 			SysFlag;
-			IF symbol.token = FoxScanner.LeftBrace THEN
-				NextSymbol;
-				IF symbol.token # FoxScanner.Identifier THEN
+			IF token.symbol = FoxScanner.LeftBrace THEN
+				NextToken;
+				IF token.symbol # FoxScanner.Identifier THEN
 					(* Error *)
-				ELSIF symbol.identifierString = "DELEGATE" THEN
+				ELSIF token.identifierString = "DELEGATE" THEN
 					proc.delegate := TRUE;
 				END;
-				NextSymbol;
+				NextToken;
 				Check(FoxScanner.RightBrace);
 			END;
-			IF symbol.token = FoxScanner.LeftParenthesis THEN
+			IF token.symbol = FoxScanner.LeftParenthesis THEN
 				NEW(proc.formalPars, proc);
 				FormalParsP(proc.formalPars);
 			END;
 		END ProcedureP;
 
-		PROCEDURE ConstExprP(delimiter1, delimiter2: FoxScanner.Token; expr: InfoItem);
+		PROCEDURE ConstExprP(delimiter1, delimiter2: FoxScanner.Symbol; expr: InfoItem);
 		VAR
 			exprStr, name: ARRAY 1024 OF CHAR;
 			longExprStr : Strings.String; (* for exprStr content lengths > LEN(exprStr) *)
@@ -1078,23 +1078,23 @@ TYPE
 			END Add;
 
 		BEGIN
-			expr.pos := symbol.position.start;
-			IF (symbol.token = delimiter1) OR (symbol.token = delimiter2) THEN RETURN END;
+			expr.pos := token.position.start;
+			IF (token.symbol = delimiter1) OR (token.symbol = delimiter2) THEN RETURN END;
 			REPEAT
-				CASE symbol.token OF
+				CASE token.symbol OF
 				| FoxScanner.LeftParenthesis: INC(paren); Add("(");
 				| FoxScanner.RightParenthesis: DEC(paren); Add(")");
 				| FoxScanner.LeftBrace: INC(brace); Add("{");
 				| FoxScanner.RightBrace: DEC(brace); Add("}");
 				| FoxScanner.LeftBracket: INC(brak); Add("[");
 				| FoxScanner.RightBracket: DEC(brak); Add("]");
-				| FoxScanner.Number: Add(symbol.identifierString);
+				| FoxScanner.Number: Add(token.identifierString);
 				| FoxScanner.Nil: Add("NIL");
 				| FoxScanner.True: Add("TRUE");
 				| FoxScanner.False: Add("FALSE");
 				| FoxScanner.Not: Add("~");
 				| FoxScanner.Period: Add(".");
-				| FoxScanner.Identifier: Add(symbol.identifierString);
+				| FoxScanner.Identifier: Add(token.identifierString);
 				| FoxScanner.Comma: Add(", ");
 				| FoxScanner.Plus: Add(" + ");
 				| FoxScanner.Minus: Add(" - ");
@@ -1113,15 +1113,15 @@ TYPE
 				| FoxScanner.Slash: Add(" / ");
 				| FoxScanner.And: Add(" & ");
 				| FoxScanner.Or: Add(" OR ");
-				| FoxScanner.String: name[0] := '"'; name[1] := 0X; Add(name); Add(symbol.string^); Add(name);
+				| FoxScanner.String: name[0] := '"'; name[1] := 0X; Add(name); Add(token.string^); Add(name);
 				| FoxScanner.Arrow: Add("^");
 				ELSE
 					(* error *)
 					hasError := TRUE;
 				END;
-				NextSymbol;
+				NextToken;
 				(* urgh, what an ugly condition ... *)
-			UNTIL (((symbol.token = delimiter1) OR (symbol.token = delimiter2)) & (paren = 0) & (brace = 0) & (brak = 0)) OR (symbol.token = FoxScanner.EndOfText);
+			UNTIL (((token.symbol = delimiter1) OR (token.symbol = delimiter2)) & (paren = 0) & (brace = 0) & (brak = 0)) OR (token.symbol = FoxScanner.EndOfText);
 			IF (longExprStr = NIL) THEN
 				expr.name := Strings.NewString(exprStr);
 			ELSE
@@ -1133,42 +1133,42 @@ TYPE
 		VAR ignore : InfoItem;
 		BEGIN
 			modifiers := {};
-			IF symbol.token = FoxScanner.LeftBrace THEN
-				NextSymbol;
+			IF token.symbol = FoxScanner.LeftBrace THEN
+				NextToken;
 				LOOP
-					IF symbol.token = FoxScanner.Identifier THEN
-						IF symbol.identifierString = ExclusiveStr  THEN
+					IF token.symbol = FoxScanner.Identifier THEN
+						IF token.identifierString = ExclusiveStr  THEN
 							modifiers := modifiers + {Exclusive};
-							NextSymbol;
-						ELSIF allowBody & (symbol.identifierString = ActiveStr)  THEN
+							NextToken;
+						ELSIF allowBody & (token.identifierString = ActiveStr)  THEN
 							modifiers := modifiers + {Active};
-							NextSymbol
-						ELSIF allowBody & (symbol.identifierString = RealtimeStr) THEN
-							NextSymbol;
-						ELSIF allowBody & (symbol.identifierString = SafeStr)  THEN
+							NextToken
+						ELSIF allowBody & (token.identifierString = RealtimeStr) THEN
+							NextToken;
+						ELSIF allowBody & (token.identifierString = SafeStr)  THEN
 							modifiers := modifiers + {Safe};
-							NextSymbol
-						ELSIF allowBody & (symbol.identifierString = PriorityStr)  THEN
+							NextToken
+						ELSIF allowBody & (token.identifierString = PriorityStr)  THEN
 							modifiers := modifiers + {Priority};
-							NextSymbol;
-							IF symbol.token = FoxScanner.LeftParenthesis THEN
-								NextSymbol;
+							NextToken;
+							IF token.symbol = FoxScanner.LeftParenthesis THEN
+								NextToken;
 								NEW(ignore);
 								ConstExprP(FoxScanner.RightParenthesis, -1, ignore);
 								Check(FoxScanner.RightParenthesis);
 							END;
-						ELSIF symbol.identifierString = UncheckedStr  THEN
+						ELSIF token.identifierString = UncheckedStr  THEN
 							modifiers := modifiers + {Unchecked};
-							NextSymbol;
-						ELSIF symbol.identifierString = UncooperativeStr  THEN
+							NextToken;
+						ELSIF token.identifierString = UncooperativeStr  THEN
 							modifiers := modifiers + {Uncooperative};
-							NextSymbol;
+							NextToken;
 						ELSE
-							Error(symbol.position.start); NextSymbol (* skip the ident, probably a typo *)
+							Error(token.position.start); NextToken (* skip the ident, probably a typo *)
 						END;
 					END;
-					IF symbol.token # FoxScanner.Comma THEN EXIT END;
-					NextSymbol
+					IF token.symbol # FoxScanner.Comma THEN EXIT END;
+					NextToken
 				END;
 				Check(FoxScanner.RightBrace);
 			END;
@@ -1178,28 +1178,28 @@ TYPE
 		VAR
 			value: LONGINT; ignore: InfoItem;
 		BEGIN
-			IF symbol.token = FoxScanner.LeftBrace THEN
-				NextSymbol;
-				IF symbol.token # FoxScanner.RightBrace THEN
+			IF token.symbol = FoxScanner.LeftBrace THEN
+				NextToken;
+				IF token.symbol # FoxScanner.RightBrace THEN
 					LOOP
-						IF symbol.token = FoxScanner.Identifier THEN
-							IF symbol.identifierString = InterruptStr THEN NextSymbol; procHead.modifiers := procHead.modifiers + {Interrupt}
-							ELSE NextSymbol;
+						IF token.symbol = FoxScanner.Identifier THEN
+							IF token.identifierString = InterruptStr THEN NextToken; procHead.modifiers := procHead.modifiers + {Interrupt}
+							ELSE NextToken;
 							END;
-						ELSE Error(symbol.position.start); NextSymbol; (* skip the ident, probably a typo *)
+						ELSE Error(token.position.start); NextToken; (* skip the ident, probably a typo *)
 						END;
-						IF (symbol.token = FoxScanner.LeftParenthesis) THEN
-							NextSymbol;
+						IF (token.symbol = FoxScanner.LeftParenthesis) THEN
+							NextToken;
 							NEW (ignore);
 							ConstExprP	 (FoxScanner.RightParenthesis, -1, ignore);
 							Check (FoxScanner.RightParenthesis);
-						ELSIF (symbol.token = FoxScanner.Equal) THEN
-							NextSymbol;
+						ELSIF (token.symbol = FoxScanner.Equal) THEN
+							NextToken;
 							NEW (ignore);
 							ConstExprP	 (FoxScanner.Comma, FoxScanner.RightBrace, ignore);
 						END;
-						IF symbol.token # FoxScanner.Comma THEN EXIT END;
-						NextSymbol;
+						IF token.symbol # FoxScanner.Comma THEN EXIT END;
+						NextToken;
 					END
 				END;
 				Check(FoxScanner.RightBrace)
@@ -1208,25 +1208,25 @@ TYPE
 
 		PROCEDURE ModifierValueP(VAR value: LONGINT);
 		BEGIN
-			IF symbol.token = FoxScanner.Equal THEN
-				NextSymbol; Check(FoxScanner.Number); value := symbol.integer
-			ELSIF symbol.token = FoxScanner.LeftParenthesis THEN
-				NextSymbol; Check(FoxScanner.Number); value := symbol.integer; Check(FoxScanner.RightParenthesis)
+			IF token.symbol = FoxScanner.Equal THEN
+				NextToken; Check(FoxScanner.Number); value := token.integer
+			ELSIF token.symbol = FoxScanner.LeftParenthesis THEN
+				NextToken; Check(FoxScanner.Number); value := token.integer; Check(FoxScanner.RightParenthesis)
 			ELSE
-				Error(symbol.position.start); NextSymbol
+				Error(token.position.start); NextToken
 			END
 		END ModifierValueP;
 
 		PROCEDURE BodyP(allowBody : BOOLEAN; VAR modifiers : SET);
-		VAR end, lastToken: LONGINT; m : SET; first : BOOLEAN;
+		VAR end: LONGINT; lastSymbol: FoxScanner.Symbol; m : SET; first : BOOLEAN;
 		BEGIN
-			IF symbol.token = FoxScanner.Begin THEN
+			IF token.symbol = FoxScanner.Begin THEN
 				end := 1;
 				first := TRUE;
 				REPEAT
-					lastToken := symbol.token;
-					NextSymbol;
-					IF (lastToken = FoxScanner.Begin) & (symbol.token = FoxScanner.LeftBrace) THEN
+					lastSymbol := token.symbol;
+					NextToken;
+					IF (lastSymbol = FoxScanner.Begin) & (token.symbol = FoxScanner.LeftBrace) THEN
 						BlockModifierP(allowBody, m);
 						IF first THEN
 							allowBody := FALSE;
@@ -1238,20 +1238,20 @@ TYPE
 						END;
 					END;
 					first := FALSE;
-					CASE symbol.token OF
+					CASE token.symbol OF
 					| FoxScanner.Begin: INC(end);
 					| FoxScanner.If, FoxScanner.Case, FoxScanner.While, FoxScanner.For, FoxScanner.Loop, FoxScanner.With: INC(end);
 					| FoxScanner.Code:
-						REPEAT NextSymbol UNTIL (symbol.token = FoxScanner.End) OR (symbol.token = FoxScanner.EndOfText);
-						NextSymbol;
+						REPEAT NextToken UNTIL (token.symbol = FoxScanner.End) OR (token.symbol = FoxScanner.EndOfText);
+						NextToken;
 					| FoxScanner.End: DEC(end);
 					ELSE
 					END;
-				UNTIL (end = 0) OR (symbol.token = FoxScanner.EndOfText);
-			ELSIF symbol.token = FoxScanner.Code THEN
-				REPEAT NextSymbol UNTIL (symbol.token = FoxScanner.End) OR (symbol.token = FoxScanner.EndOfText);
+				UNTIL (end = 0) OR (token.symbol = FoxScanner.EndOfText);
+			ELSIF token.symbol = FoxScanner.Code THEN
+				REPEAT NextToken UNTIL (token.symbol = FoxScanner.End) OR (token.symbol = FoxScanner.EndOfText);
 			END;
-			NextSymbol;
+			NextToken;
 		END BodyP;
 
 		PROCEDURE QualidentP(qualident: Qualident);
@@ -1259,16 +1259,16 @@ TYPE
 			name : ARRAY 64 OF CHAR;
 			pos: LONGINT;
 		BEGIN
-			IF symbol.token = FoxScanner.Identifier THEN
-				COPY(symbol.identifierString, name);
-				pos := symbol.position.start;
-				NextSymbol;
-				IF symbol.token = FoxScanner.Period THEN
-					NextSymbol;
-					IF symbol.token = FoxScanner.Identifier THEN
+			IF token.symbol = FoxScanner.Identifier THEN
+				COPY(token.identifierString, name);
+				pos := token.position.start;
+				NextToken;
+				IF token.symbol = FoxScanner.Period THEN
+					NextToken;
+					IF token.symbol = FoxScanner.Identifier THEN
 						Strings.Append(name, ".");
-						Strings.Concat(name, symbol.identifierString, name);
-						NextSymbol;
+						Strings.Concat(name, token.identifierString, name);
+						NextToken;
 					END;
 				END;
 				NEW(qualident.ident);
@@ -1279,53 +1279,53 @@ TYPE
 
 		PROCEDURE IdentDefP(identDef: IdentDef);
 		BEGIN
-			IF (symbol.token = FoxScanner.Identifier) OR (symbol.token = FoxScanner.Number) & (symbol.numberType = FoxScanner.Character)  THEN
+			IF (token.symbol = FoxScanner.Identifier) OR (token.symbol = FoxScanner.Number) & (token.numberType = FoxScanner.Character)  THEN
 				NEW(identDef.ident);
-				identDef.ident.name := Strings.NewString(symbol.identifierString);
-				identDef.ident.pos := symbol.position.start;
-			ELSIF (symbol.token = FoxScanner.String) THEN
+				identDef.ident.name := Strings.NewString(token.identifierString);
+				identDef.ident.pos := token.position.start;
+			ELSIF (token.symbol = FoxScanner.String) THEN
 				NEW(identDef.ident);
-				identDef.ident.name := Strings.NewString(symbol.string^);
-				identDef.ident.pos := symbol.position.start;
+				identDef.ident.name := Strings.NewString(token.string^);
+				identDef.ident.pos := token.position.start;
 			END;
-			NextSymbol;
-			IF symbol.token = FoxScanner.Times THEN
+			NextToken;
+			IF token.symbol = FoxScanner.Times THEN
 				identDef.vis := Public;
-				NextSymbol;
-			ELSIF symbol.token = FoxScanner.Minus THEN
+				NextToken;
+			ELSIF token.symbol = FoxScanner.Minus THEN
 				identDef.vis := PublicRO;
-				NextSymbol;
+				NextToken;
 			ELSE
 				identDef.vis := Private;
 			END;
 			identDef.external := NIL;
-			IF symbol.token = FoxScanner.Becomes THEN
-				NextSymbol;
+			IF token.symbol = FoxScanner.Becomes THEN
+				NextToken;
 				NEW(identDef.initializer);
 				ConstExprP(FoxScanner.Colon, FoxScanner.Comma, identDef.initializer);
-			ELSIF symbol.token = FoxScanner.Extern THEN
-				NextSymbol;
-				identDef.external := Strings.NewString(symbol.string^);
+			ELSIF token.symbol = FoxScanner.Extern THEN
+				NextToken;
+				identDef.external := Strings.NewString(token.string^);
 				Check(FoxScanner.String);
 				TRACE (identDef.external^);
 			END;
 		END IdentDefP;
 
-		PROCEDURE Check(token: FoxScanner.Token);
+		PROCEDURE Check(symbol: FoxScanner.Symbol);
 		BEGIN
-			IF symbol.token = token THEN
+			IF token.symbol = symbol THEN
 				(* correct *)
 			ELSE
 				(* error *)
 
 				KernelLog.String("******* Check error **********  ");
-				KernelLog.Int(symbol.position.start, 0);
+				KernelLog.Int(token.position.start, 0);
 				KernelLog.Ln;
 
 				hasError := TRUE;
 				(*HALT(33);*)
 			END;
-			NextSymbol;
+			NextToken;
 		END Check;
 
 		PROCEDURE Error(pos : LONGINT);