rebuilt release

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

WinAos/obg/FoxAMD64Assembler.SymW

@@ -243,7 +243,7 @@ TYPE
 
 	Assembly* = OBJECT 
 	VAR 
-		errPos: LONGINT; 
+		errPos: Basic.Position; 
 		error-: BOOLEAN; 
 		useLineNumbers*: BOOLEAN; 
 		emitter: Emitter; 
@@ -258,7 +258,7 @@ TYPE
 		PROCEDURE ^  & InitAssembly*(diagnostics: Diagnostics.Diagnostics; emit: Emitter); 
 		PROCEDURE ^ Error(CONST message: ARRAY OF CHAR); 
 		PROCEDURE ^ ErrorSS(CONST msg1, msg2: ARRAY OF CHAR); 
-		PROCEDURE ^ Assemble*(reader: Streams.Reader; orgPos: LONGINT; scope: SyntaxTree.Scope; in: IntermediateCode.Section; out: IntermediateCode.Section; module: Sections.Module; exported, inlined: BOOLEAN; map: RegisterMap); 
+		PROCEDURE ^ Assemble*(reader: Streams.Reader; orgPos: Basic.Position; scope: SyntaxTree.Scope; in: IntermediateCode.Section; out: IntermediateCode.Section; module: Sections.Module; exported, inlined: BOOLEAN; map: RegisterMap); 
 	END Assembly; 
 VAR 
 	kernelWriter: Streams.Writer; 

WinAos/obg/FoxARMAssembler.SymW

@@ -1,5 +1,5 @@
 MODULE FoxARMAssembler;
-	IMPORT InstructionSet := FoxARMInstructionSet, FoxAssembler, Scanner := FoxScanner, Diagnostics, Strings;
+	IMPORT InstructionSet := FoxARMInstructionSet, FoxAssembler, Scanner := FoxScanner, Diagnostics, Strings, Basic := FoxBasic;
 CONST 
 	Trace = FoxAssembler.Trace; 
 TYPE 

WinAos/obg/FoxAssembler.SymW

@@ -12,6 +12,8 @@ CONST
 TYPE 
 	OperandString = ARRAY 256 OF CHAR; 
 
+	Position = Basic.Position; 
+
 	FixupElement = POINTER TO RECORD 
 		fixup: BinaryCode.Fixup; 
 		next: FixupElement; 
@@ -68,7 +70,7 @@ TYPE
 	VAR 
 		diagnostics: Diagnostics.Diagnostics; 
 		error-: BOOLEAN; 
-		errorPosition-: LONGINT; 
+		errorPosition-: Position; 
 		symbol-: Scanner.Symbol; 
 		scanner: Scanner.AssemblerScanner; 
 		orgOffset: LONGINT; 
@@ -82,28 +84,28 @@ TYPE
 
 		PROCEDURE ^  & Init*(diagnostics: Diagnostics.Diagnostics); 
 		PROCEDURE ^ SetContext(CONST context: Scanner.Context); 
-		PROCEDURE ^ Error*(pos: LONGINT; CONST msg: ARRAY OF CHAR); 
-		PROCEDURE ^ ErrorSS*(pos: LONGINT; CONST s1, s2: ARRAY OF CHAR); 
+		PROCEDURE ^ Error*(pos: SyntaxTree.Position; CONST msg: ARRAY OF CHAR); 
+		PROCEDURE ^ ErrorSS*(pos: SyntaxTree.Position; CONST s1, s2: ARRAY OF CHAR); 
 		PROCEDURE ^ NextSymbol*; 
 		PROCEDURE ^ ThisToken*(x: LONGINT): BOOLEAN; 
-		PROCEDURE ^ GetIdentifier*(VAR pos: LONGINT; VAR identifier: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ GetIdentifier*(VAR pos: Position; VAR identifier: ARRAY OF CHAR): BOOLEAN; 
 		PROCEDURE ^ ThisIdentifier*(CONST this: ARRAY OF CHAR): BOOLEAN; 
-		PROCEDURE ^ ExpectIdentifier*(VAR pos: LONGINT; VAR identifier: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ ExpectIdentifier*(VAR pos: Position; VAR identifier: ARRAY OF CHAR): BOOLEAN; 
 		PROCEDURE ^ ExpectToken*(x: LONGINT): BOOLEAN; 
 		PROCEDURE ^ ExpectConstantInteger*(VAR x: Result; critical: BOOLEAN): BOOLEAN; 
 		PROCEDURE ^ Section; 
-		PROCEDURE ^ DefineLabel(pos: LONGINT; CONST name: ARRAY OF CHAR); 
-		PROCEDURE ^ SetLabel(pos: LONGINT; CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ DefineLabel(pos: Position; CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ SetLabel(pos: Position; CONST name: ARRAY OF CHAR); 
 		PROCEDURE ^ CopyResult(CONST from: Result; VAR to: Result); 
-		PROCEDURE ^ DefineResult(pos: LONGINT; CONST name: ARRAY OF CHAR; CONST r: Result); 
+		PROCEDURE ^ DefineResult(pos: Position; CONST name: ARRAY OF CHAR; CONST r: Result); 
 		PROCEDURE ^ SetResult(CONST name: ARRAY OF CHAR; CONST r: Result); 
 		PROCEDURE ^ SymbolInScope(CONST ident: ARRAY OF CHAR): SyntaxTree.Symbol; 
-		PROCEDURE ^ ConstantSymbol(pos: LONGINT; constant: SyntaxTree.Constant; VAR result: Result): BOOLEAN; 
+		PROCEDURE ^ ConstantSymbol(pos: Position; constant: SyntaxTree.Constant; VAR result: Result): BOOLEAN; 
 		PROCEDURE ^ GetFingerprint(symbol: SyntaxTree.Symbol): LONGINT; 
-		PROCEDURE ^ NonConstantSymbol(pos: LONGINT; symbol: SyntaxTree.Symbol; VAR result: Result): BOOLEAN; 
-		PROCEDURE ^ GetNonConstant*(pos: LONGINT; CONST ident: ARRAY OF CHAR; VAR result: Result): BOOLEAN; 
-		PROCEDURE ^ LocalOffset(pos: LONGINT; symbol: SyntaxTree.Symbol; VAR result: Result): BOOLEAN; 
-		PROCEDURE ^ GetConstant*(pos: LONGINT; CONST ident: ARRAY OF CHAR; VAR result: Result): BOOLEAN; 
+		PROCEDURE ^ NonConstantSymbol(pos: Position; symbol: SyntaxTree.Symbol; VAR result: Result): BOOLEAN; 
+		PROCEDURE ^ GetNonConstant*(pos: Position; CONST ident: ARRAY OF CHAR; VAR result: Result): BOOLEAN; 
+		PROCEDURE ^ LocalOffset(pos: Position; symbol: SyntaxTree.Symbol; VAR result: Result): BOOLEAN; 
+		PROCEDURE ^ GetConstant*(pos: Position; CONST ident: ARRAY OF CHAR; VAR result: Result): BOOLEAN; 
 		PROCEDURE ^ Factor(VAR x: Result; critical: BOOLEAN): BOOLEAN; 
 		PROCEDURE ^ Term(VAR x: Result; critical: BOOLEAN): BOOLEAN; 
 		PROCEDURE ^ Expression*(VAR x: Result; critical: BOOLEAN): BOOLEAN; 

WinAos/obg/FoxBackend.SymW

@@ -1,5 +1,5 @@
 MODULE FoxBackend;
-	IMPORT Streams, Diagnostics, Global := FoxGlobal, Formats := FoxFormats, SyntaxTree := FoxSyntaxTree, SemanticChecker := FoxSemanticChecker, Options, Strings;
+	IMPORT Streams, Diagnostics, Basic := FoxBasic, Global := FoxGlobal, Formats := FoxFormats, SyntaxTree := FoxSyntaxTree, SemanticChecker := FoxSemanticChecker, Options, Strings;
 CONST 
 TYPE 
 	SectionName = ARRAY 256 OF CHAR; 
@@ -33,7 +33,7 @@ TYPE
 		PROCEDURE ^ SetName*(CONST name: ARRAY OF CHAR); 
 		PROCEDURE ^ GetSystem*(): Global.System; 
 		PROCEDURE ^ GetParameterRegisters*(callingConvention: SyntaxTree.CallingConvention): Registers; 
-		PROCEDURE ^ Error*(CONST source: ARRAY OF CHAR; errorNumber, errorPosition: LONGINT; CONST err: ARRAY OF CHAR); 
+		PROCEDURE ^ Error*(CONST source: ARRAY OF CHAR; position: Basic.Position; errorNumber: LONGINT; CONST err: ARRAY OF CHAR); 
 		PROCEDURE ^ ProcessSyntaxTreeModule*(syntaxTreeModule: SyntaxTree.Module): Formats.GeneratedModule; 
 		PROCEDURE ^ ProcessIntermediateCodeModule*(intermediateCodeModule: Formats.GeneratedModule): Formats.GeneratedModule; 
 		PROCEDURE ^ Emit*(backend: Backend): BOOLEAN; 

WinAos/obg/FoxBasic.SymW

@@ -30,6 +30,7 @@ CONST
 	MaxLInt* = 2147483647; 
 	MaxSet* = 31; 
 	invalidString* =  -1; 
+	InvalidCode* = Diagnostics.Invalid; 
 TYPE 
 	String* = StringPool.Index; 
 
@@ -49,6 +50,12 @@ TYPE
 
 	ComparisonFunction = PROCEDURE {DELEGATE}(object1, object2: ANY):BOOLEAN; 
 
+	Position* = RECORD 
+		start*, end*, line*, linepos*: LONGINT; 
+	END; 
+
+	ErrorCode* = LONGINT; 
+
 	List* = OBJECT 
 	VAR 
 		list: ObjectArray; 
@@ -450,11 +457,18 @@ VAR
 	getWriter: WriterFactory; 
 	getDiagnostics: DiagnosticsFactory; 
 	CRC32Table: ARRAY 256 OF SET; 
+	invalidPosition-: Position; 
 
 	PROCEDURE ^ MakeString*(CONST s: ARRAY OF CHAR): String; 
 	PROCEDURE ^ GetString*(s: String; VAR str: ARRAY OF CHAR); 
 	PROCEDURE ^ StringEqual*(s, t: String): BOOLEAN; 
 	PROCEDURE ^ GetErrorMessage*(err: LONGINT; CONST msg: ARRAY OF CHAR; VAR res: ARRAY OF CHAR); 
+	PROCEDURE ^ AppendPosition*(VAR msg: ARRAY OF CHAR; pos: Position); 
+	PROCEDURE ^ MakeMessage(pos: Position; code: ErrorCode; CONST msg: ARRAY OF CHAR; VAR message: ARRAY OF CHAR); 
+	PROCEDURE ^ ErrorC*(diagnostics: Diagnostics.Diagnostics; CONST source: ARRAY OF CHAR; pos: Position; code: ErrorCode; CONST msg: ARRAY OF CHAR); 
+	PROCEDURE ^ Error*(diagnostics: Diagnostics.Diagnostics; CONST source: ARRAY OF CHAR; pos: Position; CONST msg: ARRAY OF CHAR); 
+	PROCEDURE ^ Warning*(diagnostics: Diagnostics.Diagnostics; CONST source: ARRAY OF CHAR; pos: Position; CONST msg: ARRAY OF CHAR); 
+	PROCEDURE ^ Information*(diagnostics: Diagnostics.Diagnostics; CONST source: ARRAY OF CHAR; pos: Position; CONST msg: ARRAY OF CHAR); 
 	PROCEDURE ^ SetErrorMessage*(n: LONGINT; CONST msg: ARRAY OF CHAR); 
 	PROCEDURE ^ SetErrorExpected*(n: LONGINT; CONST msg: ARRAY OF CHAR); 
 	PROCEDURE ^ AppendNumber*(VAR s: ARRAY OF CHAR; num: LONGINT); 

WinAos/obg/FoxBinaryCode.SymW

@@ -64,7 +64,7 @@ TYPE
 
 	LabelList* = POINTER TO RECORD 
 		offset-: LONGINT; 
-		position-: LONGINT; 
+		position-: Basic.Position; 
 		prev-: LabelList; 
 	END; 
 
@@ -82,7 +82,7 @@ TYPE
 		PROCEDURE ^ GetPC(): LONGINT; 
 		PROCEDURE ^  & InitBinarySection*(type: SHORTINT; priority: LONGINT; unit: LONGINT; CONST name: Basic.SegmentedName; dump: BOOLEAN; bigEndian: BOOLEAN); 
 		PROCEDURE ^ Reset*; 
-		PROCEDURE ^ AddLabel*(position: Unit); 
+		PROCEDURE ^ AddLabel*(position: Basic.Position); 
 		PROCEDURE ^ SetPC*(pc: Unit); 
 		PROCEDURE ^ Align*(alignment: Unit); 
 		PROCEDURE ^ SetFinally*(atPC: Unit); 

WinAos/obg/FoxCSharpParser.SymW

@@ -5,8 +5,9 @@ CONST
 	Public = 0; 
 	Internal = 1; 
 	LynxCase = FoxScanner.Lowercase; 
-	invalidPosition =  -1; 
 TYPE 
+	Position* = Scanner.Position; 
+
 	LocalIdentEntry = OBJECT 
 	VAR 
 		next: LocalIdentEntry; 
@@ -78,22 +79,22 @@ TYPE
 		PROCEDURE ^ S(CONST s: ARRAY OF CHAR); 
 		PROCEDURE ^ E(CONST s: ARRAY OF CHAR); 
 		PROCEDURE ^ EE(CONST s, t: ARRAY OF CHAR); 
-		PROCEDURE ^ Error(position: LONGINT; code: LONGINT; CONST message: ARRAY OF CHAR); 
+		PROCEDURE ^ Error(position: Position; code: LONGINT; CONST message: ARRAY OF CHAR); 
 		PROCEDURE ^ NextSymbol; 
 		PROCEDURE ^ Peek(token: Scanner.Token): BOOLEAN; 
 		PROCEDURE ^ Mandatory(token: Scanner.Token): BOOLEAN; 
 		PROCEDURE ^ Check(token: Scanner.Token); 
 		PROCEDURE ^ MandatoryIdentifier(VAR name: SyntaxTree.Identifier): BOOLEAN; 
-		PROCEDURE ^ Identifier(VAR position: LONGINT): SyntaxTree.Identifier; 
+		PROCEDURE ^ Identifier(VAR position: Position): SyntaxTree.Identifier; 
 		PROCEDURE ^ Optional(token: Scanner.Token): BOOLEAN; 
 		PROCEDURE ^ Ignore(token: Scanner.Token); 
 		PROCEDURE ^ SetNextInComment(c: SyntaxTree.Comment; this: ANY); 
 		PROCEDURE ^ CommentSymbol(symbol: SyntaxTree.Symbol); 
 		PROCEDURE ^ MapOperator(token: Scanner.Token): LONGINT; 
-		PROCEDURE ^ NewUnaryExpression(position: LONGINT; operand: SyntaxTree.Expression; operator: LONGINT): SyntaxTree.Expression; 
-		PROCEDURE ^ NewBinaryExpression(position: LONGINT; left, right: SyntaxTree.Expression; operator: LONGINT): SyntaxTree.Expression; 
-		PROCEDURE ^ NewTypeExpression(position: LONGINT): SyntaxTree.Expression; 
-		PROCEDURE ^ NewReceiveExpression(position: LONGINT; left, right: SyntaxTree.Expression): SyntaxTree.Expression; 
+		PROCEDURE ^ NewUnaryExpression(position: Position; operand: SyntaxTree.Expression; operator: LONGINT): SyntaxTree.Expression; 
+		PROCEDURE ^ NewBinaryExpression(position: Position; left, right: SyntaxTree.Expression; operator: LONGINT): SyntaxTree.Expression; 
+		PROCEDURE ^ NewTypeExpression(position: Position): SyntaxTree.Expression; 
+		PROCEDURE ^ NewReceiveExpression(position: Position; left, right: SyntaxTree.Expression): SyntaxTree.Expression; 
 		PROCEDURE ^ MapNumberType(numberType: LONGINT): LONGINT; 
 		PROCEDURE ^ EnterInit; 
 		PROCEDURE ^ QualifiedIdentifier(): SyntaxTree.QualifiedIdentifier; 
@@ -116,18 +117,18 @@ TYPE
 		PROCEDURE ^ LocalVariableDeclaration(statements: SyntaxTree.StatementSequence; outer: SyntaxTree.Statement; type: SyntaxTree.Type); 
 		PROCEDURE ^ LocalConstantDeclaration(statements: SyntaxTree.StatementSequence; outer: SyntaxTree.Statement); 
 		PROCEDURE ^ Block(statements: SyntaxTree.StatementSequence; outer: SyntaxTree.Statement); 
-		PROCEDURE ^ NewAsopStatement(position: LONGINT; operator: LONGINT; left: SyntaxTree.Designator; right: SyntaxTree.Expression; outer: SyntaxTree.Statement): SyntaxTree.Statement; 
+		PROCEDURE ^ NewAsopStatement(position: Position; operator: LONGINT; left: SyntaxTree.Designator; right: SyntaxTree.Expression; outer: SyntaxTree.Statement): SyntaxTree.Statement; 
 		PROCEDURE ^ PatchPortReference(expression: SyntaxTree.Expression): SyntaxTree.Expression; 
-		PROCEDURE ^ NewPortStatement(position: LONGINT; name: SyntaxTree.Identifier; left: SyntaxTree.Designator; right: SyntaxTree.Expression; outer: SyntaxTree.Statement): SyntaxTree.Statement; 
+		PROCEDURE ^ NewPortStatement(position: Position; name: SyntaxTree.Identifier; left: SyntaxTree.Designator; right: SyntaxTree.Expression; outer: SyntaxTree.Statement): SyntaxTree.Statement; 
 		PROCEDURE ^ StatementExpression(statements: SyntaxTree.StatementSequence; outer: SyntaxTree.Statement; expression: SyntaxTree.Expression): BOOLEAN; 
 		PROCEDURE ^ ExpressionStatement(statements: SyntaxTree.StatementSequence; outer: SyntaxTree.Statement): BOOLEAN; 
 		PROCEDURE ^ IfStatement(statements: SyntaxTree.StatementSequence; outer: SyntaxTree.Statement); 
 		PROCEDURE ^ SwitchSection(caseStatement: SyntaxTree.CaseStatement; VAR haveDefault: BOOLEAN); 
 		PROCEDURE ^ SwitchStatement(statements: SyntaxTree.StatementSequence; outer: SyntaxTree.Statement); 
-		PROCEDURE ^ NewLynxNewsel(position: LONGINT; outer: SyntaxTree.Statement): SyntaxTree.Statement; 
-		PROCEDURE ^ NewLynxAddsel(position: LONGINT; index: LONGINT; variable: SyntaxTree.Identifier; channel: SyntaxTree.Expression; outer: SyntaxTree.Statement): SyntaxTree.Statement; 
-		PROCEDURE ^ NewLynxSelect(position: LONGINT): SyntaxTree.Expression; 
-		PROCEDURE ^ NewLynxSelidx(position: LONGINT; variable: SyntaxTree.Identifier; outer: SyntaxTree.Statement): SyntaxTree.Statement; 
+		PROCEDURE ^ NewLynxNewsel(position: Position; outer: SyntaxTree.Statement): SyntaxTree.Statement; 
+		PROCEDURE ^ NewLynxAddsel(position: Position; index: LONGINT; variable: SyntaxTree.Identifier; channel: SyntaxTree.Expression; outer: SyntaxTree.Statement): SyntaxTree.Statement; 
+		PROCEDURE ^ NewLynxSelect(position: Position): SyntaxTree.Expression; 
+		PROCEDURE ^ NewLynxSelidx(position: Position; variable: SyntaxTree.Identifier; outer: SyntaxTree.Statement): SyntaxTree.Statement; 
 		PROCEDURE ^ SelectSection(statements: SyntaxTree.StatementSequence; caseStatement: SyntaxTree.CaseStatement; index: LONGINT; outer: SyntaxTree.Statement); 
 		PROCEDURE ^ SelectStatement(statements: SyntaxTree.StatementSequence; outer: SyntaxTree.Statement); 
 		PROCEDURE ^ WhileStatement(statements: SyntaxTree.StatementSequence; outer: SyntaxTree.Statement); 
@@ -152,15 +153,15 @@ TYPE
 		PROCEDURE ^ IdentifierAccess(modifiers: SET; allowedReadOnly: BOOLEAN): SET; 
 		PROCEDURE ^ ConstantDeclarator(parentScope: SyntaxTree.Scope; modifiers: SET; type: SyntaxTree.Type); 
 		PROCEDURE ^ ConstantDeclaration(parentScope: SyntaxTree.Scope; modifiers: SET); 
-		PROCEDURE ^ VariableDeclarator(parentScope: SyntaxTree.Scope; modifiers: SET; type: SyntaxTree.Type; name: SyntaxTree.Identifier; position: LONGINT); 
-		PROCEDURE ^ FieldDeclaration(parentScope: SyntaxTree.Scope; modifiers: SET; type: SyntaxTree.Type; name: SyntaxTree.Identifier; position: LONGINT); 
+		PROCEDURE ^ VariableDeclarator(parentScope: SyntaxTree.Scope; modifiers: SET; type: SyntaxTree.Type; name: SyntaxTree.Identifier; position: Position); 
+		PROCEDURE ^ FieldDeclaration(parentScope: SyntaxTree.Scope; modifiers: SET; type: SyntaxTree.Type; name: SyntaxTree.Identifier; position: Position); 
 		PROCEDURE ^ FixedParameter(procedureType: SyntaxTree.ProcedureType; parentScope: SyntaxTree.Scope); 
 		PROCEDURE ^ FormalParameterList(procedureType: SyntaxTree.ProcedureType; parentScope: SyntaxTree.Scope; returnType: SyntaxTree.Type); 
 		PROCEDURE ^ ConstructorInitializer(scope: SyntaxTree.ProcedureScope); 
-		PROCEDURE ^ ProcedureDeclaration(parentScope: SyntaxTree.Scope; modifiers: SET; type: SyntaxTree.Type; name: SyntaxTree.Identifier; position: LONGINT; isConstructor: BOOLEAN); 
-		PROCEDURE ^ MethodDeclaration(parentScope: SyntaxTree.Scope; modifiers: SET; type: SyntaxTree.Type; name: SyntaxTree.Identifier; position: LONGINT); 
-		PROCEDURE ^ ConstructorDeclaration(parentScope: SyntaxTree.Scope; modifiers: SET; name: SyntaxTree.Identifier; position: LONGINT); 
-		PROCEDURE ^ BodyDeclaration(parentScope: SyntaxTree.Scope; modifiers: SET; type: SyntaxTree.Type; name: SyntaxTree.Identifier; position: LONGINT); 
+		PROCEDURE ^ ProcedureDeclaration(parentScope: SyntaxTree.Scope; modifiers: SET; type: SyntaxTree.Type; name: SyntaxTree.Identifier; position: Position; isConstructor: BOOLEAN); 
+		PROCEDURE ^ MethodDeclaration(parentScope: SyntaxTree.Scope; modifiers: SET; type: SyntaxTree.Type; name: SyntaxTree.Identifier; position: Position); 
+		PROCEDURE ^ ConstructorDeclaration(parentScope: SyntaxTree.Scope; modifiers: SET; name: SyntaxTree.Identifier; position: Position); 
+		PROCEDURE ^ BodyDeclaration(parentScope: SyntaxTree.Scope; modifiers: SET; type: SyntaxTree.Type; name: SyntaxTree.Identifier; position: Position); 
 		PROCEDURE ^ MemberDeclaration(parentScope: SyntaxTree.Scope; parentName: SyntaxTree.Identifier); 
 		PROCEDURE ^ ClassMemberDeclaration(parentScope: SyntaxTree.Scope; parentName: SyntaxTree.Identifier); 
 		PROCEDURE ^ ClassMemberDeclarations(parentScope: SyntaxTree.Scope; parentName: SyntaxTree.Identifier); 
@@ -178,6 +179,8 @@ TYPE
 		PROCEDURE ^ ImportDirectives(moduleScope: SyntaxTree.ModuleScope); 
 		PROCEDURE ^ Module*(): SyntaxTree.Module; 
 	END Parser; 
+VAR 
+	invalidPosition: Position; 
 
 	PROCEDURE ^ NewParser*(scanner: Scanner.Scanner; diagnostics: Diagnostics.Diagnostics): Parser; 
 BEGIN

WinAos/obg/FoxCSharpScanner.SymW

@@ -128,8 +128,10 @@ TYPE
 
 	Token* = LONGINT; 
 
+	Position* = Basic.Position; 
+
 	Symbol* = RECORD 
-		start*, end*, line-: LONGINT; 
+		position*: Position; 
 		token*: Token; 
 		identifier*: IdentifierType; 
 		identifierString*: IdentifierString; 
@@ -150,8 +152,7 @@ TYPE
 		reader: Streams.Reader; 
 		diagnostics: Diagnostics.Diagnostics; 
 		ch: CHAR; 
-		position: LONGINT; 
-		line-: LONGINT; 
+		position-: Position; 
 		error-: BOOLEAN; 
 		stringWriter: Streams.Writer; 
 		stringMaker: StringMaker; 

WinAos/obg/FoxCodeGenerators.SymW

@@ -50,7 +50,7 @@ TYPE
 
 		PROCEDURE ^  & InitGenerator*(diagnostics: Diagnostics.Diagnostics; optimize: BOOLEAN); 
 		PROCEDURE ^ SetModule*(module: Sections.Module); 
-		PROCEDURE ^ Error*(position: LONGINT; CONST message: ARRAY OF CHAR); 
+		PROCEDURE ^ Error*(position: Basic.Position; CONST message: ARRAY OF CHAR); 
 		PROCEDURE ^ Section*(in: IntermediateCode.Section; out: BinaryCode.Section); 
 		PROCEDURE ^ FirstUse*(virtualRegister: LONGINT): LONGINT; 
 		PROCEDURE ^ LastUse*(virtualRegister: LONGINT): LONGINT; 

WinAos/obg/FoxGlobal.SymW

@@ -197,6 +197,8 @@ CONST
 	SymLynxSelidx* = (endFox + 9); 
 	end = (endFox + 10); 
 TYPE 
+	Position = SyntaxTree.Position; 
+
 	Alignment* = RECORD 
 		min, max: LONGINT; 
 	END; 
@@ -285,11 +287,11 @@ VAR
 	PROCEDURE ^ IsSignedInteger*(this: HUGEINT; sizeInBits: LONGINT): BOOLEAN; 
 	PROCEDURE ^ GetSignedIntegerType*(system: System; this: HUGEINT): SyntaxTree.IntegerType; 
 	PROCEDURE ^ GetIntegerType*(system: System; this: HUGEINT): SyntaxTree.IntegerType; 
-	PROCEDURE ^ NewIntegerValue*(system: System; position: LONGINT; hugeint: HUGEINT): SyntaxTree.Value; 
-	PROCEDURE ^ NewBooleanValue*(system: System; position: LONGINT; b: BOOLEAN): SyntaxTree.Value; 
-	PROCEDURE ^ NewSetValue*(system: System; position: LONGINT; s: SET): SyntaxTree.Value; 
-	PROCEDURE ^ NewCharacterValue*(system: System; position: LONGINT; c: CHAR): SyntaxTree.Value; 
-	PROCEDURE ^ NewNilValue*(system: System; position: LONGINT): SyntaxTree.Value; 
+	PROCEDURE ^ NewIntegerValue*(system: System; position: Position; hugeint: HUGEINT): SyntaxTree.Value; 
+	PROCEDURE ^ NewBooleanValue*(system: System; position: Position; b: BOOLEAN): SyntaxTree.Value; 
+	PROCEDURE ^ NewSetValue*(system: System; position: Position; s: SET): SyntaxTree.Value; 
+	PROCEDURE ^ NewCharacterValue*(system: System; position: Position; c: CHAR): SyntaxTree.Value; 
+	PROCEDURE ^ NewNilValue*(system: System; position: Position): SyntaxTree.Value; 
 	PROCEDURE ^ BasicTypeDistance*(system: System; from, to: SyntaxTree.BasicType): LONGINT; 
 	PROCEDURE ^ GetIdentifier*(symbol: LONGINT; case: LONGINT): SyntaxTree.Identifier; 
 	PROCEDURE ^ GetSymbol*(case: LONGINT; id: SyntaxTree.Identifier): LONGINT; 

WinAos/obg/FoxIntermediateAssembler.SymW

@@ -1,5 +1,5 @@
 MODULE FoxIntermediateAssembler;
-	IMPORT IntermediateCode := FoxIntermediateCode, FoxAssembler, D := Debugging, Scanner := FoxScanner;
+	IMPORT IntermediateCode := FoxIntermediateCode, FoxAssembler, D := Debugging, Scanner := FoxScanner, Basic := FoxBasic;
 CONST 
 	Trace = FoxAssembler.Trace; 
 TYPE 

WinAos/obg/FoxIntermediateBackend.SymW

@@ -83,6 +83,8 @@ CONST
 	Size8Flag = 10; 
 	ReflectionSupport = TRUE; 
 TYPE 
+	Position = SyntaxTree.Position; 
+
 	SupportedInstructionProcedure* = PROCEDURE {DELEGATE}(CONST instr: IntermediateCode.Instruction; VAR moduleName, procedureName: ARRAY OF CHAR):BOOLEAN; 
 
 	SupportedImmediateProcedure* = PROCEDURE {DELEGATE}(CONST op: IntermediateCode.Operand):BOOLEAN; 
@@ -132,7 +134,7 @@ TYPE
 		addressType: IntermediateCode.Type; 
 
 		PROCEDURE ^  & Init(system: Global.System; implementationVisitor: ImplementationVisitor; backend: IntermediateBackend; forceModuleBody, dump: BOOLEAN); 
-		PROCEDURE ^ Error(position: LONGINT; CONST s: ARRAY OF CHAR); 
+		PROCEDURE ^ Error(position: Position; CONST s: ARRAY OF CHAR); 
 		PROCEDURE ^ Type(x: SyntaxTree.Type); 
 		PROCEDURE ^ VisitBasicType*(x: SyntaxTree.BasicType); 
 		PROCEDURE ^ VisitCharacterType*(x: SyntaxTree.CharacterType); 
@@ -243,7 +245,7 @@ TYPE
 		checker: SemanticChecker.Checker; 
 		backend: IntermediateBackend; 
 		meta: MetaDataGenerator; 
-		position: LONGINT; 
+		position: Position; 
 		moduleSelf: SyntaxTree.Variable; 
 		currentScope: SyntaxTree.Scope; 
 		constantDeclaration: SyntaxTree.Symbol; 
@@ -299,11 +301,11 @@ TYPE
 		PROCEDURE ^ TraceEnter(CONST s: ARRAY OF CHAR); 
 		PROCEDURE ^ TraceExit(CONST s: ARRAY OF CHAR); 
 		PROCEDURE ^ Emit(instruction: IntermediateCode.Instruction); 
-		PROCEDURE ^ EmitTrap(position, trapNo: LONGINT); 
-		PROCEDURE ^ EmitEnter(section: IntermediateCode.Section; position: LONGINT; procedure: SyntaxTree.Procedure; callconv: LONGINT; varSize: LONGINT; numRegs: LONGINT); 
-		PROCEDURE ^ Enter(position: LONGINT; callconv: LONGINT; varSize: LONGINT): IntermediateCode.Instruction; 
-		PROCEDURE ^ Leave(position: LONGINT; callconv: LONGINT): IntermediateCode.Instruction; 
-		PROCEDURE ^ EmitLeave(section: IntermediateCode.Section; position: LONGINT; procedure: SyntaxTree.Procedure; callconv: LONGINT); 
+		PROCEDURE ^ EmitTrap(position: Position; trapNo: LONGINT); 
+		PROCEDURE ^ EmitEnter(section: IntermediateCode.Section; position: Position; procedure: SyntaxTree.Procedure; callconv: LONGINT; varSize: LONGINT; numRegs: LONGINT); 
+		PROCEDURE ^ Enter(position: Position; callconv: LONGINT; varSize: LONGINT): IntermediateCode.Instruction; 
+		PROCEDURE ^ Leave(position: Position; callconv: LONGINT): IntermediateCode.Instruction; 
+		PROCEDURE ^ EmitLeave(section: IntermediateCode.Section; position: Basic.Position; procedure: SyntaxTree.Procedure; callconv: LONGINT); 
 		PROCEDURE ^ Symbol(x: SyntaxTree.Symbol; VAR op: Operand); 
 		PROCEDURE ^ Expression(x: SyntaxTree.Expression); 
 		PROCEDURE ^ Statement(x: SyntaxTree.Statement); 
@@ -346,8 +348,8 @@ TYPE
 		PROCEDURE ^ VisitMathArrayExpression*(x: SyntaxTree.MathArrayExpression); 
 		PROCEDURE ^ VisitUnaryExpression*(x: SyntaxTree.UnaryExpression); 
 		PROCEDURE ^ TypeTest(tag: IntermediateCode.Operand; type: SyntaxTree.Type; trueL, falseL: Label); 
-		PROCEDURE ^ Error(position: LONGINT; CONST s: ARRAY OF CHAR); 
-		PROCEDURE ^ Warning(position: LONGINT; CONST s: ARRAY OF CHAR); 
+		PROCEDURE ^ Error(position: Position; CONST s: ARRAY OF CHAR); 
+		PROCEDURE ^ Warning(position: Position; CONST s: ARRAY OF CHAR); 
 		PROCEDURE ^ CreateTraceModuleMethod(mod: SyntaxTree.Module); 
 		PROCEDURE ^ CallAssignPointer(CONST dst, src: IntermediateCode.Operand); 
 		PROCEDURE ^ CallAssignMethod(CONST dst, src: IntermediateCode.Operand; type: SyntaxTree.Type); 
@@ -369,8 +371,8 @@ TYPE
 		PROCEDURE ^ GetArrayOfBytesSize(e: SyntaxTree.Expression; tag: IntermediateCode.Operand): IntermediateCode.Operand; 
 		PROCEDURE ^ GetRuntimeProcedure(CONST moduleName, procedureName: ARRAY OF CHAR; VAR procedure: SyntaxTree.Procedure; force: BOOLEAN): BOOLEAN; 
 		PROCEDURE ^ GetTypeDescriptor(CONST moduleName, typeName: ARRAY OF CHAR; VAR name: Basic.SegmentedName): SyntaxTree.Symbol; 
-		PROCEDURE ^ CallThisChecked(position: LONGINT; CONST moduleName, procedureName: ARRAY OF CHAR; numberParameters: LONGINT; checkNumParameters: BOOLEAN); 
-		PROCEDURE ^ CallThis(position: LONGINT; CONST moduleName, procedureName: ARRAY OF CHAR; numberParameters: LONGINT); 
+		PROCEDURE ^ CallThisChecked(position: Position; CONST moduleName, procedureName: ARRAY OF CHAR; numberParameters: LONGINT; checkNumParameters: BOOLEAN); 
+		PROCEDURE ^ CallThis(position: Position; CONST moduleName, procedureName: ARRAY OF CHAR; numberParameters: LONGINT); 
 		PROCEDURE ^ CompareString(br: ConditionalBranch; leftExpression, rightExpression: SyntaxTree.Expression); 
 		PROCEDURE ^ CopyString(leftExpression, rightExpression: SyntaxTree.Expression); 
 		PROCEDURE ^ VisitBinaryExpression*(x: SyntaxTree.BinaryExpression); 
@@ -401,7 +403,7 @@ TYPE
 		PROCEDURE ^ ProfilerAddModule(CONST name: ARRAY OF CHAR); 
 		PROCEDURE ^ ProfilerPatchInit; 
 		PROCEDURE ^ RegisterDynamicOperator(operator: SyntaxTree.Operator); 
-		PROCEDURE ^ SystemTrace(x: SyntaxTree.ExpressionList; pos: LONGINT); 
+		PROCEDURE ^ SystemTrace(x: SyntaxTree.ExpressionList; pos: Position); 
 		PROCEDURE ^ InitFields(type: SyntaxTree.Type; CONST adr: IntermediateCode.Operand; offset: LONGINT); 
 		PROCEDURE ^ InitVariable(VAR variable: SyntaxTree.Variable); 
 		PROCEDURE ^ MathArrayDim(type: SyntaxTree.MathArrayType; CONST base: IntermediateCode.Operand; VAR result: Operand); 
@@ -663,47 +665,47 @@ VAR
 	PROCEDURE ^ ProcedureParametersSize*(system: Global.System; procedure: SyntaxTree.Procedure): LONGINT; 
 	PROCEDURE ^ ToMemoryUnits*(system: Global.System; size: LONGINT): LONGINT; 
 	PROCEDURE ^ Get*(): Backend.Backend; 
-	PROCEDURE ^ Nop(position: LONGINT): IntermediateCode.Instruction; 
-	PROCEDURE ^ Mov(position: LONGINT; dest, src: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ MovReplace(position: LONGINT; dest, src: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Conv(position: LONGINT; dest, src: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Nop(position: Basic.Position): IntermediateCode.Instruction; 
+	PROCEDURE ^ Mov(position: Basic.Position; dest, src: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ MovReplace(position: Basic.Position; dest, src: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Conv(position: Basic.Position; dest, src: IntermediateCode.Operand): IntermediateCode.Instruction; 
 	PROCEDURE ^ SysvABI(cc: LONGINT): BOOLEAN; 
 	PROCEDURE ^ SysvABIorWINAPI(cc: LONGINT): BOOLEAN; 
-	PROCEDURE ^ Call*(position: LONGINT; op: IntermediateCode.Operand; parSize: LONGINT): IntermediateCode.Instruction; 
-	PROCEDURE ^ Exit(position: LONGINT; pcOffset: LONGINT; callingConvention, unwind: LONGINT): IntermediateCode.Instruction; 
-	PROCEDURE ^ Return(position: LONGINT; res: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Result*(position: LONGINT; res: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Trap(position: LONGINT; nr: LONGINT): IntermediateCode.Instruction; 
-	PROCEDURE ^ Br(position: LONGINT; dest: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Breq(position: LONGINT; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Brne(position: LONGINT; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Brge(position: LONGINT; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Brlt(position: LONGINT; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Pop*(position: LONGINT; op: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Push*(position: LONGINT; op: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Neg(position: LONGINT; dest, src: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Not(position: LONGINT; dest, src: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Abs(position: LONGINT; dest, src: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Mul(position: LONGINT; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Div(position: LONGINT; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Mod(position: LONGINT; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Sub(position: LONGINT; dest: IntermediateCode.Operand; left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Add(position: LONGINT; dest: IntermediateCode.Operand; left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ And(position: LONGINT; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Or(position: LONGINT; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Xor(position: LONGINT; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Shl(position: LONGINT; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Shr(position: LONGINT; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Rol(position: LONGINT; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Ror(position: LONGINT; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Cas(position: LONGINT; dest, src, size: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Copy(position: LONGINT; dest, src, size: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Fill(position: LONGINT; dest, size, value: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Asm(position: LONGINT; s: SyntaxTree.SourceCode; inRules, outRules: IntermediateCode.Rules): IntermediateCode.Instruction; 
-	PROCEDURE ^ Data*(position: LONGINT; op: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ SpecialInstruction(position: LONGINT; subtype: SHORTINT; op1, op2, op3: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Reserve(position: LONGINT; units: LONGINT): IntermediateCode.Instruction; 
-	PROCEDURE ^ LabelInstruction(position: LONGINT): IntermediateCode.Instruction; 
+	PROCEDURE ^ Call*(position: Basic.Position; op: IntermediateCode.Operand; parSize: LONGINT): IntermediateCode.Instruction; 
+	PROCEDURE ^ Exit(position: Basic.Position; pcOffset: LONGINT; callingConvention, unwind: LONGINT): IntermediateCode.Instruction; 
+	PROCEDURE ^ Return(position: Basic.Position; res: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Result*(position: Basic.Position; res: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Trap(position: Basic.Position; nr: LONGINT): IntermediateCode.Instruction; 
+	PROCEDURE ^ Br(position: Basic.Position; dest: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Breq(position: Basic.Position; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Brne(position: Basic.Position; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Brge(position: Basic.Position; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Brlt(position: Basic.Position; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Pop*(position: Basic.Position; op: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Push*(position: Basic.Position; op: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Neg(position: Basic.Position; dest, src: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Not(position: Basic.Position; dest, src: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Abs(position: Basic.Position; dest, src: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Mul(position: Basic.Position; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Div(position: Basic.Position; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Mod(position: Basic.Position; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Sub(position: Basic.Position; dest: IntermediateCode.Operand; left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Add(position: Basic.Position; dest: IntermediateCode.Operand; left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ And(position: Basic.Position; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Or(position: Basic.Position; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Xor(position: Basic.Position; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Shl(position: Basic.Position; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Shr(position: Basic.Position; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Rol(position: Basic.Position; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Ror(position: Basic.Position; dest, left, right: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Cas(position: Basic.Position; dest, src, size: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Copy(position: Basic.Position; dest, src, size: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Fill(position: Basic.Position; dest, size, value: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Asm(position: Basic.Position; s: SyntaxTree.SourceCode; inRules, outRules: IntermediateCode.Rules): IntermediateCode.Instruction; 
+	PROCEDURE ^ Data*(position: Basic.Position; op: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ SpecialInstruction(position: Basic.Position; subtype: SHORTINT; op1, op2, op3: IntermediateCode.Operand): IntermediateCode.Instruction; 
+	PROCEDURE ^ Reserve(position: Basic.Position; units: LONGINT): IntermediateCode.Instruction; 
+	PROCEDURE ^ LabelInstruction(position: Basic.Position): IntermediateCode.Instruction; 
 	PROCEDURE ^ EnterImmediate*(data: IntermediateCode.Section; CONST vop: IntermediateCode.Operand): LONGINT; 
 	PROCEDURE ^ Init; 
 	PROCEDURE ^ IsExported(symbol: SyntaxTree.Symbol): BOOLEAN; 

WinAos/obg/FoxIntermediateCode.SymW

@@ -122,7 +122,7 @@ TYPE
 	Instruction* = POINTER TO RECORD 
 		opcode-: SHORTINT; 
 		subtype-: SHORTINT; 
-		textPosition-: LONGINT; 
+		textPosition-: Basic.Position; 
 		pc-: LONGINT; 
 		op1*, op2*, op3*: Operand; 
 	END; 
@@ -192,10 +192,10 @@ VAR
 	PROCEDURE ^ Equals*(CONST i1, i2: Instruction): BOOLEAN; 
 	PROCEDURE ^ DumpInstruction*(w: Streams.Writer; CONST instr: Instruction); 
 	PROCEDURE ^ InitInstructions; 
-	PROCEDURE ^ InitInstruction*(VAR instr: Instruction; textPosition: LONGINT; opcode: SHORTINT; op1, op2, op3: Operand); 
-	PROCEDURE ^ InitInstruction2*(VAR instr: Instruction; textPosition: LONGINT; opcode: SHORTINT; op1, op2: Operand); 
-	PROCEDURE ^ InitInstruction1*(VAR instr: Instruction; textPosition: LONGINT; opcode: SHORTINT; op1: Operand); 
-	PROCEDURE ^ InitInstruction0*(VAR instr: Instruction; textPosition: LONGINT; opcode: SHORTINT); 
+	PROCEDURE ^ InitInstruction*(VAR instr: Instruction; textPosition: Basic.Position; opcode: SHORTINT; op1, op2, op3: Operand); 
+	PROCEDURE ^ InitInstruction2*(VAR instr: Instruction; textPosition: Basic.Position; opcode: SHORTINT; op1, op2: Operand); 
+	PROCEDURE ^ InitInstruction1*(VAR instr: Instruction; textPosition: Basic.Position; opcode: SHORTINT; op1: Operand); 
+	PROCEDURE ^ InitInstruction0*(VAR instr: Instruction; textPosition: Basic.Position; opcode: SHORTINT); 
 	PROCEDURE ^ SetSubType*(VAR instr: Instruction; subType: SHORTINT); 
 	PROCEDURE ^ InitOperand*(VAR op: Operand); 
 	PROCEDURE ^ InitRegister*(VAR op: Operand; type: Type; registerClass: RegisterClass; register: LONGINT); 

WinAos/obg/FoxIntermediateParser.SymW

@@ -6,6 +6,8 @@ CONST
 TYPE 
 	MessageString = ARRAY 256 OF CHAR; 
 
+	Position = Basic.Position; 
+
 	IntermediateCodeParser* = OBJECT 
 	CONST 
 		Trace = FALSE; 
@@ -18,13 +20,13 @@ TYPE
 		system: Global.System; 
 
 		PROCEDURE ^  & Init*(diagnostics: Diagnostics.Diagnostics; s: Global.System); 
-		PROCEDURE ^ Error(pos: LONGINT; CONST msg: ARRAY OF CHAR); 
+		PROCEDURE ^ Error(pos: Position; CONST msg: ARRAY OF CHAR); 
 		PROCEDURE ^ NextSymbol; 
 		PROCEDURE ^ ThisToken(x: LONGINT): BOOLEAN; 
-		PROCEDURE ^ GetIdentifier(VAR pos: LONGINT; VAR identifier: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ GetIdentifier(VAR pos: Position; VAR identifier: ARRAY OF CHAR): BOOLEAN; 
 		PROCEDURE ^ ExpectToken(x: LONGINT): BOOLEAN; 
 		PROCEDURE ^ ThisIdentifier(CONST this: ARRAY OF CHAR): BOOLEAN; 
-		PROCEDURE ^ ExpectAnyIdentifier(VAR pos: LONGINT; VAR identifier: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ ExpectAnyIdentifier(VAR pos: Position; VAR identifier: ARRAY OF CHAR): BOOLEAN; 
 		PROCEDURE ^ ExpectIntegerWithSign(VAR integer: LONGINT): BOOLEAN; 
 		PROCEDURE ^ ExpectIntegerWithoutSign(VAR integer: LONGINT): BOOLEAN; 
 		PROCEDURE ^ IgnoreNewLines; 

WinAos/obg/FoxParser.SymW

@@ -4,6 +4,8 @@ CONST
 	Trace = FALSE; 
 	CascadedWithSupport = TRUE; 
 TYPE 
+	Position* = Scanner.Position; 
+
 	Parser* = OBJECT 
 	VAR 
 		scanner-: Scanner.Scanner; 
@@ -25,7 +27,7 @@ TYPE
 		PROCEDURE ^  & Init*(scanner: Scanner.Scanner; diagnostics: Diagnostics.Diagnostics); 
 		PROCEDURE ^ Reset*; 
 		PROCEDURE ^ SetLax*; 
-		PROCEDURE ^ Error(position: LONGINT; code: LONGINT; CONST message: ARRAY OF CHAR); 
+		PROCEDURE ^ Error(position: Position; code: LONGINT; CONST message: ARRAY OF CHAR); 
 		PROCEDURE ^ SkipComments(b: BOOLEAN); 
 		PROCEDURE ^ NextSymbol*; 
 		PROCEDURE ^ Token*(): LONGINT; 
@@ -35,7 +37,7 @@ TYPE
 		PROCEDURE ^ Mandatory*(token: Scanner.Token): BOOLEAN; 
 		PROCEDURE ^ Check(token: Scanner.Token); 
 		PROCEDURE ^ MandatoryIdentifier(VAR name: SyntaxTree.Identifier): BOOLEAN; 
-		PROCEDURE ^ Identifier(VAR position: LONGINT): SyntaxTree.Identifier; 
+		PROCEDURE ^ Identifier(VAR position: Position): SyntaxTree.Identifier; 
 		PROCEDURE ^ MandatoryString*(VAR name: Scanner.StringType): BOOLEAN; 
 		PROCEDURE ^ ExpectThisIdentifier(name: SyntaxTree.Identifier): BOOLEAN; 
 		PROCEDURE ^ ExpectThisString(CONST name: ARRAY OF CHAR): BOOLEAN; 
@@ -61,14 +63,14 @@ TYPE
 		PROCEDURE ^ Code(outer: SyntaxTree.Statement): SyntaxTree.Code; 
 		PROCEDURE ^ Body(scope: SyntaxTree.ProcedureScope): SyntaxTree.Body; 
 		PROCEDURE ^ BodyProcedure(parentScope: SyntaxTree.Scope): SyntaxTree.Procedure; 
-		PROCEDURE ^ ProcedureType(position: LONGINT; parentScope: SyntaxTree.Scope): SyntaxTree.ProcedureType; 
-		PROCEDURE ^ ObjectType(position: LONGINT; name: SyntaxTree.Identifier; parentScope: SyntaxTree.Scope): SyntaxTree.Type; 
-		PROCEDURE ^ CellType(position: LONGINT; name: SyntaxTree.Identifier; parentScope: SyntaxTree.Scope; isCellNet: BOOLEAN): SyntaxTree.Type; 
-		PROCEDURE ^ PointerType(position: LONGINT; parentScope: SyntaxTree.Scope): SyntaxTree.PointerType; 
-		PROCEDURE ^ RecordType(position: LONGINT; parentScope: SyntaxTree.Scope): SyntaxTree.RecordType; 
-		PROCEDURE ^ ArrayType(position: LONGINT; parentScope: SyntaxTree.Scope): SyntaxTree.Type; 
-		PROCEDURE ^ EnumerationType(position: LONGINT; parentScope: SyntaxTree.Scope): SyntaxTree.Type; 
-		PROCEDURE ^ PortType(position: LONGINT; parentScope: SyntaxTree.Scope): SyntaxTree.Type; 
+		PROCEDURE ^ ProcedureType(position: Position; parentScope: SyntaxTree.Scope): SyntaxTree.ProcedureType; 
+		PROCEDURE ^ ObjectType(position: Position; name: SyntaxTree.Identifier; parentScope: SyntaxTree.Scope): SyntaxTree.Type; 
+		PROCEDURE ^ CellType(position: Position; name: SyntaxTree.Identifier; parentScope: SyntaxTree.Scope; isCellNet: BOOLEAN): SyntaxTree.Type; 
+		PROCEDURE ^ PointerType(position: Position; parentScope: SyntaxTree.Scope): SyntaxTree.PointerType; 
+		PROCEDURE ^ RecordType(position: Position; parentScope: SyntaxTree.Scope): SyntaxTree.RecordType; 
+		PROCEDURE ^ ArrayType(position: Position; parentScope: SyntaxTree.Scope): SyntaxTree.Type; 
+		PROCEDURE ^ EnumerationType(position: Position; parentScope: SyntaxTree.Scope): SyntaxTree.Type; 
+		PROCEDURE ^ PortType(position: Position; parentScope: SyntaxTree.Scope): SyntaxTree.Type; 
 		PROCEDURE ^ Type(name: SyntaxTree.Identifier; parentScope: SyntaxTree.Scope): SyntaxTree.Type; 
 		PROCEDURE ^ PortDeclaration(cell: SyntaxTree.CellType; parentScope: SyntaxTree.Scope); 
 		PROCEDURE ^ PortList(cell: SyntaxTree.CellType; parentScope: SyntaxTree.Scope); 

WinAos/obg/FoxScanner.SymW

@@ -159,8 +159,10 @@ TYPE
 
 	Token* = LONGINT; 
 
+	Position* = Basic.Position; 
+
 	Symbol* = RECORD 
-		start*, end*, line-: LONGINT; 
+		position*: Position; 
 		token*: Token; 
 		identifier*: IdentifierType; 
 		identifierString*: IdentifierString; 
@@ -194,8 +196,7 @@ TYPE
 		reader-: Streams.Reader; 
 		diagnostics: Diagnostics.Diagnostics; 
 		ch-: CHAR; 
-		position-: LONGINT; 
-		line-: LONGINT; 
+		position-: Position; 
 		error-: BOOLEAN; 
 		firstIdentifier: BOOLEAN; 
 		case-: LONGINT; 
@@ -223,7 +224,8 @@ TYPE
 	END Scanner; 
 
 	Context* = RECORD 
-		position, readerPosition, line: LONGINT; 
+		position: Position; 
+		readerPosition: LONGINT; 
 		ch: CHAR; 
 	END; 
 

WinAos/obg/FoxSemanticChecker.SymW

@@ -3,13 +3,14 @@ MODULE FoxSemanticChecker;
 CONST 
 	Trace = FALSE; 
 	Infinity = MAX(LONGINT); 
-	InvalidPosition* = Diagnostics.Invalid; 
 	MaxTensorIndexOperatorSize = 4; 
 	UndefinedPhase = 0; 
 	DeclarationPhase = 1; 
 	InlinePhase = 2; 
 	ImplementationPhase = 3; 
 TYPE 
+	Position = SyntaxTree.Position; 
+
 	FileName = ARRAY 256 OF CHAR; 
 
 	LateFix = POINTER TO RECORD 
@@ -72,10 +73,10 @@ TYPE
 		variableAccessed: BOOLEAN; 
 
 		PROCEDURE ^  & InitChecker*(diagnostics: Diagnostics.Diagnostics; verboseErrorMessage, useDarwinCCalls, cooperative: BOOLEAN; system: Global.System; symbolFileFormat: Formats.SymbolFileFormat; VAR importCache: SyntaxTree.ModuleScope; CONST backend: ARRAY OF CHAR); 
-		PROCEDURE ^ Error(position: LONGINT; code: LONGINT; CONST message: ARRAY OF CHAR); 
-		PROCEDURE ^ Warning(position: LONGINT; CONST message: ARRAY OF CHAR); 
-		PROCEDURE ^ ErrorSS(position: LONGINT; CONST msg, msg2: ARRAY OF CHAR); 
-		PROCEDURE ^ InfoSS(position: LONGINT; CONST msg1: ARRAY OF CHAR; CONST s: Basic.String); 
+		PROCEDURE ^ Error(position: Position; code: LONGINT; CONST message: ARRAY OF CHAR); 
+		PROCEDURE ^ Warning(position: Position; CONST message: ARRAY OF CHAR); 
+		PROCEDURE ^ ErrorSS(position: Position; CONST msg, msg2: ARRAY OF CHAR); 
+		PROCEDURE ^ InfoSS(position: Position; CONST msg1: ARRAY OF CHAR; CONST s: Basic.String); 
 		PROCEDURE ^ Find(inScope: SyntaxTree.Scope; name: SyntaxTree.Identifier; traverse: BOOLEAN): SyntaxTree.Symbol; 
 		PROCEDURE ^ ResolveNamedType(qualifiedIdentifier: SyntaxTree.QualifiedIdentifier; VAR typeDeclaration: SyntaxTree.TypeDeclaration): SyntaxTree.Type; 
 		PROCEDURE ^ TypeNeedsResolution(x: SyntaxTree.Type): BOOLEAN; 
@@ -100,16 +101,16 @@ TYPE
 		PROCEDURE ^ VisitRangeType*(x: SyntaxTree.RangeType); 
 		PROCEDURE ^ VisitQualifiedType*(x: SyntaxTree.QualifiedType); 
 		PROCEDURE ^ VisitArrayType*(x: SyntaxTree.ArrayType); 
-		PROCEDURE ^ ImportModule(name: SyntaxTree.Identifier; position: LONGINT); 
+		PROCEDURE ^ ImportModule(name: SyntaxTree.Identifier; position: Position); 
 		PROCEDURE ^ VisitMathArrayType*(x: SyntaxTree.MathArrayType); 
 		PROCEDURE ^ AnonymousTypeDeclaration(x: SyntaxTree.Type; CONST prefix: ARRAY OF CHAR); 
 		PROCEDURE ^ FixPointerType(type: SyntaxTree.PointerType); 
 		PROCEDURE ^ VisitPointerType*(x: SyntaxTree.PointerType); 
 		PROCEDURE ^ VisitPortType*(x: SyntaxTree.PortType); 
 		PROCEDURE ^ FixProcedureType(procedureType: SyntaxTree.ProcedureType); 
-		PROCEDURE ^ HasFlag(VAR modifiers: SyntaxTree.Modifier; name: SyntaxTree.Identifier; VAR position: LONGINT): BOOLEAN; 
-		PROCEDURE ^ HasValue(modifiers: SyntaxTree.Modifier; name: SyntaxTree.Identifier; VAR position: LONGINT; VAR value: LONGINT): BOOLEAN; 
-		PROCEDURE ^ HasStringValue(modifiers: SyntaxTree.Modifier; name: SyntaxTree.Identifier; VAR position: LONGINT; VAR value: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ HasFlag(VAR modifiers: SyntaxTree.Modifier; name: SyntaxTree.Identifier; VAR position: Position): BOOLEAN; 
+		PROCEDURE ^ HasValue(modifiers: SyntaxTree.Modifier; name: SyntaxTree.Identifier; VAR position: Position; VAR value: LONGINT): BOOLEAN; 
+		PROCEDURE ^ HasStringValue(modifiers: SyntaxTree.Modifier; name: SyntaxTree.Identifier; VAR position: Position; VAR value: ARRAY OF CHAR): BOOLEAN; 
 		PROCEDURE ^ SkipImplementation*(x: SyntaxTree.CellType): BOOLEAN; 
 		PROCEDURE ^ CheckModifiers(modifiers: SyntaxTree.Modifier; checkUse: BOOLEAN); 
 		PROCEDURE ^ VisitProcedureType*(procedureType: SyntaxTree.ProcedureType); 
@@ -123,8 +124,8 @@ TYPE
 		PROCEDURE ^ CheckIndexOperator(operator: SyntaxTree.Operator; arrayStructure: SyntaxTree.MathArrayType; VAR isReadOperator, isGeneralOperator: BOOLEAN; VAR indexListSize, indexListKind: LONGINT): BOOLEAN; 
 		PROCEDURE ^ FixTypes; 
 		PROCEDURE ^ ResolveType(x: SyntaxTree.Type): SyntaxTree.Type; 
-		PROCEDURE ^ RegularType(position: LONGINT; type: SyntaxTree.Type): SyntaxTree.Type; 
-		PROCEDURE ^ SignatureCompatible(position: LONGINT; this, to: SyntaxTree.ProcedureType): BOOLEAN; 
+		PROCEDURE ^ RegularType(position: Position; type: SyntaxTree.Type): SyntaxTree.Type; 
+		PROCEDURE ^ SignatureCompatible(position: Position; this, to: SyntaxTree.ProcedureType): BOOLEAN; 
 		PROCEDURE ^ ParameterCompatible(formal: SyntaxTree.Parameter; actual: SyntaxTree.Expression): BOOLEAN; 
 		PROCEDURE ^ AssignmentCompatible(left: SyntaxTree.Designator; right: SyntaxTree.Expression): BOOLEAN; 
 		PROCEDURE ^ VisitIntegerValue*(value: SyntaxTree.IntegerValue); 
@@ -140,14 +141,14 @@ TYPE
 		PROCEDURE ^ VisitSet*(set: SyntaxTree.Set); 
 		PROCEDURE ^ VisitMathArrayExpression*(x: SyntaxTree.MathArrayExpression); 
 		PROCEDURE ^ VisitUnaryExpression*(unaryExpression: SyntaxTree.UnaryExpression); 
-		PROCEDURE ^ MathArrayConversion(position: LONGINT; expression: SyntaxTree.Expression; type: SyntaxTree.Type): SyntaxTree.Expression; 
-		PROCEDURE ^ ConvertValue(position: LONGINT; expression: SyntaxTree.Value; type: SyntaxTree.Type): SyntaxTree.Expression; 
-		PROCEDURE ^ NewConversion*(position: LONGINT; expression: SyntaxTree.Expression; type: SyntaxTree.Type; reference: SyntaxTree.Expression): SyntaxTree.Expression; 
-		PROCEDURE ^ CompatibleConversion(position: LONGINT; expression: SyntaxTree.Expression; type: SyntaxTree.Type): SyntaxTree.Expression; 
+		PROCEDURE ^ MathArrayConversion(position: Position; expression: SyntaxTree.Expression; type: SyntaxTree.Type): SyntaxTree.Expression; 
+		PROCEDURE ^ ConvertValue(position: Position; expression: SyntaxTree.Value; type: SyntaxTree.Type): SyntaxTree.Expression; 
+		PROCEDURE ^ NewConversion*(position: Position; expression: SyntaxTree.Expression; type: SyntaxTree.Type; reference: SyntaxTree.Expression): SyntaxTree.Expression; 
+		PROCEDURE ^ CompatibleConversion(position: Position; expression: SyntaxTree.Expression; type: SyntaxTree.Type): SyntaxTree.Expression; 
 		PROCEDURE ^ ConvertOperands(VAR left, right: SyntaxTree.Expression); 
 		PROCEDURE ^ FindOperator*(system: Global.System; operator: LONGINT; actualParameters: SyntaxTree.ExpressionList; returnType: SyntaxTree.Type): SyntaxTree.Operator; 
 		PROCEDURE ^ SetCurrentScope*(scope: SyntaxTree.Scope); 
-		PROCEDURE ^ NewOperatorCall*(position: LONGINT; op: LONGINT; leftExpression, rightExpression: SyntaxTree.Expression; resultType: SyntaxTree.Type): SyntaxTree.Expression; 
+		PROCEDURE ^ NewOperatorCall*(position: Position; op: LONGINT; leftExpression, rightExpression: SyntaxTree.Expression; resultType: SyntaxTree.Type): SyntaxTree.Expression; 
 		PROCEDURE ^ VisitBinaryExpression*(binaryExpression: SyntaxTree.BinaryExpression); 
 		PROCEDURE ^ VisitRangeExpression*(x: SyntaxTree.RangeExpression); 
 		PROCEDURE ^ VisitTensorRangeExpression*(x: SyntaxTree.TensorRangeExpression); 
@@ -155,21 +156,21 @@ TYPE
 		PROCEDURE ^ VisitSymbolDesignator*(x: SyntaxTree.SymbolDesignator); 
 		PROCEDURE ^ VisitSelfDesignator*(x: SyntaxTree.SelfDesignator); 
 		PROCEDURE ^ VisitResultDesignator*(x: SyntaxTree.ResultDesignator); 
-		PROCEDURE ^ NewSymbolDesignator*(position: LONGINT; left: SyntaxTree.Designator; symbol: SyntaxTree.Symbol): SyntaxTree.Expression; 
+		PROCEDURE ^ NewSymbolDesignator*(position: Position; left: SyntaxTree.Designator; symbol: SyntaxTree.Symbol): SyntaxTree.Expression; 
 		PROCEDURE ^ VisitIdentifierDesignator*(identifierDesignator: SyntaxTree.IdentifierDesignator); 
 		PROCEDURE ^ VisitSelectorDesignator*(selectorDesignator: SyntaxTree.SelectorDesignator); 
 		PROCEDURE ^ IndexCheck(index, length: SyntaxTree.Expression); 
 		PROCEDURE ^ SetIndexBaseType(indexDesignator: SyntaxTree.IndexDesignator; newBaseType: SyntaxTree.Type); 
-		PROCEDURE ^ AppendMathIndex(position: LONGINT; indexDesignator: SyntaxTree.IndexDesignator; indexListItem: SyntaxTree.Expression; sourceArray: SyntaxTree.MathArrayType); 
-		PROCEDURE ^ AppendIndex(position: LONGINT; index: SyntaxTree.IndexDesignator; expression: SyntaxTree.Expression; over: SyntaxTree.Type); 
+		PROCEDURE ^ AppendMathIndex(position: Position; indexDesignator: SyntaxTree.IndexDesignator; indexListItem: SyntaxTree.Expression; sourceArray: SyntaxTree.MathArrayType); 
+		PROCEDURE ^ AppendIndex(position: Position; index: SyntaxTree.IndexDesignator; expression: SyntaxTree.Expression; over: SyntaxTree.Type); 
 		PROCEDURE ^ ConvertToMathArray(expression: SyntaxTree.Expression): SyntaxTree.Expression; 
 		PROCEDURE ^ ListOfOpenRanges(itemCount: LONGINT): SyntaxTree.ExpressionList; 
-		PROCEDURE ^ NewIndexOperatorCall*(position: LONGINT; left: SyntaxTree.Expression; indexList: SyntaxTree.ExpressionList; rhs: SyntaxTree.Expression): SyntaxTree.Designator; 
-		PROCEDURE ^ NewObjectOperatorCall*(position: LONGINT; left: SyntaxTree.Expression; oper: LONGINT; parameters: SyntaxTree.ExpressionList; rhs: SyntaxTree.Expression): SyntaxTree.Designator; 
+		PROCEDURE ^ NewIndexOperatorCall*(position: Position; left: SyntaxTree.Expression; indexList: SyntaxTree.ExpressionList; rhs: SyntaxTree.Expression): SyntaxTree.Designator; 
+		PROCEDURE ^ NewObjectOperatorCall*(position: Position; left: SyntaxTree.Expression; oper: LONGINT; parameters: SyntaxTree.ExpressionList; rhs: SyntaxTree.Expression): SyntaxTree.Designator; 
 		PROCEDURE ^ VisitBracketDesignator*(bracketDesignator: SyntaxTree.BracketDesignator); 
 		PROCEDURE ^ ExpressionList(expressionList: SyntaxTree.ExpressionList): BOOLEAN; 
 		PROCEDURE ^ CanPassInRegister*(type: SyntaxTree.Type): BOOLEAN; 
-		PROCEDURE ^ NewProcedureCallDesignator(position: LONGINT; left: SyntaxTree.Designator; actualParameters: SyntaxTree.ExpressionList): SyntaxTree.Designator; 
+		PROCEDURE ^ NewProcedureCallDesignator(position: Position; left: SyntaxTree.Designator; actualParameters: SyntaxTree.ExpressionList): SyntaxTree.Designator; 
 		PROCEDURE ^ VisitTypeGuardDesignator*(x: SyntaxTree.TypeGuardDesignator); 
 		PROCEDURE ^ VisitBuiltinCallDesignator*(x: SyntaxTree.BuiltinCallDesignator); 
 		PROCEDURE ^ VisitProcedureCallDesignator*(x: SyntaxTree.ProcedureCallDesignator); 
@@ -198,11 +199,11 @@ TYPE
 		PROCEDURE ^ CheckCharacterValue(x: SyntaxTree.Expression; VAR value: CHAR): BOOLEAN; 
 		PROCEDURE ^ CheckPositiveIntegerValue(x: SyntaxTree.Expression; VAR value: LONGINT; includeZero: BOOLEAN): BOOLEAN; 
 		PROCEDURE ^ CheckPortType(x: SyntaxTree.Expression; VAR portType: SyntaxTree.PortType): BOOLEAN; 
-		PROCEDURE ^ NewBuiltinCallDesignator(position: LONGINT; builtin: SyntaxTree.Builtin; actualParameters: SyntaxTree.ExpressionList; left: SyntaxTree.Designator; returnType: SyntaxTree.Type): SyntaxTree.Expression; 
-		PROCEDURE ^ NewTypeGuardDesignator(position: LONGINT; left: SyntaxTree.Designator; type: SyntaxTree.Type; typeExpression: SyntaxTree.Expression): SyntaxTree.Designator; 
+		PROCEDURE ^ NewBuiltinCallDesignator(position: Position; builtin: SyntaxTree.Builtin; actualParameters: SyntaxTree.ExpressionList; left: SyntaxTree.Designator; returnType: SyntaxTree.Type): SyntaxTree.Expression; 
+		PROCEDURE ^ NewTypeGuardDesignator(position: Position; left: SyntaxTree.Designator; type: SyntaxTree.Type; typeExpression: SyntaxTree.Expression): SyntaxTree.Designator; 
 		PROCEDURE ^ VisitParameterDesignator*(designator: SyntaxTree.ParameterDesignator); 
-		PROCEDURE ^ NewDereferenceDesignator(position: LONGINT; left: SyntaxTree.Designator): SyntaxTree.Designator; 
-		PROCEDURE ^ NewSupercallDesignator(position: LONGINT; left: SyntaxTree.Designator): SyntaxTree.Designator; 
+		PROCEDURE ^ NewDereferenceDesignator(position: Position; left: SyntaxTree.Designator): SyntaxTree.Designator; 
+		PROCEDURE ^ NewSupercallDesignator(position: Position; left: SyntaxTree.Designator): SyntaxTree.Designator; 
 		PROCEDURE ^ VisitArrowDesignator*(arrowDesignator: SyntaxTree.ArrowDesignator); 
 		PROCEDURE ^ ResolveExpression(expression: SyntaxTree.Expression): SyntaxTree.Expression; 
 		PROCEDURE ^ ConstantExpression(expression: SyntaxTree.Expression): SyntaxTree.Expression; 
@@ -243,7 +244,7 @@ TYPE
 		PROCEDURE ^ VisitExitStatement*(exitStatement: SyntaxTree.ExitStatement); 
 		PROCEDURE ^ VisitReturnStatement*(returnStatement: SyntaxTree.ReturnStatement); 
 		PROCEDURE ^ VisitAwaitStatement*(awaitStatement: SyntaxTree.AwaitStatement); 
-		PROCEDURE ^ CheckSystemImport(position: LONGINT); 
+		PROCEDURE ^ CheckSystemImport(position: Position); 
 		PROCEDURE ^ VisitCode*(code: SyntaxTree.Code); 
 		PROCEDURE ^ BlockFlags(block: SyntaxTree.StatementBlock); 
 		PROCEDURE ^ VisitStatementBlock*(statementBlock: SyntaxTree.StatementBlock); 

WinAos/obg/FoxSyntaxTree.SymW

@@ -39,6 +39,8 @@ CONST
 	FlagParameterVar* = 1; 
 	FlagParameterConst* = 2; 
 TYPE 
+	Position* = Scanner.Position; 
+
 	SourceCode* = Scanner.StringType; 
 
 	BinaryCode* = BitSets.BitSet; 
@@ -157,9 +159,9 @@ TYPE
 	QualifiedIdentifier* = OBJECT 
 	VAR 
 		prefix-, suffix-: Identifier; 
-		position-: LONGINT; 
+		position-: Position; 
 
-		PROCEDURE ^  & InitQualifiedIdentifier(position: LONGINT; prefix, suffix: Identifier); 
+		PROCEDURE ^  & InitQualifiedIdentifier(position: Position; prefix, suffix: Identifier); 
 		PROCEDURE ^ GetName*(VAR name: Basic.SegmentedName); 
 	END QualifiedIdentifier; 
 
@@ -168,7 +170,7 @@ TYPE
 		typeDeclaration-: TypeDeclaration; 
 		scope-: Scope; 
 		resolved-: Type; 
-		position-, endposition-: LONGINT; 
+		position-: Position; 
 		state-: SET; 
 		hasPointers-: BOOLEAN; 
 		fingerprint-: FingerPrint; 
@@ -177,7 +179,7 @@ TYPE
 		sizeInBits-: LONGINT; 
 		alignmentInBits-: LONGINT; 
 
-		PROCEDURE ^  & InitType*(position: LONGINT); 
+		PROCEDURE ^  & InitType*(position: Position); 
 		PROCEDURE ^ SetSize*(sizeInBits: LONGINT); 
 		PROCEDURE ^ SetAlignmentInBits*(alignmentInBits: LONGINT); 
 		PROCEDURE ^ End*(position: LONGINT); 
@@ -329,7 +331,7 @@ TYPE
 	VAR 
 		qualifiedIdentifier-: QualifiedIdentifier; 
 
-		PROCEDURE ^  & InitQualifiedType(position: LONGINT; scope: Scope; qualifiedIdentifier: QualifiedIdentifier); 
+		PROCEDURE ^  & InitQualifiedType(position: Position; scope: Scope; qualifiedIdentifier: QualifiedIdentifier); 
 		PROCEDURE ^ SetResolved*(resolved: Type); 
 		PROCEDURE ^ SameType*(this: Type): BOOLEAN; 
 		PROCEDURE ^ CompatibleTo*(to: Type): BOOLEAN; 
@@ -345,7 +347,7 @@ TYPE
 		length-: LONGINT; 
 		baseType-: Type; 
 
-		PROCEDURE ^  & InitStringType(position: LONGINT; baseType: Type; length: LONGINT); 
+		PROCEDURE ^  & InitStringType(position: Position; baseType: Type; length: LONGINT); 
 		PROCEDURE ^ SetLength*(length: LONGINT); 
 		PROCEDURE ^ SameType*(this: Type): BOOLEAN; 
 		PROCEDURE ^ CompatibleTo*(to: Type): BOOLEAN; 
@@ -359,7 +361,7 @@ TYPE
 		enumerationBase-: Type; 
 		rangeLowest-, rangeHighest-: LONGINT; 
 
-		PROCEDURE ^  & InitEnumerationType(position: LONGINT; scope: Scope; enumerationScope: EnumerationScope); 
+		PROCEDURE ^  & InitEnumerationType(position: Position; scope: Scope; enumerationScope: EnumerationScope); 
 		PROCEDURE ^ SetEnumerationBase*(base: Type); 
 		PROCEDURE ^ SetRange*(lowest, highest: LONGINT); 
 		PROCEDURE ^ Extends*(this: EnumerationType): BOOLEAN; 
@@ -375,7 +377,7 @@ TYPE
 		staticLength-: LONGINT; 
 		form-: LONGINT; 
 
-		PROCEDURE ^  & InitArrayType(position: LONGINT; scope: Scope; form: LONGINT); 
+		PROCEDURE ^  & InitArrayType(position: Position; scope: Scope; form: LONGINT); 
 		PROCEDURE ^ SetArrayBase*(type: Type); 
 		PROCEDURE ^ SetForm*(f: LONGINT); 
 		PROCEDURE ^ SetLength*(length: Expression); 
@@ -395,7 +397,7 @@ TYPE
 		staticIncrementInBits-: LONGINT; 
 		form-: LONGINT; 
 
-		PROCEDURE ^  & InitMathArrayType(position: LONGINT; scope: Scope; form: LONGINT); 
+		PROCEDURE ^  & InitMathArrayType(position: Position; scope: Scope; form: LONGINT); 
 		PROCEDURE ^ SetForm*(form: LONGINT); 
 		PROCEDURE ^ SetArrayBase*(type: Type); 
 		PROCEDURE ^ SetLength*(length: Expression); 
@@ -418,7 +420,7 @@ TYPE
 		isDisposable-: BOOLEAN; 
 		isHidden-: BOOLEAN; 
 
-		PROCEDURE ^  & InitPointerType(position: LONGINT; scope: Scope); 
+		PROCEDURE ^  & InitPointerType(position: Position; scope: Scope); 
 		PROCEDURE ^ SetHidden*(hidden: BOOLEAN); 
 		PROCEDURE ^ SetModifiers*(flags: Modifier); 
 		PROCEDURE ^ SetPointerBase*(type: Type); 
@@ -439,7 +441,7 @@ TYPE
 		sizeInBits-: LONGINT; 
 		cellsAreObjects-: BOOLEAN; 
 
-		PROCEDURE ^  & InitPortType(position: LONGINT; direction: LONGINT; sizeExpression: Expression; scope: Scope); 
+		PROCEDURE ^  & InitPortType(position: Position; direction: LONGINT; sizeExpression: Expression; scope: Scope); 
 		PROCEDURE ^ SetSize*(size: LONGINT); 
 		PROCEDURE ^ SetSizeExpression*(sizeExpression: Expression); 
 		PROCEDURE ^ SetCellsAreObjects*(b: BOOLEAN); 
@@ -459,7 +461,7 @@ TYPE
 		arrayStructure-: MathArrayType; 
 		arrayAccessOperators-: ArrayAccessOperators; 
 
-		PROCEDURE ^  & InitRecordType(position: LONGINT; scope: Scope; recordScope: RecordScope); 
+		PROCEDURE ^  & InitRecordType(position: Position; scope: Scope; recordScope: RecordScope); 
 		PROCEDURE ^ SetModifiers*(flag: Modifier); 
 		PROCEDURE ^ SetBaseType*(type: Type); 
 		PROCEDURE ^ SetPointerType*(pointerType: PointerType); 
@@ -492,7 +494,7 @@ TYPE
 		modifiers-: Modifier; 
 		baseType-: Type; 
 
-		PROCEDURE ^  & InitCellType(position: LONGINT; scope: Scope; cellScope: CellScope); 
+		PROCEDURE ^  & InitCellType(position: Position; scope: Scope; cellScope: CellScope); 
 		PROCEDURE ^ SetBaseType*(base: Type); 
 		PROCEDURE ^ GetBaseValueType*(): Type; 
 		PROCEDURE ^ GetBaseRecord*(): RecordType; 
@@ -523,7 +525,7 @@ TYPE
 		stackAlignment-: LONGINT; 
 		parametersOffset-: LONGINT; 
 
-		PROCEDURE ^  & InitProcedureType(position: LONGINT; scope: Scope); 
+		PROCEDURE ^  & InitProcedureType(position: Position; scope: Scope); 
 		PROCEDURE ^ SetNoPAF*(noPAF: BOOLEAN); 
 		PROCEDURE ^ SetNoReturn*(noReturn: BOOLEAN); 
 		PROCEDURE ^ SetPcOffset*(pcOffset: LONGINT); 
@@ -550,14 +552,14 @@ TYPE
 	VAR 
 		type-: Type; 
 		assignable-: BOOLEAN; 
-		position-, endposition-: LONGINT; 
+		position-: Position; 
 		state-: SET; 
 		resolved-: Value; 
 		isHidden-: BOOLEAN; 
 
 		PROCEDURE ^ End*(position: LONGINT); 
 		PROCEDURE ^ SetState*(state: LONGINT); 
-		PROCEDURE ^  & InitExpression(position: LONGINT); 
+		PROCEDURE ^  & InitExpression(position: Position); 
 		PROCEDURE ^ SetHidden*(hidden: BOOLEAN); 
 		PROCEDURE ^ SetType*(type: Type); 
 		PROCEDURE ^ SetResolved*(value: Value); 
@@ -585,7 +587,7 @@ TYPE
 	VAR 
 		elements-: ExpressionList; 
 
-		PROCEDURE ^  & InitSet(position: LONGINT); 
+		PROCEDURE ^  & InitSet(position: Position); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
 	END Set; 
@@ -594,7 +596,7 @@ TYPE
 	VAR 
 		elements-: ExpressionList; 
 
-		PROCEDURE ^  & InitMathArrayExpression(position: LONGINT); 
+		PROCEDURE ^  & InitMathArrayExpression(position: Position); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
 	END MathArrayExpression; 
@@ -604,7 +606,7 @@ TYPE
 		left-: Expression; 
 		operator-: LONGINT; 
 
-		PROCEDURE ^  & InitUnaryExpression(position: LONGINT; operand: Expression; operator: LONGINT); 
+		PROCEDURE ^  & InitUnaryExpression(position: Position; operand: Expression; operator: LONGINT); 
 		PROCEDURE ^ SetLeft*(left: Expression); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
@@ -615,7 +617,7 @@ TYPE
 		left-, right-: Expression; 
 		operator-: LONGINT; 
 
-		PROCEDURE ^  & InitBinaryExpression(position: LONGINT; left, right: Expression; operator: LONGINT); 
+		PROCEDURE ^  & InitBinaryExpression(position: Position; left, right: Expression; operator: LONGINT); 
 		PROCEDURE ^ SetLeft*(left: Expression); 
 		PROCEDURE ^ SetRight*(right: Expression); 
 		PROCEDURE ^ Clone(): Expression; 
@@ -628,7 +630,7 @@ TYPE
 		missingFirst-, missingLast-, missingStep-: BOOLEAN; 
 		context-: SHORTINT; 
 
-		PROCEDURE ^  & InitRangeExpression(position: LONGINT; first, last, step: Expression); 
+		PROCEDURE ^  & InitRangeExpression(position: Position; first, last, step: Expression); 
 		PROCEDURE ^ SetFirst*(first: Expression); 
 		PROCEDURE ^ SetLast*(last: Expression); 
 		PROCEDURE ^ SetStep*(step: Expression); 
@@ -639,7 +641,7 @@ TYPE
 
 	TensorRangeExpression* = OBJECT (Expression)
 
-		PROCEDURE ^  & InitTensorRangeExpression(position: LONGINT); 
+		PROCEDURE ^  & InitTensorRangeExpression(position: Position); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
 	END TensorRangeExpression; 
@@ -649,7 +651,7 @@ TYPE
 		expression-: Expression; 
 		typeExpression-: Expression; 
 
-		PROCEDURE ^  & InitConversion(position: LONGINT; expression: Expression; type: Type; typeExpression: Expression); 
+		PROCEDURE ^  & InitConversion(position: Position; expression: Expression; type: Type; typeExpression: Expression); 
 		PROCEDURE ^ SetExpression*(expression: Expression); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
@@ -663,7 +665,7 @@ TYPE
 		relatedIndexList-: ExpressionList; 
 		modifiers-: Modifier; 
 
-		PROCEDURE ^  & InitDesignator*(position: LONGINT); 
+		PROCEDURE ^  & InitDesignator*(position: Position); 
 		PROCEDURE ^ SetLeft*(expression: Expression); 
 		PROCEDURE ^ SetRelatedRhs*(relatedRhs: Expression); 
 		PROCEDURE ^ SetRelatedAsot*(relatedAsot: Expression); 
@@ -677,7 +679,7 @@ TYPE
 	VAR 
 		identifier-: Identifier; 
 
-		PROCEDURE ^  & InitIdentifierDesignator(position: LONGINT; id: Identifier); 
+		PROCEDURE ^  & InitIdentifierDesignator(position: Position; id: Identifier); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
 	END IdentifierDesignator; 
@@ -686,7 +688,7 @@ TYPE
 	VAR 
 		identifier-: Identifier; 
 
-		PROCEDURE ^  & InitSelector(position: LONGINT; left: Designator; identifier: Identifier); 
+		PROCEDURE ^  & InitSelector(position: Position; left: Designator; identifier: Identifier); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
 	END SelectorDesignator; 
@@ -695,14 +697,14 @@ TYPE
 	VAR 
 		parameters-: ExpressionList; 
 
-		PROCEDURE ^  & InitParameterDesignator(position: LONGINT; left: Designator; parameters: ExpressionList); 
+		PROCEDURE ^  & InitParameterDesignator(position: Position; left: Designator; parameters: ExpressionList); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
 	END ParameterDesignator; 
 
 	ArrowDesignator* = OBJECT (Designator)
 
-		PROCEDURE ^  & InitArrowDesignator(position: LONGINT; left: Designator); 
+		PROCEDURE ^  & InitArrowDesignator(position: Position; left: Designator); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
 	END ArrowDesignator; 
@@ -711,7 +713,7 @@ TYPE
 	VAR 
 		parameters-: ExpressionList; 
 
-		PROCEDURE ^  & InitBracketDesignator(position: LONGINT; left: Designator; parameters: ExpressionList); 
+		PROCEDURE ^  & InitBracketDesignator(position: Position; left: Designator; parameters: ExpressionList); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
 	END BracketDesignator; 
@@ -720,7 +722,7 @@ TYPE
 	VAR 
 		symbol-: Symbol; 
 
-		PROCEDURE ^  & InitSymbolDesignator(position: LONGINT; left: Designator; symbol: Symbol); 
+		PROCEDURE ^  & InitSymbolDesignator(position: Position; left: Designator; symbol: Symbol); 
 		PROCEDURE ^ Accept*(v: Visitor); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ SetSymbol*(s: Symbol); 
@@ -733,7 +735,7 @@ TYPE
 		hasRange-: BOOLEAN; 
 		hasTensorRange-: BOOLEAN; 
 
-		PROCEDURE ^  & InitIndexDesignator(position: LONGINT; left: Designator); 
+		PROCEDURE ^  & InitIndexDesignator(position: Position; left: Designator); 
 		PROCEDURE ^ HasRange*; 
 		PROCEDURE ^ HasTensorRange*; 
 		PROCEDURE ^ Clone(): Expression; 
@@ -746,7 +748,7 @@ TYPE
 		statement-: Statement; 
 		result-: Expression; 
 
-		PROCEDURE ^  & InitStatementDesignator(position: LONGINT; s: Statement); 
+		PROCEDURE ^  & InitStatementDesignator(position: Position; s: Statement); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ SetResult*(r: Expression); 
 		PROCEDURE ^ Accept*(v: Visitor); 
@@ -756,7 +758,7 @@ TYPE
 	VAR 
 		parameters-: ExpressionList; 
 
-		PROCEDURE ^  & InitProcedureCallDesignator(position: LONGINT; left: Designator; parameters: ExpressionList); 
+		PROCEDURE ^  & InitProcedureCallDesignator(position: Position; left: Designator; parameters: ExpressionList); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
 	END ProcedureCallDesignator; 
@@ -768,7 +770,7 @@ TYPE
 		builtin-: Builtin; 
 		returnType-: Type; 
 
-		PROCEDURE ^  & InitBuiltinCallDesignator(position: LONGINT; id: LONGINT; left: Designator; parameters: ExpressionList); 
+		PROCEDURE ^  & InitBuiltinCallDesignator(position: Position; id: LONGINT; left: Designator; parameters: ExpressionList); 
 		PROCEDURE ^ SetReturnType*(type: Type); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
@@ -778,7 +780,7 @@ TYPE
 	VAR 
 		typeExpression-: Expression; 
 
-		PROCEDURE ^  & InitTypeGuardDesignator(position: LONGINT; left: Designator; type: Type); 
+		PROCEDURE ^  & InitTypeGuardDesignator(position: Position; left: Designator; type: Type); 
 		PROCEDURE ^ SetTypeExpression*(typeExpression: Expression); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
@@ -787,7 +789,7 @@ TYPE
 
 	DereferenceDesignator* = OBJECT (Designator)
 
-		PROCEDURE ^  & InitDereferenceDesignator(position: LONGINT; left: Designator); 
+		PROCEDURE ^  & InitDereferenceDesignator(position: Position; left: Designator); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
 		PROCEDURE ^ NeedsTrace*(): BOOLEAN; 
@@ -795,14 +797,14 @@ TYPE
 
 	SupercallDesignator* = OBJECT (Designator)
 
-		PROCEDURE ^  & InitSupercallDesignator(position: LONGINT; left: Designator); 
+		PROCEDURE ^  & InitSupercallDesignator(position: Position; left: Designator); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
 	END SupercallDesignator; 
 
 	SelfDesignator* = OBJECT (Designator)
 
-		PROCEDURE ^  & InitSelfDesignator(position: LONGINT); 
+		PROCEDURE ^  & InitSelfDesignator(position: Position); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
 		PROCEDURE ^ NeedsTrace*(): BOOLEAN; 
@@ -810,7 +812,7 @@ TYPE
 
 	ResultDesignator* = OBJECT (Designator)
 
-		PROCEDURE ^  & InitResultDesignator(position: LONGINT); 
+		PROCEDURE ^  & InitResultDesignator(position: Position); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
 	END ResultDesignator; 
@@ -819,7 +821,7 @@ TYPE
 	VAR 
 		fingerprint-: FingerPrint; 
 
-		PROCEDURE ^  & InitValue(position: LONGINT); 
+		PROCEDURE ^  & InitValue(position: Position); 
 		PROCEDURE ^ SetFingerPrint*(CONST fp: FingerPrint); 
 		PROCEDURE ^ Accept*(v: Visitor); 
 		PROCEDURE ^ Equals*(v: Value): BOOLEAN; 
@@ -829,7 +831,7 @@ TYPE
 	VAR 
 		value-: BOOLEAN; 
 
-		PROCEDURE ^  & InitBooleanValue(position: LONGINT; value: BOOLEAN); 
+		PROCEDURE ^  & InitBooleanValue(position: Position; value: BOOLEAN); 
 		PROCEDURE ^ SetValue*(value: BOOLEAN); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
@@ -841,7 +843,7 @@ TYPE
 		hvalue-: HUGEINT; 
 		value-: LONGINT; 
 
-		PROCEDURE ^  & InitIntegerValue(position: LONGINT; hvalue: HUGEINT); 
+		PROCEDURE ^  & InitIntegerValue(position: Position; hvalue: HUGEINT); 
 		PROCEDURE ^ SetValue*(hvalue: HUGEINT); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
@@ -852,7 +854,7 @@ TYPE
 	VAR 
 		value-: CHAR; 
 
-		PROCEDURE ^  & InitCharacterValue(position: LONGINT; value: CHAR); 
+		PROCEDURE ^  & InitCharacterValue(position: Position; value: CHAR); 
 		PROCEDURE ^ SetValue*(value: CHAR); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
@@ -865,7 +867,7 @@ TYPE
 	VAR 
 		value-: SET; 
 
-		PROCEDURE ^  & InitSetValue(position: LONGINT; value: SET); 
+		PROCEDURE ^  & InitSetValue(position: Position; value: SET); 
 		PROCEDURE ^ SetValue*(value: SET); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
@@ -875,7 +877,7 @@ TYPE
 	VAR 
 		array-: MathArrayExpression; 
 
-		PROCEDURE ^  & InitMathArrayValue(position: LONGINT); 
+		PROCEDURE ^  & InitMathArrayValue(position: Position); 
 		PROCEDURE ^ SetArray*(array: MathArrayExpression); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
@@ -886,7 +888,7 @@ TYPE
 		value-: LONGREAL; 
 		subtype-: LONGINT; 
 
-		PROCEDURE ^  & InitRealValue(position: LONGINT; value: LONGREAL); 
+		PROCEDURE ^  & InitRealValue(position: Position; value: LONGREAL); 
 		PROCEDURE ^ SetValue*(value: LONGREAL); 
 		PROCEDURE ^ SetSubtype*(subtype: LONGINT); 
 		PROCEDURE ^ Clone(): Expression; 
@@ -899,7 +901,7 @@ TYPE
 		realValue-, imagValue-: LONGREAL; 
 		subtype-: LONGINT; 
 
-		PROCEDURE ^  & InitComplexValue(position: LONGINT; realValue, imagValue: LONGREAL); 
+		PROCEDURE ^  & InitComplexValue(position: Position; realValue, imagValue: LONGREAL); 
 		PROCEDURE ^ SetValue*(realValue, imagValue: LONGREAL); 
 		PROCEDURE ^ UpdateSubtype*; 
 		PROCEDURE ^ SetSubtype*(subtype: LONGINT); 
@@ -913,7 +915,7 @@ TYPE
 		value-: String; 
 		length-: LONGINT; 
 
-		PROCEDURE ^  & InitStringValue(position: LONGINT; value: String); 
+		PROCEDURE ^  & InitStringValue(position: Position; value: String); 
 		PROCEDURE ^ SetValue*(CONST value: String); 
 		PROCEDURE ^ Append*(CONST value: String); 
 		PROCEDURE ^ AppendChar*(CONST ch: CHAR); 
@@ -933,7 +935,7 @@ TYPE
 	VAR 
 		value-: LONGINT; 
 
-		PROCEDURE ^  & InitEnumerationValue(position: LONGINT; value: LONGINT); 
+		PROCEDURE ^  & InitEnumerationValue(position: Position; value: LONGINT); 
 		PROCEDURE ^ SetValue*(value: LONGINT); 
 		PROCEDURE ^ Clone(): Expression; 
 		PROCEDURE ^ Accept*(v: Visitor); 
@@ -952,12 +954,12 @@ TYPE
 		used-, written-: BOOLEAN; 
 		fixed-: BOOLEAN; 
 		alignment-: LONGINT; 
-		position-: LONGINT; 
+		position-: Position; 
 		state-: SET; 
 		fingerprint-: FingerPrint; 
 		comment-: Comment; 
 
-		PROCEDURE ^  & InitSymbol(position: LONGINT; name: Identifier); 
+		PROCEDURE ^  & InitSymbol(position: Position; name: Identifier); 
 		PROCEDURE ^ SetAlignment*(fix: BOOLEAN; align: LONGINT); 
 		PROCEDURE ^ SetFingerPrint*(CONST fp: FingerPrint); 
 		PROCEDURE ^ SetState*(state: LONGINT); 
@@ -980,7 +982,7 @@ TYPE
 		nextTypeDeclaration-: TypeDeclaration; 
 		declaredType-: Type; 
 
-		PROCEDURE ^  & InitTypeDeclaration(position: LONGINT; name: Identifier); 
+		PROCEDURE ^  & InitTypeDeclaration(position: Position; name: Identifier); 
 		PROCEDURE ^ SetDeclaredType*(type: Type); 
 		PROCEDURE ^ SetType*(type: Type); 
 		PROCEDURE ^ Accept*(v: Visitor); 
@@ -991,7 +993,7 @@ TYPE
 		value-: Expression; 
 		nextConstant-: Constant; 
 
-		PROCEDURE ^  & InitConstant(position: LONGINT; name: Identifier); 
+		PROCEDURE ^  & InitConstant(position: Position; name: Identifier); 
 		PROCEDURE ^ SetValue*(value: Expression); 
 		PROCEDURE ^ Accept*(v: Visitor); 
 	END Constant; 
@@ -1008,7 +1010,7 @@ TYPE
 		initializer-: Expression; 
 		usedAsReference-: BOOLEAN; 
 
-		PROCEDURE ^  & InitVariable*(position: LONGINT; name: Identifier); 
+		PROCEDURE ^  & InitVariable*(position: Position; name: Identifier); 
 		PROCEDURE ^ UsedAsReference*; 
 		PROCEDURE ^ SetUntraced*(u: BOOLEAN); 
 		PROCEDURE ^ SetUseRegister*(u: BOOLEAN); 
@@ -1030,7 +1032,7 @@ TYPE
 		untraced-: BOOLEAN; 
 		movable-: BOOLEAN; 
 
-		PROCEDURE ^  & InitParameter(position: LONGINT; ownerType: Type; name: Identifier; kind: LONGINT); 
+		PROCEDURE ^  & InitParameter(position: Position; ownerType: Type; name: Identifier; kind: LONGINT); 
 		PROCEDURE ^ SetModifiers*(flag: Modifier); 
 		PROCEDURE ^ SetUntraced*(untraced: BOOLEAN); 
 		PROCEDURE ^ SetMoveable*(movable: BOOLEAN); 
@@ -1045,7 +1047,7 @@ TYPE
 		nextProperty-, prevProperty-: Property; 
 		value-: Expression; 
 
-		PROCEDURE ^  & InitProperty(position: LONGINT; name: Identifier); 
+		PROCEDURE ^  & InitProperty(position: Position; name: Identifier); 
 		PROCEDURE ^ SetValue*(e: Expression); 
 		PROCEDURE ^ Accept*(v: Visitor); 
 	END Property; 
@@ -1058,7 +1060,7 @@ TYPE
 		level-, methodNumber-: LONGINT; 
 		isBodyProcedure-, isConstructor-, isFinalizer-, isInline-, isOberonInline-, isEntry-, isExit-, isFinal-, isAbstract-, isOverwritten-: BOOLEAN; 
 
-		PROCEDURE ^  & InitProcedure(position: LONGINT; name: Identifier; scope: ProcedureScope); 
+		PROCEDURE ^  & InitProcedure(position: Position; name: Identifier; scope: ProcedureScope); 
 		PROCEDURE ^ SetSuper*(super: Procedure); 
 		PROCEDURE ^ SetBodyProcedure*(isBodyProcedure: BOOLEAN); 
 		PROCEDURE ^ SetConstructor*(isConstructor: BOOLEAN); 
@@ -1080,7 +1082,7 @@ TYPE
 		nextBuiltin-: Builtin; 
 		id-: LONGINT; 
 
-		PROCEDURE ^  & InitBuiltin(position: LONGINT; name: Identifier; id: LONGINT); 
+		PROCEDURE ^  & InitBuiltin(position: Position; name: Identifier; id: LONGINT); 
 		PROCEDURE ^ Accept*(v: Visitor); 
 	END Builtin; 
 
@@ -1088,7 +1090,7 @@ TYPE
 	VAR 
 		subType-: SHORTINT; 
 
-		PROCEDURE ^  & InitCustomBuiltin(position: LONGINT; name: Identifier; id: LONGINT; subType: SHORTINT); 
+		PROCEDURE ^  & InitCustomBuiltin(position: Position; name: Identifier; id: LONGINT; subType: SHORTINT); 
 		PROCEDURE ^ CompatibleTo*(otherType: Type): BOOLEAN; 
 	END CustomBuiltin; 
 
@@ -1097,7 +1099,7 @@ TYPE
 		nextOperator-: Operator; 
 		isDynamic-: BOOLEAN; 
 
-		PROCEDURE ^  & InitOperator(position: LONGINT; name: Identifier; scope: ProcedureScope); 
+		PROCEDURE ^  & InitOperator(position: Position; name: Identifier; scope: ProcedureScope); 
 		PROCEDURE ^ SetDynamic*(isDynamic: BOOLEAN); 
 		PROCEDURE ^ Accept*(v: Visitor); 
 	END Operator; 
@@ -1110,7 +1112,7 @@ TYPE
 		context-: Identifier; 
 		direct-: BOOLEAN; 
 
-		PROCEDURE ^  & InitImport(position: LONGINT; name, moduleName: Identifier; direct: BOOLEAN); 
+		PROCEDURE ^  & InitImport(position: Position; name, moduleName: Identifier; direct: BOOLEAN); 
 		PROCEDURE ^ SetType*(type: Type); 
 		PROCEDURE ^ SetModule*(module: Module); 
 		PROCEDURE ^ SetDirect*(d: BOOLEAN); 
@@ -1138,11 +1140,11 @@ TYPE
 	Statement* = OBJECT 
 	VAR 
 		outer-: Statement; 
-		position-: LONGINT; 
+		position-: Position; 
 		isUnreachable-: BOOLEAN; 
 		comment-: Comment; 
 
-		PROCEDURE ^  & InitStatement*(position: LONGINT; outer: Statement); 
+		PROCEDURE ^  & InitStatement*(position: Position; outer: Statement); 
 		PROCEDURE ^ SetOuter*(o: Statement); 
 		PROCEDURE ^ SetUnreachable*(unreachable: BOOLEAN); 
 		PROCEDURE ^ Accept*(v: Visitor); 
@@ -1154,7 +1156,7 @@ TYPE
 	VAR 
 		call-: Designator; 
 
-		PROCEDURE ^  & InitProcedureCallStatement(position: LONGINT; call: Designator; outer: Statement); 
+		PROCEDURE ^  & InitProcedureCallStatement(position: Position; call: Designator; outer: Statement); 
 		PROCEDURE ^ SetCall*(call: Designator); 
 		PROCEDURE ^ Clone(): Statement; 
 		PROCEDURE ^ Accept*(v: Visitor); 
@@ -1165,7 +1167,7 @@ TYPE
 		left-: Designator; 
 		right-: Expression; 
 
-		PROCEDURE ^  & InitAssignment*(position: LONGINT; left: Designator; right: Expression; outer: Statement); 
+		PROCEDURE ^  & InitAssignment*(position: Position; left: Designator; right: Expression; outer: Statement); 
 		PROCEDURE ^ SetLeft*(left: Designator); 
 		PROCEDURE ^ SetRight*(right: Expression); 
 		PROCEDURE ^ Clone(): Statement; 
@@ -1178,7 +1180,7 @@ TYPE
 		right-: Expression; 
 		op-: LONGINT; 
 
-		PROCEDURE ^  & InitAssignment*(position: LONGINT; op: LONGINT; left: Designator; right: Expression; outer: Statement); 
+		PROCEDURE ^  & InitAssignment*(position: Position; op: LONGINT; left: Designator; right: Expression; outer: Statement); 
 		PROCEDURE ^ SetLeft*(left: Designator); 
 		PROCEDURE ^ SetRight*(right: Expression); 
 		PROCEDURE ^ Accept*(v: Visitor); 
@@ -1203,7 +1205,7 @@ TYPE
 		elsifParts: Basic.List; 
 		elsePart-: StatementSequence; 
 
-		PROCEDURE ^  & InitIfStatement(position: LONGINT; outer: Statement); 
+		PROCEDURE ^  & InitIfStatement(position: Position; outer: Statement); 
 		PROCEDURE ^ SetElsePart*(elsePart: StatementSequence); 
 		PROCEDURE ^ AddElsifPart*(elsifPart: IfPart); 
 		PROCEDURE ^ GetElsifPart*(i: LONGINT): IfPart; 
@@ -1232,7 +1234,7 @@ TYPE
 		withParts-: Basic.List; 
 		elsePart-: StatementSequence; 
 
-		PROCEDURE ^  & InitWithStatement(position: LONGINT; outer: Statement); 
+		PROCEDURE ^  & InitWithStatement(position: Position; outer: Statement); 
 		PROCEDURE ^ AddWithPart*(withPart: WithPart); 
 		PROCEDURE ^ GetWithPart*(i: LONGINT): WithPart; 
 		PROCEDURE ^ WithParts*(): LONGINT; 
@@ -1267,7 +1269,7 @@ TYPE
 		caseParts-: Basic.List; 
 		min-, max-: LONGINT; 
 
-		PROCEDURE ^  & InitCaseStatement(position: LONGINT; outer: Statement); 
+		PROCEDURE ^  & InitCaseStatement(position: Position; outer: Statement); 
 		PROCEDURE ^ SetVariable*(expression: Expression); 
 		PROCEDURE ^ SetElsePart*(elsePart: StatementSequence); 
 		PROCEDURE ^ AddCasePart*(casePart: CasePart); 
@@ -1284,7 +1286,7 @@ TYPE
 		condition-: Expression; 
 		statements-: StatementSequence; 
 
-		PROCEDURE ^  & InitWhileStatement(position: LONGINT; outer: Statement); 
+		PROCEDURE ^  & InitWhileStatement(position: Position; outer: Statement); 
 		PROCEDURE ^ SetCondition*(condition: Expression); 
 		PROCEDURE ^ SetStatements*(statements: StatementSequence); 
 		PROCEDURE ^ Clone(): Statement; 
@@ -1296,7 +1298,7 @@ TYPE
 		condition-: Expression; 
 		statements-: StatementSequence; 
 
-		PROCEDURE ^  & InitRepeatStatement(position: LONGINT; outer: Statement); 
+		PROCEDURE ^  & InitRepeatStatement(position: Position; outer: Statement); 
 		PROCEDURE ^ SetCondition*(condition: Expression); 
 		PROCEDURE ^ SetStatements*(statements: StatementSequence); 
 		PROCEDURE ^ Clone(): Statement; 
@@ -1309,7 +1311,7 @@ TYPE
 		from-, to-, by-: Expression; 
 		statements-: StatementSequence; 
 
-		PROCEDURE ^  & InitForStatement(position: LONGINT; outer: Statement); 
+		PROCEDURE ^  & InitForStatement(position: Position; outer: Statement); 
 		PROCEDURE ^ SetVariable*(variable: Designator); 
 		PROCEDURE ^ SetFrom*(from: Expression); 
 		PROCEDURE ^ SetTo*(to: Expression); 
@@ -1323,7 +1325,7 @@ TYPE
 	VAR 
 		statements-: StatementSequence; 
 
-		PROCEDURE ^  & InitExitableBlock(position: LONGINT; outer: Statement); 
+		PROCEDURE ^  & InitExitableBlock(position: Position; outer: Statement); 
 		PROCEDURE ^ SetStatements*(statements: StatementSequence); 
 		PROCEDURE ^ Clone(): Statement; 
 		PROCEDURE ^ Accept*(v: Visitor); 
@@ -1345,7 +1347,7 @@ TYPE
 	VAR 
 		returnValue-: Expression; 
 
-		PROCEDURE ^  & InitReturnStatement(position: LONGINT; outer: Statement); 
+		PROCEDURE ^  & InitReturnStatement(position: Position; outer: Statement); 
 		PROCEDURE ^ SetReturnValue*(returnValue: Expression); 
 		PROCEDURE ^ Clone(): Statement; 
 		PROCEDURE ^ Accept*(v: Visitor); 
@@ -1355,7 +1357,7 @@ TYPE
 	VAR 
 		condition-: Expression; 
 
-		PROCEDURE ^  & InitAwaitStatement(position: LONGINT; outer: Statement); 
+		PROCEDURE ^  & InitAwaitStatement(position: Position; outer: Statement); 
 		PROCEDURE ^ SetCondition*(condition: Expression); 
 		PROCEDURE ^ Clone(): Statement; 
 		PROCEDURE ^ Accept*(v: Visitor); 
@@ -1367,9 +1369,9 @@ TYPE
 		expression-: Expression; 
 		resolved-: BOOLEAN; 
 		nextModifier-: Modifier; 
-		position-: LONGINT; 
+		position-: Position; 
 
-		PROCEDURE ^  & InitModifier(position: LONGINT; identifier: Identifier; expression: Expression); 
+		PROCEDURE ^  & InitModifier(position: Position; identifier: Identifier; expression: Expression); 
 		PROCEDURE ^ Resolved*; 
 		PROCEDURE ^ SetExpression*(e: Expression); 
 		PROCEDURE ^ SetNext*(modifier: Modifier); 
@@ -1384,7 +1386,7 @@ TYPE
 		isUnchecked-: BOOLEAN; 
 		isUncooperative-: BOOLEAN; 
 
-		PROCEDURE ^  & InitStatementBlock(position: LONGINT; outer: Statement); 
+		PROCEDURE ^  & InitStatementBlock(position: Position; outer: Statement); 
 		PROCEDURE ^ SetRealtime*(b: BOOLEAN); 
 		PROCEDURE ^ SetUnchecked*(unchecked: BOOLEAN); 
 		PROCEDURE ^ SetUncooperative*(uncooperative: BOOLEAN); 
@@ -1401,7 +1403,7 @@ TYPE
 		inlineCode-: BinaryCode; 
 		inRules-, outRules-: StatementSequence; 
 
-		PROCEDURE ^  & InitCode(position: LONGINT; outer: Statement); 
+		PROCEDURE ^  & InitCode(position: Position; outer: Statement); 
 		PROCEDURE ^ SetSourceCode*(source: SourceCode; length: LONGINT); 
 		PROCEDURE ^ SetBinaryCode*(code: BinaryCode); 
 		PROCEDURE ^ Clone(): Statement; 
@@ -1416,7 +1418,7 @@ TYPE
 		code-: Code; 
 		isActive-, isSafe-: BOOLEAN; 
 
-		PROCEDURE ^  & InitBody(position: LONGINT; scope: ProcedureScope); 
+		PROCEDURE ^  & InitBody(position: Position; scope: ProcedureScope); 
 		PROCEDURE ^ SetActive*(active: BOOLEAN); 
 		PROCEDURE ^ SetSafe*(safe: BOOLEAN); 
 		PROCEDURE ^ SetFinally*(finally: StatementSequence); 
@@ -1426,14 +1428,14 @@ TYPE
 
 	Comment* = OBJECT 
 	VAR 
-		position-: LONGINT; 
+		position-: Position; 
 		source-: String; 
 		scope-: Scope; 
 		item-: ANY; 
 		sameLine-: BOOLEAN; 
 		nextComment-: Comment; 
 
-		PROCEDURE ^  & InitComment(pos: LONGINT; scope: Scope; CONST s: ARRAY OF CHAR; length: LONGINT); 
+		PROCEDURE ^  & InitComment(pos: Position; scope: Scope; CONST s: ARRAY OF CHAR; length: LONGINT); 
 		PROCEDURE ^ SetItem*(p: ANY; sameLine: BOOLEAN); 
 	END Comment; 
 
@@ -1573,7 +1575,7 @@ TYPE
 		closingComment-: Comment; 
 		modifiers-: Modifier; 
 
-		PROCEDURE ^  & InitModule(CONST sourceName: ARRAY OF CHAR; position: LONGINT; name: Identifier; scope: ModuleScope; case: LONGINT); 
+		PROCEDURE ^  & InitModule(CONST sourceName: ARRAY OF CHAR; position: Position; name: Identifier; scope: ModuleScope; case: LONGINT); 
 		PROCEDURE ^ SetCase*(case: LONGINT); 
 		PROCEDURE ^ SetCellNet*(isCellNet: BOOLEAN); 
 		PROCEDURE ^ SetContext*(context: Identifier); 
@@ -1603,6 +1605,7 @@ VAR
 	invalidDesignator-: Designator; 
 	invalidValue-: Value; 
 	invalidSymbol-: Symbol; 
+	invalidPosition-: Position; 
 	anonymousIdentifier-: Identifier; 
 	importType-: Type; 
 	typeDeclarationType-: Type; 
@@ -1610,14 +1613,14 @@ VAR
 	indexListSeparator-: Expression; 
 
 	PROCEDURE ^ InitFingerPrint*(VAR fingerprint: FingerPrint); 
-	PROCEDURE ^ NewModule*(CONST sourceName: ARRAY OF CHAR; position: LONGINT; name: Identifier; scope: ModuleScope; case: LONGINT): Module; 
-	PROCEDURE ^ NewComment*(position: LONGINT; scope: Scope; CONST source: ARRAY OF CHAR; length: LONGINT): Comment; 
-	PROCEDURE ^ NewImport*(position: LONGINT; alias, name: Identifier; direct: BOOLEAN): Import; 
-	PROCEDURE ^ NewConstant*(position: LONGINT; name: Identifier): Constant; 
-	PROCEDURE ^ NewProcedure*(position: LONGINT; name: Identifier; scope: ProcedureScope): Procedure; 
-	PROCEDURE ^ NewBuiltin*(position: LONGINT; name: Identifier; id: LONGINT): Builtin; 
-	PROCEDURE ^ NewCustomBuiltin*(position: LONGINT; name: Identifier; id: LONGINT; subType: SHORTINT): CustomBuiltin; 
-	PROCEDURE ^ NewOperator*(position: LONGINT; name: Identifier; scope: ProcedureScope): Operator; 
+	PROCEDURE ^ NewModule*(CONST sourceName: ARRAY OF CHAR; position: Position; name: Identifier; scope: ModuleScope; case: LONGINT): Module; 
+	PROCEDURE ^ NewComment*(position: Position; scope: Scope; CONST source: ARRAY OF CHAR; length: LONGINT): Comment; 
+	PROCEDURE ^ NewImport*(position: Position; alias, name: Identifier; direct: BOOLEAN): Import; 
+	PROCEDURE ^ NewConstant*(position: Position; name: Identifier): Constant; 
+	PROCEDURE ^ NewProcedure*(position: Position; name: Identifier; scope: ProcedureScope): Procedure; 
+	PROCEDURE ^ NewBuiltin*(position: Position; name: Identifier; id: LONGINT): Builtin; 
+	PROCEDURE ^ NewCustomBuiltin*(position: Position; name: Identifier; id: LONGINT; subType: SHORTINT): CustomBuiltin; 
+	PROCEDURE ^ NewOperator*(position: Position; name: Identifier; scope: ProcedureScope): Operator; 
 	PROCEDURE ^ NewType*(): Type; 
 	PROCEDURE ^ NewByteType*(sizeInBits: LONGINT): ByteType; 
 	PROCEDURE ^ NewAnyType*(sizeInBits: LONGINT): AnyType; 
@@ -1632,88 +1635,88 @@ VAR
 	PROCEDURE ^ NewComplexType*(base: Type): ComplexType; 
 	PROCEDURE ^ NewIntegerType*(size: LONGINT; signed: BOOLEAN): IntegerType; 
 	PROCEDURE ^ NewFloatType*(sizeInBits: LONGINT): FloatType; 
-	PROCEDURE ^ NewTypeDeclaration*(position: LONGINT; name: Identifier): TypeDeclaration; 
-	PROCEDURE ^ NewStringType*(position: LONGINT; baseType: Type; length: LONGINT): StringType; 
-	PROCEDURE ^ NewEnumerationType*(position: LONGINT; scope: Scope; enumerationScope: EnumerationScope): EnumerationType; 
-	PROCEDURE ^ NewArrayType*(position: LONGINT; scope: Scope; form: LONGINT): ArrayType; 
-	PROCEDURE ^ NewMathArrayType*(position: LONGINT; scope: Scope; form: LONGINT): MathArrayType; 
-	PROCEDURE ^ NewPointerType*(position: LONGINT; scope: Scope): PointerType; 
-	PROCEDURE ^ NewPortType*(position: LONGINT; direction: LONGINT; sizeExpression: Expression; scope: Scope): PortType; 
-	PROCEDURE ^ NewRecordType*(position: LONGINT; scope: Scope; recordScope: RecordScope): RecordType; 
-	PROCEDURE ^ NewCellType*(position: LONGINT; scope: Scope; cellScope: CellScope): CellType; 
-	PROCEDURE ^ NewProcedureType*(position: LONGINT; scope: Scope): ProcedureType; 
-	PROCEDURE ^ NewQualifiedType*(position: LONGINT; scope: Scope; qualifiedIdentifier: QualifiedIdentifier): QualifiedType; 
+	PROCEDURE ^ NewTypeDeclaration*(position: Position; name: Identifier): TypeDeclaration; 
+	PROCEDURE ^ NewStringType*(position: Position; baseType: Type; length: LONGINT): StringType; 
+	PROCEDURE ^ NewEnumerationType*(position: Position; scope: Scope; enumerationScope: EnumerationScope): EnumerationType; 
+	PROCEDURE ^ NewArrayType*(position: Position; scope: Scope; form: LONGINT): ArrayType; 
+	PROCEDURE ^ NewMathArrayType*(position: Position; scope: Scope; form: LONGINT): MathArrayType; 
+	PROCEDURE ^ NewPointerType*(position: Position; scope: Scope): PointerType; 
+	PROCEDURE ^ NewPortType*(position: Position; direction: LONGINT; sizeExpression: Expression; scope: Scope): PortType; 
+	PROCEDURE ^ NewRecordType*(position: Position; scope: Scope; recordScope: RecordScope): RecordType; 
+	PROCEDURE ^ NewCellType*(position: Position; scope: Scope; cellScope: CellScope): CellType; 
+	PROCEDURE ^ NewProcedureType*(position: Position; scope: Scope): ProcedureType; 
+	PROCEDURE ^ NewQualifiedType*(position: Position; scope: Scope; qualifiedIdentifier: QualifiedIdentifier): QualifiedType; 
 	PROCEDURE ^ NewSymbol*(name: Identifier): Symbol; 
-	PROCEDURE ^ NewVariable*(position: LONGINT; name: Identifier): Variable; 
-	PROCEDURE ^ NewQualifiedIdentifier*(position: LONGINT; prefix, suffix: Identifier): QualifiedIdentifier; 
+	PROCEDURE ^ NewVariable*(position: Position; name: Identifier): Variable; 
+	PROCEDURE ^ NewQualifiedIdentifier*(position: Position; prefix, suffix: Identifier): QualifiedIdentifier; 
 	PROCEDURE ^ NewIdentifier*(CONST name: ARRAY OF CHAR): Identifier; 
-	PROCEDURE ^ NewParameter*(position: LONGINT; ownerType: Type; name: Identifier; passAs: LONGINT): Parameter; 
-	PROCEDURE ^ NewProperty*(position: LONGINT; name: Identifier): Property; 
+	PROCEDURE ^ NewParameter*(position: Position; ownerType: Type; name: Identifier; passAs: LONGINT): Parameter; 
+	PROCEDURE ^ NewProperty*(position: Position; name: Identifier): Property; 
 	PROCEDURE ^ NewExpressionList*(): ExpressionList; 
 	PROCEDURE ^ CloneExpressionList*(l: ExpressionList): ExpressionList; 
 	PROCEDURE ^ NewDesignator*(): Designator; 
-	PROCEDURE ^ NewIdentifierDesignator*(position: LONGINT; identifier: Identifier): IdentifierDesignator; 
-	PROCEDURE ^ NewSelectorDesignator*(position: LONGINT; left: Designator; name: Identifier): SelectorDesignator; 
-	PROCEDURE ^ NewParameterDesignator*(position: LONGINT; left: Designator; expressionList: ExpressionList): ParameterDesignator; 
-	PROCEDURE ^ NewArrowDesignator*(position: LONGINT; left: Designator): ArrowDesignator; 
-	PROCEDURE ^ NewBracketDesignator*(position: LONGINT; left: Designator; expressionList: ExpressionList): BracketDesignator; 
-	PROCEDURE ^ NewSymbolDesignator*(position: LONGINT; left: Designator; symbol: Symbol): SymbolDesignator; 
-	PROCEDURE ^ NewIndexDesignator*(position: LONGINT; left: Designator): IndexDesignator; 
-	PROCEDURE ^ NewProcedureCallDesignator*(position: LONGINT; left: Designator; parameters: ExpressionList): ProcedureCallDesignator; 
-	PROCEDURE ^ NewBuiltinCallDesignator*(position: LONGINT; id: LONGINT; left: Designator; parameters: ExpressionList): BuiltinCallDesignator; 
-	PROCEDURE ^ NewTypeGuardDesignator*(position: LONGINT; left: Designator; type: Type): TypeGuardDesignator; 
-	PROCEDURE ^ NewDereferenceDesignator*(position: LONGINT; left: Designator): DereferenceDesignator; 
-	PROCEDURE ^ NewSupercallDesignator*(position: LONGINT; left: Designator): SupercallDesignator; 
-	PROCEDURE ^ NewSelfDesignator*(position: LONGINT): SelfDesignator; 
-	PROCEDURE ^ NewResultDesignator*(position: LONGINT): ResultDesignator; 
+	PROCEDURE ^ NewIdentifierDesignator*(position: Position; identifier: Identifier): IdentifierDesignator; 
+	PROCEDURE ^ NewSelectorDesignator*(position: Position; left: Designator; name: Identifier): SelectorDesignator; 
+	PROCEDURE ^ NewParameterDesignator*(position: Position; left: Designator; expressionList: ExpressionList): ParameterDesignator; 
+	PROCEDURE ^ NewArrowDesignator*(position: Position; left: Designator): ArrowDesignator; 
+	PROCEDURE ^ NewBracketDesignator*(position: Position; left: Designator; expressionList: ExpressionList): BracketDesignator; 
+	PROCEDURE ^ NewSymbolDesignator*(position: Position; left: Designator; symbol: Symbol): SymbolDesignator; 
+	PROCEDURE ^ NewIndexDesignator*(position: Position; left: Designator): IndexDesignator; 
+	PROCEDURE ^ NewProcedureCallDesignator*(position: Position; left: Designator; parameters: ExpressionList): ProcedureCallDesignator; 
+	PROCEDURE ^ NewBuiltinCallDesignator*(position: Position; id: LONGINT; left: Designator; parameters: ExpressionList): BuiltinCallDesignator; 
+	PROCEDURE ^ NewTypeGuardDesignator*(position: Position; left: Designator; type: Type): TypeGuardDesignator; 
+	PROCEDURE ^ NewDereferenceDesignator*(position: Position; left: Designator): DereferenceDesignator; 
+	PROCEDURE ^ NewSupercallDesignator*(position: Position; left: Designator): SupercallDesignator; 
+	PROCEDURE ^ NewSelfDesignator*(position: Position): SelfDesignator; 
+	PROCEDURE ^ NewResultDesignator*(position: Position): ResultDesignator; 
 	PROCEDURE ^ NewExpression*(): Expression; 
 	PROCEDURE ^ CloneExpression*(e: Expression): Expression; 
 	PROCEDURE ^ CloneDesignator*(e: Expression): Designator; 
-	PROCEDURE ^ NewElement*(position: LONGINT; from, to: Expression): Expression; 
-	PROCEDURE ^ NewSet*(position: LONGINT): Set; 
-	PROCEDURE ^ NewMathArrayExpression*(position: LONGINT): MathArrayExpression; 
-	PROCEDURE ^ NewBinaryExpression*(position: LONGINT; left, right: Expression; operator: LONGINT): BinaryExpression; 
-	PROCEDURE ^ NewRangeExpression*(position: LONGINT; first, last, step: Expression): RangeExpression; 
-	PROCEDURE ^ NewTensorRangeExpression*(position: LONGINT): TensorRangeExpression; 
-	PROCEDURE ^ NewUnaryExpression*(position: LONGINT; operand: Expression; operator: LONGINT): UnaryExpression; 
-	PROCEDURE ^ NewConversion*(position: LONGINT; expression: Expression; type: Type; typeExpression: Expression): Conversion; 
+	PROCEDURE ^ NewElement*(position: Position; from, to: Expression): Expression; 
+	PROCEDURE ^ NewSet*(position: Position): Set; 
+	PROCEDURE ^ NewMathArrayExpression*(position: Position): MathArrayExpression; 
+	PROCEDURE ^ NewBinaryExpression*(position: Position; left, right: Expression; operator: LONGINT): BinaryExpression; 
+	PROCEDURE ^ NewRangeExpression*(position: Position; first, last, step: Expression): RangeExpression; 
+	PROCEDURE ^ NewTensorRangeExpression*(position: Position): TensorRangeExpression; 
+	PROCEDURE ^ NewUnaryExpression*(position: Position; operand: Expression; operator: LONGINT): UnaryExpression; 
+	PROCEDURE ^ NewConversion*(position: Position; expression: Expression; type: Type; typeExpression: Expression): Conversion; 
 	PROCEDURE ^ NewValue*(): Value; 
-	PROCEDURE ^ NewIntegerValue*(position: LONGINT; value: HUGEINT): IntegerValue; 
-	PROCEDURE ^ NewCharacterValue*(position: LONGINT; value: CHAR): CharacterValue; 
-	PROCEDURE ^ NewSetValue*(position: LONGINT; value: SET): SetValue; 
-	PROCEDURE ^ NewMathArrayValue*(position: LONGINT): MathArrayValue; 
-	PROCEDURE ^ NewRealValue*(position: LONGINT; value: LONGREAL): RealValue; 
-	PROCEDURE ^ NewComplexValue*(position: LONGINT; realValue, imagValue: LONGREAL): ComplexValue; 
-	PROCEDURE ^ NewStringValue*(position: LONGINT; value: String): StringValue; 
-	PROCEDURE ^ NewBooleanValue*(position: LONGINT; value: BOOLEAN): BooleanValue; 
-	PROCEDURE ^ NewNilValue*(position: LONGINT): NilValue; 
-	PROCEDURE ^ NewEnumerationValue*(position: LONGINT; value: LONGINT): EnumerationValue; 
+	PROCEDURE ^ NewIntegerValue*(position: Position; value: HUGEINT): IntegerValue; 
+	PROCEDURE ^ NewCharacterValue*(position: Position; value: CHAR): CharacterValue; 
+	PROCEDURE ^ NewSetValue*(position: Position; value: SET): SetValue; 
+	PROCEDURE ^ NewMathArrayValue*(position: Position): MathArrayValue; 
+	PROCEDURE ^ NewRealValue*(position: Position; value: LONGREAL): RealValue; 
+	PROCEDURE ^ NewComplexValue*(position: Position; realValue, imagValue: LONGREAL): ComplexValue; 
+	PROCEDURE ^ NewStringValue*(position: Position; value: String): StringValue; 
+	PROCEDURE ^ NewBooleanValue*(position: Position; value: BOOLEAN): BooleanValue; 
+	PROCEDURE ^ NewNilValue*(position: Position): NilValue; 
+	PROCEDURE ^ NewEnumerationValue*(position: Position; value: LONGINT): EnumerationValue; 
 	PROCEDURE ^ NewStatement*(outer: Statement): Statement; 
 	PROCEDURE ^ CloneStatement*(statement: Statement): Statement; 
 	PROCEDURE ^ NewStatementSequence*(): StatementSequence; 
 	PROCEDURE ^ CloneStatementSequence*(statementSequence: StatementSequence): StatementSequence; 
-	PROCEDURE ^ NewModifier*(position: LONGINT; identifier: Identifier; expression: Expression): Modifier; 
-	PROCEDURE ^ NewStatementBlock*(position: LONGINT; outer: Statement): StatementBlock; 
-	PROCEDURE ^ NewStatementDesignator*(position: LONGINT; s: Statement): StatementDesignator; 
-	PROCEDURE ^ NewBody*(position: LONGINT; scope: ProcedureScope): Body; 
+	PROCEDURE ^ NewModifier*(position: Position; identifier: Identifier; expression: Expression): Modifier; 
+	PROCEDURE ^ NewStatementBlock*(position: Position; outer: Statement): StatementBlock; 
+	PROCEDURE ^ NewStatementDesignator*(position: Position; s: Statement): StatementDesignator; 
+	PROCEDURE ^ NewBody*(position: Position; scope: ProcedureScope): Body; 
 	PROCEDURE ^ NewIfPart*(): IfPart; 
-	PROCEDURE ^ NewIfStatement*(position: LONGINT; outer: Statement): IfStatement; 
-	PROCEDURE ^ NewAssignment*(position: LONGINT; left: Designator; right: Expression; outer: Statement): Assignment; 
-	PROCEDURE ^ NewCommunicationStatement*(position: LONGINT; op: LONGINT; left: Designator; right: Expression; outer: Statement): CommunicationStatement; 
-	PROCEDURE ^ NewProcedureCallStatement*(position: LONGINT; call: Designator; outer: Statement): ProcedureCallStatement; 
-	PROCEDURE ^ NewCaseStatement*(position: LONGINT; outer: Statement): CaseStatement; 
+	PROCEDURE ^ NewIfStatement*(position: Position; outer: Statement): IfStatement; 
+	PROCEDURE ^ NewAssignment*(position: Position; left: Designator; right: Expression; outer: Statement): Assignment; 
+	PROCEDURE ^ NewCommunicationStatement*(position: Position; op: LONGINT; left: Designator; right: Expression; outer: Statement): CommunicationStatement; 
+	PROCEDURE ^ NewProcedureCallStatement*(position: Position; call: Designator; outer: Statement): ProcedureCallStatement; 
+	PROCEDURE ^ NewCaseStatement*(position: Position; outer: Statement): CaseStatement; 
 	PROCEDURE ^ NewCasePart*(): CasePart; 
 	PROCEDURE ^ NewWithPart*(): WithPart; 
-	PROCEDURE ^ NewWithStatement*(position: LONGINT; outer: Statement): WithStatement; 
-	PROCEDURE ^ NewWhileStatement*(position: LONGINT; outer: Statement): WhileStatement; 
-	PROCEDURE ^ NewRepeatStatement*(position: LONGINT; outer: Statement): RepeatStatement; 
-	PROCEDURE ^ NewForStatement*(position: LONGINT; outer: Statement): ForStatement; 
-	PROCEDURE ^ NewLoopStatement*(position: LONGINT; outer: Statement): LoopStatement; 
-	PROCEDURE ^ NewExitableBlock*(position: LONGINT; outer: Statement): ExitableBlock; 
-	PROCEDURE ^ NewExitStatement*(position: LONGINT; outer: Statement): ExitStatement; 
-	PROCEDURE ^ NewReturnStatement*(position: LONGINT; outer: Statement): ReturnStatement; 
-	PROCEDURE ^ NewAwaitStatement*(position: LONGINT; outer: Statement): AwaitStatement; 
-	PROCEDURE ^ NewCode*(position: LONGINT; outer: Statement): Code; 
+	PROCEDURE ^ NewWithStatement*(position: Position; outer: Statement): WithStatement; 
+	PROCEDURE ^ NewWhileStatement*(position: Position; outer: Statement): WhileStatement; 
+	PROCEDURE ^ NewRepeatStatement*(position: Position; outer: Statement): RepeatStatement; 
+	PROCEDURE ^ NewForStatement*(position: Position; outer: Statement): ForStatement; 
+	PROCEDURE ^ NewLoopStatement*(position: Position; outer: Statement): LoopStatement; 
+	PROCEDURE ^ NewExitableBlock*(position: Position; outer: Statement): ExitableBlock; 
+	PROCEDURE ^ NewExitStatement*(position: Position; outer: Statement): ExitStatement; 
+	PROCEDURE ^ NewReturnStatement*(position: Position; outer: Statement): ReturnStatement; 
+	PROCEDURE ^ NewAwaitStatement*(position: Position; outer: Statement): AwaitStatement; 
+	PROCEDURE ^ NewCode*(position: Position; outer: Statement): Code; 
 	PROCEDURE ^ NewProcedureScope*(outer: Scope): ProcedureScope; 
 	PROCEDURE ^ NewModuleScope*(): ModuleScope; 
 	PROCEDURE ^ NewRecordScope*(outer: Scope): RecordScope; 

WinAos/obg/FoxTRMAssembler.SymW

@@ -1,5 +1,5 @@
 MODULE FoxTRMAssembler;
-	IMPORT InstructionSet := FoxTRMInstructionSet, FoxAssembler, D := Debugging, Scanner := FoxScanner, Diagnostics;
+	IMPORT InstructionSet := FoxTRMInstructionSet, FoxAssembler, D := Debugging, Scanner := FoxScanner, Diagnostics, Basic := FoxBasic;
 CONST 
 	Trace = FoxAssembler.Trace; 
 TYPE