Fixed leading whitespace

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

source/AMD64.UsbKeyboard.Mod

@@ -173,7 +173,7 @@ TYPE
 	VAR
 		pipe : Usbdi.Pipe;
 
- 		(* buffer[0] : modifier byte					*)
+		(* buffer[0] : modifier byte					*)
 		(* buffer[1] : reserved						*)
 		(* buffer[2]-buffer[7] : 6 one byte key codes  	*)
 		buffer : Usbdi.BufferPtr;

source/AMD64.WMRasterScale.Mod

@@ -1386,11 +1386,11 @@ endofloop47:
 	; dred18f = dred18big && destMaskred128  because >> 11 and << 11 is && mask
 	PAND 		XMM7, XMM6 ; dred18f
 
- 	; dest18nr0 = dest18 && (~destMaskred128)
- 	PANDN 	XMM6, XMM3  				; dest18nr0
+	; dest18nr0 = dest18 && (~destMaskred128)
+	PANDN 	XMM6, XMM3  				; dest18nr0
 
- 	; dest18nrf = dest18nr0 || dred18f
- 	POR 		XMM6, XMM7
+	; dest18nrf = dest18nr0 || dred18f
+	POR 		XMM6, XMM7
 
 	MOVDQU 	XMM3, XMM6
 
@@ -1454,10 +1454,10 @@ endofloop47:
 	PSRLW 		XMM7, 10 					; dgreen18f
 	PSLLW 		XMM7, 5
 
- 	; dest18ng0 = dest18 && (~destMaskgreen128)
+	; dest18ng0 = dest18 && (~destMaskgreen128)
 
- 	; dest18ngf = dest18ng0 || dred18f
- 	POR 		XMM6, XMM7
+	; dest18ngf = dest18ng0 || dred18f
+	POR 		XMM6, XMM7
 	MOVDQU 	XMM3, XMM6
 	; green is calculated
 
@@ -1513,12 +1513,12 @@ endofloop47:
 	PADDUSW 	XMM7, XMM5 				; dblue18big
 	; dblue18f = (dblue18big >> 11)
 	PANDN 	XMM6, XMM3  				; dest18nr0
- 	PSRLW 		XMM7, 11 					; dblue18f
+	PSRLW 		XMM7, 11 					; dblue18f
 
   	; dest18nr0 = dest18 && (~destMaskblue128)
 
- 	; dest18nbf = dest18nb0 || dblue18f
- 	POR 		XMM6, XMM7
+	; dest18nbf = dest18nb0 || dblue18f
+	POR 		XMM6, XMM7
 	MOVDQU 	XMM3, XMM6
 
 	; blue is calculated
@@ -2334,10 +2334,10 @@ alleightpixels:
 	PAND 		XMM7, XMM6 			; dred18f
 
   	; dest18nr0 = dest18 && (~destMaskred128)
- 	PANDN 	XMM6, XMM3  			; dest18nr0
+	PANDN 	XMM6, XMM3  			; dest18nr0
 
- 	 ; dest18nrf = dest18nr0 || dred18f
- 	POR 		XMM6, XMM7
+	 ; dest18nrf = dest18nr0 || dred18f
+	POR 		XMM6, XMM7
 
 	MOVDQU 	XMM3, XMM6
 
@@ -2405,8 +2405,8 @@ alleightpixels:
 
   	; dest18ng0 = dest18 && (~destMaskgreen128)
 
- 	 ; dest18ngf = dest18ng0 || dred18f
- 	POR 		XMM6, XMM7
+	 ; dest18ngf = dest18ng0 || dred18f
+	POR 		XMM6, XMM7
 	MOVDQU 	XMM3, XMM6
 	; green is calculated
 
@@ -2458,12 +2458,12 @@ alleightpixels:
 	 PADDUSW 	XMM7, XMM5 			; dblue18big
 	; dblue18f = (dblue18big >> 11)
 	PANDN 	XMM6, XMM3  			; dest18nr0
- 	PSRLW 		XMM7, 11 				; dblue18f
+	PSRLW 		XMM7, 11 				; dblue18f
 
- 	; dest18nr0 = dest18 && (~destMaskblue128)
+	; dest18nr0 = dest18 && (~destMaskblue128)
 
   	; dest18nbf = dest18nb0 || dblue18f
- 	POR 		XMM6, XMM7
+	POR 		XMM6, XMM7
 	MOVDQU 	XMM3, XMM6
 
 	; blue is calculated

source/ARM.Machine.Mod

@@ -1758,7 +1758,7 @@ VAR
 			dummyIRQHandler[int].h := h;
 		END;
 
- 		IF (int >= MinIRQ) & (int <= MaxIRQ) THEN InEnableIRQ(int) END;
+		IF (int >= MinIRQ) & (int <= MaxIRQ) THEN InEnableIRQ(int) END;
 
 		Release(Interrupts);
 

source/ARM.Objects.Mod

@@ -140,33 +140,33 @@ TYPE
 					IF pc # 0 THEN 	(* process is running already *)
 						WHILE (bp # Heaps.NilVal) & (stack.adr <= bp) & (bp < stack.high) DO
 							FindPointers(bp, pc, d0, d1);
- 							IF first THEN
- 								IF (d0 = 0) OR (d0 = 1) OR (d1 = 3) THEN
- 									(* 	situation where pc and bp are not synchronized: *)
- 									(* 	entry protocol of a procedure:
- 										PUSH 	EBP			-- 1 byte instruction length, if pc points to this instruction at offset 0 from the codeoffset then bp still refers to caller frame -> critical
- 										MOV	EBP, ESP	-- 2 bytes instruction length, do. for offset 1 from the codeoffset
- 										(followed by initialization of local variables)
- 										exit protocol of a procedure:
- 										MOV	ESP, EBP	-- 2 bytes instruction length
- 										POP	EBP			-- 1 byte instruction length
- 										RET		n			-- 3 bytes instruction length, if pc points to this instruction at offset 3 from the last statement then bp already refers to caller's frame -> critical
- 									*)
- 									IF (d0 = 0) OR (d1 = 3) THEN
- 										SYSTEM.GET(state.SP, pc);		(* matching pc is at position of stack pointer *)
- 									ELSE
- 										SYSTEM.GET(state.SP+AddressSize, pc);		(* matching pc is at 4 bytes after stack pointer, pushed base pointer is at stack pointer position *)
+							IF first THEN
+								IF (d0 = 0) OR (d0 = 1) OR (d1 = 3) THEN
+									(* 	situation where pc and bp are not synchronized: *)
+									(* 	entry protocol of a procedure:
+										PUSH 	EBP			-- 1 byte instruction length, if pc points to this instruction at offset 0 from the codeoffset then bp still refers to caller frame -> critical
+										MOV	EBP, ESP	-- 2 bytes instruction length, do. for offset 1 from the codeoffset
+										(followed by initialization of local variables)
+										exit protocol of a procedure:
+										MOV	ESP, EBP	-- 2 bytes instruction length
+										POP	EBP			-- 1 byte instruction length
+										RET		n			-- 3 bytes instruction length, if pc points to this instruction at offset 3 from the last statement then bp already refers to caller's frame -> critical
+									*)
+									IF (d0 = 0) OR (d1 = 3) THEN
+										SYSTEM.GET(state.SP, pc);		(* matching pc is at position of stack pointer *)
+									ELSE
+										SYSTEM.GET(state.SP+AddressSize, pc);		(* matching pc is at 4 bytes after stack pointer, pushed base pointer is at stack pointer position *)
 									END;
- 								ELSE
- 									(* regular case: bp and pc were synchronized *)
- 									curbp := bp;
+								ELSE
+									(* regular case: bp and pc were synchronized *)
+									curbp := bp;
 									SYSTEM.GET(curbp, bp);
 									SYSTEM.GET(curbp+AddressSize, pc);
- 								END;
- 								first := FALSE;
- 							ELSE
- 								(* regular case: bp and pc were synchronized *)
- 								curbp := bp;
+								END;
+								first := FALSE;
+							ELSE
+								(* regular case: bp and pc were synchronized *)
+								curbp := bp;
 								SYSTEM.GET(curbp, bp);
 								SYSTEM.GET(curbp+AddressSize, pc);
 							END
@@ -1708,9 +1708,9 @@ BEGIN (* interrupts off *)
 	t := running[Machine.ID ()];
 	ASSERT(t # NIL);
 	IF t # NIL THEN
- 		t.state.PC := Machine.CurrentPC(); (* ug: required information for GC with meta data for stack inspection *)
- 		t.state.SP := SYSTEM.GetStackPointer(); (* ug: not necessarily needed for GC *)
- 		t.state.BP := SYSTEM.GetFramePointer(); (* ug: necessary information for GC with meta data for stack inspection *)
+		t.state.PC := Machine.CurrentPC(); (* ug: required information for GC with meta data for stack inspection *)
+		t.state.SP := SYSTEM.GetStackPointer(); (* ug: not necessarily needed for GC *)
+		t.state.BP := SYSTEM.GetFramePointer(); (* ug: necessary information for GC with meta data for stack inspection *)
 	END;
 	Machine.Release(Machine.Objects)
 END UpdateState;

source/ARM.UsbEhci.Mod

@@ -105,7 +105,7 @@ CONST
 	StsReclamation * = {13};
 	StsHcHalted * = {12};
 	(* HcUsbSts & HcUsbIntr common fields *)
- 	StsAsyncAdvance * = {5};
+	StsAsyncAdvance * = {5};
 	StsHostSystemError * = {4};
 	StsFrameListRollover * = {3};
 	StsPortChange * = {2};
@@ -3117,7 +3117,7 @@ END ShowItd;
 PROCEDURE ShowInterrupts * (s : SET);
 BEGIN
 	IF Debug.Trace THEN
- 	IF s * StsAsyncAdvance # {} THEN KernelLog.String("[AsyncAdvance]"); END;
+	IF s * StsAsyncAdvance # {} THEN KernelLog.String("[AsyncAdvance]"); END;
 	IF s * StsHostSystemError # {} THEN KernelLog.String("[HostSystemError]"); END;
 	IF s * StsFrameListRollover # {} THEN KernelLog.String("[FrameListRollover]"); END;
 	IF s * StsPortChange # {} THEN KernelLog.String("[PortChange]"); END;

source/ARM.UsbHcdi.Mod

@@ -1041,7 +1041,7 @@ TYPE
 
 			lock.Acquire;
 			transfer.id := nextId; INC(nextId);
- 			IF transfers = NIL THEN
+			IF transfers = NIL THEN
 				transfers := transfer
 			ELSE
 				lastTransfer.next := transfer

source/ARM.UsbKeyboard.Mod

@@ -174,7 +174,7 @@ TYPE
 	VAR
 		pipe : Usbdi.Pipe;
 
- 		(* buffer[0] : modifier byte					*)
+		(* buffer[0] : modifier byte					*)
 		(* buffer[1] : reserved						*)
 		(* buffer[2]-buffer[7] : 6 one byte key codes  	*)
 		buffer : Usbdi.BufferPtr;

source/ARM.WMRasterScale.Mod

@@ -1109,11 +1109,11 @@ endofloop47:
 	; dred18f = dred18big && destMaskred128  because >> 11 and << 11 is && mask
 	PAND 		XMM7, XMM6 ; dred18f
 
- 	; dest18nr0 = dest18 && (~destMaskred128)
- 	PANDN 	XMM6, XMM3  				; dest18nr0
+	; dest18nr0 = dest18 && (~destMaskred128)
+	PANDN 	XMM6, XMM3  				; dest18nr0
 
- 	; dest18nrf = dest18nr0 || dred18f
- 	POR 		XMM6, XMM7
+	; dest18nrf = dest18nr0 || dred18f
+	POR 		XMM6, XMM7
 
 	MOVDQU 	XMM3, XMM6
 
@@ -1177,10 +1177,10 @@ endofloop47:
 	PSRLW 		XMM7, 10 					; dgreen18f
 	PSLLW 		XMM7, 5
 
- 	; dest18ng0 = dest18 && (~destMaskgreen128)
+	; dest18ng0 = dest18 && (~destMaskgreen128)
 
- 	; dest18ngf = dest18ng0 || dred18f
- 	POR 		XMM6, XMM7
+	; dest18ngf = dest18ng0 || dred18f
+	POR 		XMM6, XMM7
 	MOVDQU 	XMM3, XMM6
 	; green is calculated
 
@@ -1236,12 +1236,12 @@ endofloop47:
 	PADDUSW 	XMM7, XMM5 				; dblue18big
 	; dblue18f = (dblue18big >> 11)
 	PANDN 	XMM6, XMM3  				; dest18nr0
- 	PSRLW 		XMM7, 11 					; dblue18f
+	PSRLW 		XMM7, 11 					; dblue18f
 
   	; dest18nr0 = dest18 && (~destMaskblue128)
 
- 	; dest18nbf = dest18nb0 || dblue18f
- 	POR 		XMM6, XMM7
+	; dest18nbf = dest18nb0 || dblue18f
+	POR 		XMM6, XMM7
 	MOVDQU 	XMM3, XMM6
 
 	; blue is calculated

source/ARMDecoder.Mod

@@ -578,7 +578,7 @@ TYPE
 					RETURN
 				END
 			END;
- 			CASE category OF
+			CASE category OF
 				0 :
 					IF (opSet * {4, 7}) = {4, 7} THEN
 						MultipliesExtraLS(armOpcode)
@@ -947,7 +947,7 @@ BEGIN
 END SetLittleEndian;
 
 PROCEDURE Hex(n: LONGINT; w : Streams.Writer); (* procedure from PCARMDecoder.Mod *)
- 	VAR i, j: INTEGER; s, t : ARRAY 10 OF CHAR;
+	VAR i, j: INTEGER; s, t : ARRAY 10 OF CHAR;
 BEGIN
 	i := 0;
 	REPEAT

source/ASMAMD64.Mod

@@ -3418,7 +3418,6 @@ BEGIN
 	Mnem ("XORPS");	(* 585 *)
 	Instr (xmm, xmmmem128, none, "0F57/r", {}, {cpuKatmai, cpuSSE});	(* 1380 *)
 
-
 	Reg ("AL", reg8, 0);
 	Reg ("CL", reg8, 1);
 	Reg ("DL", reg8, 2);

source/ASN1.Mod

@@ -199,7 +199,8 @@ BEGIN
 	IF Trace & (log#NIL) THEN log.Char("{");  log.Hex(ORD(c),0);log.Char("H"); log.Char("}"); END;
 	t.class:= ORD(c) DIV 64;
 	t.constructed:= ODD (ORD(c) DIV 32);
-	IF ORD(c) MOD 32#31 THEN 	t.tag:=ORD(c) MOD 64; (* 'constructed' bit included *)
+	IF ORD(c) MOD 32#31 THEN
+		t.tag:=ORD(c) MOD 64; (* 'constructed' bit included *)
 	ELSE
 		REPEAT
 			reader.Char(c); INC(len); INC(hdrlen);
@@ -222,8 +223,8 @@ BEGIN
 	| Boolean: reader.Char(c);INC(len); t.bvalue:=c#0X;
 	| Integer:
 		IF t.length<=4 THEN
-			 NEW(t.svalue,t.length);
-			 FOR i:=0 TO t.length-1 DO
+			NEW(t.svalue,t.length);
+			FOR i:=0 TO t.length-1 DO
 					t.ivalue:=256*t.ivalue;
 					reader.Char(c); INC(len);
 					t.svalue[i]:=c;

source/AVI.Mod

@@ -274,7 +274,7 @@ IMPORT
 
 			IF in IS Codecs.FileInputStream	THEN
 				in(Codecs.FileInputStream).f.GetName(filename);
-				IF ReadHeader() THEN res := Codecs.ResOk 	END
+				IF ReadHeader() THEN res := Codecs.ResOk END
 			ELSE RETURN END;													(* bad bad bad *)
 
 		END Open;
@@ -410,19 +410,19 @@ IMPORT
 						END;
 					ELSIF CompareCharArrays(buf, "movi",4) THEN
 						(* movie data begin, including movi Tag *)
- 						movieBeginPos := r.Pos()-4;
+						movieBeginPos := r.Pos()-4;
 
- 						(* this could be improved... *)
- 						r.SetPos(headerLength+movieBeginPos);			(* headerLength); *)
+						(* this could be improved... *)
+						r.SetPos(headerLength+movieBeginPos);			(* headerLength); *)
 
 						r.Bytes(buf,0,4,len);
 
- 						IF CompareCharArrays(buf, "idx1",4) THEN
- 							(* There is an index *)
+						IF CompareCharArrays(buf, "idx1",4) THEN
+							(* There is an index *)
 
- 							(* Start of Index including idx1 Tag *)
- 							indexStart := r.Pos()-4;
- 							ReadIndex();
+							(* Start of Index including idx1 Tag *)
+							indexStart := r.Pos()-4;
+							ReadIndex();
 							IF Debug THEN
 								KernelLog.String("AVIDemux: Start of movie stream found " ); KernelLog.Ln()
 							END;
@@ -474,128 +474,128 @@ IMPORT
 			ioff: LONGINT;
 
 		BEGIN
- 			r.RawLInt(indexLength);
-
- 			nidx := indexLength DIV 16;
- 			idxType := 0;
- 			i := 0;
- 			LOOP
- 				r.Bytes(buf, 0, 4, len);
- 				IF CompareCharArrays(buf, videoStreamHeader.streamIdentifier, 3) THEN
- 					i := i+1;
- 					(* Not shure, wether this is necessary - but everything works fine with it *)
- 					indexStart := r.Pos()-4;
- 					EXIT;
- 				END;
- 				IF i >= nidx THEN
- 					KernelLog.String("No Index found"); KernelLog.Ln();
- 					EXIT;
- 				END;
- 			END;
-
- 			r.SkipBytes(4);
- 			r.RawLInt(pos);
- 			r.RawLInt(length);
- 			r.SetPos(pos);
-
- 			(* Index from start of File*)
- 			IF CompareCharArrays(buf2, buf, 4) THEN
- 				r.RawLInt(temp);
-
- 				IF (temp = length) THEN
- 					idxType := 1;
- 				END;
- 			ELSE
- 				r.SetPos(pos + movieBeginPos);
-
- 				r.Bytes(buf2, 0, 4, len);
- 				IF CompareCharArrays(buf2, buf, 4) THEN
- 					r.RawLInt(temp);
-
- 					IF (temp = length) THEN
- 						idxType := 2;
- 					END;
- 				END;
- 			END;
-
- 			(* now go on according to indexType *)
- 			IF idxType = 0 THEN
- 				KernelLog.String("File without index: Not supported yet");
- 				(* And trap here ... *)
- 			END;
-
- 			(* The 0 case: no index. It is possible to generate an index b y traversing the whole file 	*)
- 			(* For now we simply declare the file as not seekable										*)
-
- 			IF idxType # 0 THEN
- 				nai := 0;
- 				nvi := 0;
-
- 				r.SetPos(indexStart);
-
- 				i := 0;
- 				(* Count, how many entries there are (the number would also be in the header, 	*)
- 				(* but if there is no index, you have to do this anyway)							*)
- 				REPEAT
- 					r.Bytes(buf, 0, 4, len);
- 					IF CompareCharArrays(buf, videoStreamHeader.streamIdentifier, 3) THEN
- 						nvi := nvi+1;
- 					ELSE
- 						IF audioStreamHeader # NIL THEN
- 							IF CompareCharArrays(buf, audioStreamHeader.streamIdentifier, 4) THEN
- 								nai := nai+1;
- 							END;
- 						END;
- 					END;
- 					r.SkipBytes(12);
- 					i := i+1;
- 				UNTIL (i = nidx-1);
-
- 				videoFrames := nvi;
- 				audioChunks := nai;
+			r.RawLInt(indexLength);
+
+			nidx := indexLength DIV 16;
+			idxType := 0;
+			i := 0;
+			LOOP
+				r.Bytes(buf, 0, 4, len);
+				IF CompareCharArrays(buf, videoStreamHeader.streamIdentifier, 3) THEN
+					i := i+1;
+					(* Not shure, wether this is necessary - but everything works fine with it *)
+					indexStart := r.Pos()-4;
+					EXIT;
+				END;
+				IF i >= nidx THEN
+					KernelLog.String("No Index found"); KernelLog.Ln();
+					EXIT;
+				END;
+			END;
+
+			r.SkipBytes(4);
+			r.RawLInt(pos);
+			r.RawLInt(length);
+			r.SetPos(pos);
+
+			(* Index from start of File*)
+			IF CompareCharArrays(buf2, buf, 4) THEN
+				r.RawLInt(temp);
+
+				IF (temp = length) THEN
+					idxType := 1;
+				END;
+			ELSE
+				r.SetPos(pos + movieBeginPos);
+
+				r.Bytes(buf2, 0, 4, len);
+				IF CompareCharArrays(buf2, buf, 4) THEN
+					r.RawLInt(temp);
+
+					IF (temp = length) THEN
+						idxType := 2;
+					END;
+				END;
+			END;
+
+			(* now go on according to indexType *)
+			IF idxType = 0 THEN
+				KernelLog.String("File without index: Not supported yet");
+				(* And trap here ... *)
+			END;
+
+			(* The 0 case: no index. It is possible to generate an index b y traversing the whole file *)
+			(* For now we simply declare the file as not seekable *)
+
+			IF idxType # 0 THEN
+				nai := 0;
+				nvi := 0;
+
+				r.SetPos(indexStart);
+
+				i := 0;
+				(* Count, how many entries there are (the number would also be in the header, *)
+				(* but if there is no index, you have to do this anyway) *)
+				REPEAT
+					r.Bytes(buf, 0, 4, len);
+					IF CompareCharArrays(buf, videoStreamHeader.streamIdentifier, 3) THEN
+						nvi := nvi+1;
+					ELSE
+						IF audioStreamHeader # NIL THEN
+							IF CompareCharArrays(buf, audioStreamHeader.streamIdentifier, 4) THEN
+								nai := nai+1;
+							END;
+						END;
+					END;
+					r.SkipBytes(12);
+					i := i+1;
+				UNTIL (i = nidx-1);
+
+				videoFrames := nvi;
+				audioChunks := nai;
 				NEW(videoIndex, nvi);
 
- 				(* Vielleicht haben wir ja nur Bilder... *)
- 				IF (audioChunks > 0) THEN
- 					NEW(audioIndex, nai);
- 				END;
-
- 				(* So, und jetzt die Arrays fuellen *)
- 				nvi := 0;
- 				nai := 0;
- 				tot := 0;
- 				r.SetPos(indexStart);
-
- 				IF (idxType = 1) THEN
- 					ioff := 8;
- 				ELSE
- 					ioff := movieBeginPos;
- 				END;
-
- 				i := 0;
- 				REPEAT
- 					r.Bytes(buf, 0, 4, len);
- 					IF CompareCharArrays(buf, videoStreamHeader.streamIdentifier, 3) THEN
- 						r.RawLInt(videoIndex[nvi].flags);
- 						r.RawLInt(videoIndex[nvi].offset);
- 						videoIndex[nvi].offset := videoIndex[nvi].offset + ioff;
- 						r.RawLInt(videoIndex[nvi].length);
- 						nvi := nvi+1;
- 					ELSE
- 						IF CompareCharArrays(buf, audioStreamHeader.streamIdentifier, 4) THEN
- 							r.SkipBytes(4);
- 							r.RawLInt(audioIndex[nai].offset);
- 							audioIndex[nai].offset := audioIndex[nai].offset + ioff;
- 							r.RawLInt(audioIndex[nai].length);
- 							audioIndex[nai].tot := tot;
- 							tot := tot + audioIndex[nai].length;
- 							nai := nai+1;
- 						END;
- 					END;
- 					i := i+1;
- 				UNTIL (i = nidx-1);
- 				audioBytes := tot;
- 			END;
+				(* Vielleicht haben wir ja nur Bilder... *)
+				IF (audioChunks > 0) THEN
+					NEW(audioIndex, nai);
+				END;
+
+				(* So, und jetzt die Arrays fuellen *)
+				nvi := 0;
+				nai := 0;
+				tot := 0;
+				r.SetPos(indexStart);
+
+				IF (idxType = 1) THEN
+					ioff := 8;
+				ELSE
+					ioff := movieBeginPos;
+				END;
+
+				i := 0;
+				REPEAT
+					r.Bytes(buf, 0, 4, len);
+					IF CompareCharArrays(buf, videoStreamHeader.streamIdentifier, 3) THEN
+						r.RawLInt(videoIndex[nvi].flags);
+						r.RawLInt(videoIndex[nvi].offset);
+						videoIndex[nvi].offset := videoIndex[nvi].offset + ioff;
+						r.RawLInt(videoIndex[nvi].length);
+						nvi := nvi+1;
+					ELSE
+						IF CompareCharArrays(buf, audioStreamHeader.streamIdentifier, 4) THEN
+							r.SkipBytes(4);
+							r.RawLInt(audioIndex[nai].offset);
+							audioIndex[nai].offset := audioIndex[nai].offset + ioff;
+							r.RawLInt(audioIndex[nai].length);
+							audioIndex[nai].tot := tot;
+							tot := tot + audioIndex[nai].length;
+							nai := nai+1;
+						END;
+					END;
+					i := i+1;
+				UNTIL (i = nidx-1);
+				audioBytes := tot;
+			END;
 		END ReadIndex;
 
 		(* Skip chunk *)
@@ -936,7 +936,7 @@ IMPORT
 				IF (audioStreamHeader.waveFormatEx # NIL) THEN
 					CASE audioStreamHeader.waveFormatEx.formatTag OF
 						1 :	COPY("PCM", tag);
-					|	85: 	COPY("MP3", tag);
+					|	85:	COPY("MP3", tag);
 					ELSE
 					END;
 					FOR i := 0 TO 3 DO streamInfo.contentType[i] := tag[i]; END;
@@ -1009,7 +1009,7 @@ IMPORT
 			tag : ARRAY 4 OF CHAR;
 		BEGIN
 
- 			IF streamNr = 0 THEN							(* Video *)
+			IF streamNr = 0 THEN							(* Video *)
 				streamInfo.streamType := Codecs.STVideo;
 				FOR i := 0 TO 3 DO
 					streamInfo.contentType[i] := videoStreamHeader.fccHandler[i];
@@ -1029,7 +1029,7 @@ IMPORT
 				IF (audioStreamHeader.waveFormatEx # NIL) THEN
 					CASE audioStreamHeader.waveFormatEx.formatTag OF
 						1 :	COPY("PCM", tag);
-					|	85: 	COPY("MP3", tag);
+					|	85:	COPY("MP3", tag);
 					ELSE
 					END;
 					FOR i := 0 TO 3 DO
@@ -1332,7 +1332,7 @@ BEGIN
 		bufa := Machine.ChangeByteOrder( SYSTEM.GET32( temp ) );
 		bufb := Machine.ChangeByteOrder( SYSTEM.GET32( temp + 4 ) );
 
-		 temp := LSH( LSH( bufa, posInLONGINT ),  nbit - posInLONGINT );
+		temp := LSH( LSH( bufa, posInLONGINT ),  nbit - posInLONGINT );
 		RETURN SYSTEM.VAL( LONGINT, SYSTEM.VAL( SET, LSH( bufb, nbit - 32 ) ) + SYSTEM.VAL( SET, temp ) )
 	ELSE
 		(* Reading one 32 value is sufficient *)

source/AlmSmtpReceiver.Mod

@@ -802,27 +802,27 @@ TYPE
 		  |  1: ErrMsg("Eol expected, ")
 		  |  2: ErrMsg("ident expected, ")
 		  |  3: ErrMsg("'HELO' expected, ")
- 		  |  4: ErrMsg("'QUIT' expected, ")
- 		  |  5: ErrMsg("'NOOP' expected, ")
+		  |  4: ErrMsg("'QUIT' expected, ")
+		  |  5: ErrMsg("'NOOP' expected, ")
 		  |  6: ErrMsg("'RSET' expected, ")
 		  |  7: ErrMsg("'DATA' expected, ")
 		  |  8: ErrMsg("'.' expected, ")
- 		  |  9: ErrMsg("'RCPT' expected, ")
+		  |  9: ErrMsg("'RCPT' expected, ")
 		  | 10: ErrMsg("'TO:' expected, ")
 		  | 11: ErrMsg("'MAIL' expected, ")
 		  | 12: ErrMsg("'FROM:' expected, ")
- 		 ELSE END;
+		 ELSE END;
    		CASE sym OF
   		    0: ErrMsg("EOF found")
 		  |  1: ErrMsg("Eol found")
 		  |  2: ErrMsg("ident found")
 		  |  3: ErrMsg("'HELO' found")
- 		  |  4: ErrMsg("'QUIT' found")
- 		  |  5: ErrMsg("'NOOP' found")
+		  |  4: ErrMsg("'QUIT' found")
+		  |  5: ErrMsg("'NOOP' found")
 		  |  6: ErrMsg("'RSET' found")
 		  |  7: ErrMsg("'DATA' found")
 		  |  8: ErrMsg("'.' found")
- 		  |  9: ErrMsg("'RCPT' found")
+		  |  9: ErrMsg("'RCPT' found")
 		  | 10: ErrMsg("'TO:' found")
 		  | 11: ErrMsg("'MAIL' found")
 		  | 12: ErrMsg("'FROM:' found")

source/ArrayXdCplx.Mod

@@ -155,8 +155,8 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			IF ArrayXdBytes.InBounds( o0, l0, x ) & ArrayXdBytes.InBounds( o1, l1, y ) & ArrayXdBytes.InBounds( o2, l2, z ) &
-			    ArrayXdBytes.InBounds( o3, l3, t ) THEN
-				ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
+				ArrayXdBytes.InBounds( o3, l3, t ) THEN
+					ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
 			ELSE RETURN zero
 			END;
 		END Get4BAbsorbing;
@@ -191,7 +191,7 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			ArrayXdBytes.Get3( SELF, ArrayXdBytes.PeriodicBounds( o0, l0, x ), ArrayXdBytes.PeriodicBounds( o1, l1, y ),
-											 ArrayXdBytes.PeriodicBounds( o2, l2, z ), v );
+											ArrayXdBytes.PeriodicBounds( o2, l2, z ), v );
 			RETURN v
 		END Get3BPeriodic;
 
@@ -199,7 +199,7 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			ArrayXdBytes.Get4( SELF, ArrayXdBytes.PeriodicBounds( o0, l0, x ), ArrayXdBytes.PeriodicBounds( o1, l1, y ),
-											 ArrayXdBytes.PeriodicBounds( o2, l2, z ), ArrayXdBytes.PeriodicBounds( o3, l3, z ), v );
+											ArrayXdBytes.PeriodicBounds( o2, l2, z ), ArrayXdBytes.PeriodicBounds( o3, l3, z ), v );
 			RETURN v
 		END Get4BPeriodic;
 
@@ -228,7 +228,7 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			ArrayXdBytes.Get3( SELF, ArrayXdBytes.MirrorOffB( o0, l0, x ), ArrayXdBytes.MirrorOffB( o1, l1, y ),
-											 ArrayXdBytes.MirrorOffB( o2, l2, z ), v );
+											ArrayXdBytes.MirrorOffB( o2, l2, z ), v );
 			RETURN v
 		END Get3BSymmetricOffB;
 
@@ -236,7 +236,7 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			ArrayXdBytes.Get4( SELF, ArrayXdBytes.MirrorOffB( o0, l0, x ), ArrayXdBytes.MirrorOffB( o1, l1, y ),
-											 ArrayXdBytes.MirrorOffB( o2, l2, z ), ArrayXdBytes.MirrorOffB( o3, l3, z ), v );
+											ArrayXdBytes.MirrorOffB( o2, l2, z ), ArrayXdBytes.MirrorOffB( o3, l3, z ), v );
 			RETURN v
 		END Get4BSymmetricOffB;
 
@@ -311,7 +311,7 @@ TYPE
 				ArrayXdBytes.Get3( SELF, x, y, z, v );  RETURN v
 			ELSE
 				ArrayXdBytes.Get3( SELF, ArrayXdBytes.MirrorOffB( o0, l0, x ), ArrayXdBytes.MirrorOffB( o1, l1, y ),
-												 ArrayXdBytes.MirrorOffB( o2, l2, z ), v );
+												ArrayXdBytes.MirrorOffB( o2, l2, z ), v );
 				RETURN -v
 			END;
 		END Get3BAntisymmetricOffB;
@@ -320,11 +320,11 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			IF ArrayXdBytes.InBounds( o0, l0, x ) & ArrayXdBytes.InBounds( o1, l1, y ) & ArrayXdBytes.InBounds( o2, l2, z ) &
-			    ArrayXdBytes.InBounds( o3, l3, t ) THEN
-				ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
+				ArrayXdBytes.InBounds( o3, l3, t ) THEN
+					ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
 			ELSE
 				ArrayXdBytes.Get4( SELF, ArrayXdBytes.MirrorOffB( o0, l0, x ), ArrayXdBytes.MirrorOffB( o1, l1, y ),
-												 ArrayXdBytes.MirrorOffB( o2, l2, z ), ArrayXdBytes.MirrorOffB( o3, l3, t ), v );
+												ArrayXdBytes.MirrorOffB( o2, l2, z ), ArrayXdBytes.MirrorOffB( o3, l3, t ), v );
 				RETURN -v
 			END;
 		END Get4BAntisymmetricOffB;
@@ -367,7 +367,7 @@ TYPE
 				ArrayXdBytes.Get3( SELF, x, y, z, v );  RETURN v
 			ELSE
 				ArrayXdBytes.Get3( SELF, ArrayXdBytes.MirrorOnB( o0, l0, x ), ArrayXdBytes.MirrorOnB( o1, l1, y ),
-												 ArrayXdBytes.MirrorOnB( o2, l2, z ), v );
+												ArrayXdBytes.MirrorOnB( o2, l2, z ), v );
 				RETURN -v
 			END;
 		END Get3BAntisymmetricOnB;
@@ -376,11 +376,11 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			IF ArrayXdBytes.InBounds( o0, l0, x ) & ArrayXdBytes.InBounds( o1, l1, y ) & ArrayXdBytes.InBounds( o2, l2, z ) &
-			    ArrayXdBytes.InBounds( o3, l3, t ) THEN
-				ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
+				ArrayXdBytes.InBounds( o3, l3, t ) THEN
+					ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
 			ELSE
 				ArrayXdBytes.Get4( SELF, ArrayXdBytes.MirrorOnB( o0, l0, x ), ArrayXdBytes.MirrorOnB( o1, l1, y ),
-												 ArrayXdBytes.MirrorOnB( o2, l2, z ), ArrayXdBytes.MirrorOnB( o3, l3, t ), v );
+												ArrayXdBytes.MirrorOnB( o2, l2, z ), ArrayXdBytes.MirrorOnB( o3, l3, t ), v );
 				RETURN -v
 			END;
 		END Get4BAntisymmetricOnB;
@@ -529,7 +529,7 @@ VAR
 	BEGIN
 		IF (src.dim # 1) OR (dest.dim # 1) THEN HALT( 1001 ) END;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index1( srcx ), ArrayXdBytes.Index1( len ),
-																		   ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
 	END CopyVecToVec;
 
 	PROCEDURE CopyMtxToVec*( src, dest: Array;  dim: Index;  srcx, srcy, destx, len: Index );
@@ -538,7 +538,7 @@ VAR
 		IF (src.dim # 2) OR (dest.dim # 1) THEN HALT( 1002 ) END;
 		slen := ArrayXdBytes.Index2( 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index2( srcx, srcy ), slen,
-																		   ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
 	END CopyMtxToVec;
 
 	PROCEDURE CopyVecToMtx*( src, dest: Array;  dim: Index;  srcx, destx, desty, len: Index );
@@ -547,7 +547,7 @@ VAR
 		IF (src.dim # 1) OR (dest.dim # 2) THEN HALT( 1002 ) END;
 		slen := ArrayXdBytes.Index2( 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index1( srcx ), ArrayXdBytes.Index1( len ),
-																		   ArrayXdBytes.Index2( destx, desty ), slen );
+																		ArrayXdBytes.Index2( destx, desty ), slen );
 	END CopyVecToMtx;
 
 	PROCEDURE CopyCubeToVec*( src, dest: Array;  dim: Index;  srcx, srcy, srcz, destx, len: Index );
@@ -556,7 +556,7 @@ VAR
 		IF (src.dim # 3) OR (dest.dim # 1) THEN HALT( 1003 ) END;
 		slen := ArrayXdBytes.Index3( 1, 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ), slen,
-																		   ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
 	END CopyCubeToVec;
 
 	PROCEDURE CopyVecToCube*( src, dest: Array;  dim: Index;  srcx, destx, desty, destz, len: Index );
@@ -565,7 +565,7 @@ VAR
 		IF (src.dim # 1) OR (dest.dim # 3) THEN HALT( 1002 ) END;
 		slen := ArrayXdBytes.Index3( 1, 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index1( srcx ), ArrayXdBytes.Index1( len ),
-																		   ArrayXdBytes.Index3( destx, desty, destz ), slen );
+																		ArrayXdBytes.Index3( destx, desty, destz ), slen );
 	END CopyVecToCube;
 
 	PROCEDURE CopyHCubeToVec*( src, dest: Array;  dim: Index;  srcx, srcy, srcz, srct, destx, len: Index );
@@ -574,7 +574,7 @@ VAR
 		IF (src.dim # 4) OR (dest.dim # 1) THEN HALT( 1004 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ), slen,
-																		   ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
 	END CopyHCubeToVec;
 
 	PROCEDURE CopyVecToHCube*( src, dest: Array;  dim: Index;  srcx, destx, desty, destz, destt, len: Index );
@@ -583,7 +583,7 @@ VAR
 		IF (src.dim # 1) OR (dest.dim # 4) THEN HALT( 1002 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index1( srcx ), ArrayXdBytes.Index1( len ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
 	END CopyVecToHCube;
 
 	PROCEDURE CopyMtxToMtx*( src, dest: Array;  srcx, srcy, destx, desty, lenx, leny: Index );
@@ -592,7 +592,7 @@ VAR
 		IF (src.dim # 2) OR (dest.dim # 2) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index2( lenx, leny );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index2( srcx, srcy ), slen,
-																		   ArrayXdBytes.Index2( destx, desty ), slen );
+																		ArrayXdBytes.Index2( destx, desty ), slen );
 	END CopyMtxToMtx;
 
 	PROCEDURE CopyCubeToMtx*( src, dest: Array;  dimx, dimy: Index;  srcx, srcy, srcz, destx, desty, lenx, leny: Index );
@@ -601,7 +601,7 @@ VAR
 		IF (src.dim # 3) OR (dest.dim # 2) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index3( 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ), slen,
-																		   ArrayXdBytes.Index2( destx, desty ), ArrayXdBytes.Index2( lenx, leny ) );
+																		ArrayXdBytes.Index2( destx, desty ), ArrayXdBytes.Index2( lenx, leny ) );
 	END CopyCubeToMtx;
 
 	PROCEDURE CopyMtxToCube*( src, dest: Array;  dimx, dimy: Index;  srcx, srcy, destx, desty, destz, lenx, leny: Index );
@@ -610,7 +610,7 @@ VAR
 		IF (src.dim # 2) OR (dest.dim # 3) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index3( 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index2( srcx, srcy ), ArrayXdBytes.Index2( lenx, leny ),
-																		   ArrayXdBytes.Index3( destx, desty, destz ), slen );
+																		ArrayXdBytes.Index3( destx, desty, destz ), slen );
 	END CopyMtxToCube;
 
 	PROCEDURE CopyHCubeToMtx*( src, dest: Array;  dimx, dimy: Index;  srcx, srcy, srcz, srct, destx, desty, lenx, leny: Index );
@@ -619,17 +619,17 @@ VAR
 		IF (src.dim # 4) OR (dest.dim # 2) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ), slen,
-																		   ArrayXdBytes.Index2( destx, desty ), ArrayXdBytes.Index2( lenx, leny ) );
+																		ArrayXdBytes.Index2( destx, desty ), ArrayXdBytes.Index2( lenx, leny ) );
 	END CopyHCubeToMtx;
 
 	PROCEDURE CopyMtxToHCube*( src, dest: Array;  dimx, dimy: Index;
-														 srcx, srcy, destx, desty, destz, destt, lenx, leny: Index );
+														srcx, srcy, destx, desty, destz, destt, lenx, leny: Index );
 	VAR slen: ArrayXdBytes.IndexArray;
 	BEGIN
 		IF (src.dim # 2) OR (dest.dim # 4) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index2( srcx, srcy ), ArrayXdBytes.Index2( lenx, leny ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
 	END CopyMtxToHCube;
 
 	PROCEDURE CopyCubeToCube*( src, dest: Array;  srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
@@ -638,39 +638,39 @@ VAR
 		IF (src.dim # 3) OR (dest.dim # 3) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index3( lenx, leny, lenz );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ), slen,
-																		   ArrayXdBytes.Index3( destx, desty, destz ), slen );
+																		ArrayXdBytes.Index3( destx, desty, destz ), slen );
 	END CopyCubeToCube;
 
 	PROCEDURE CopyHCubeToCube*( src, dest: Array;  dimx, dimy, dimz: Index;
-														  srcx, srcy, srcz, srct, destx, desty, destz, lenx, leny, lenz: Index );
+														srcx, srcy, srcz, srct, destx, desty, destz, lenx, leny, lenz: Index );
 	VAR slen: ArrayXdBytes.IndexArray;
 	BEGIN
 		IF (src.dim # 4) OR (dest.dim # 3) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;  slen[dimz] := lenz;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ), slen,
-																		   ArrayXdBytes.Index3( destx, desty, destz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ) );
+																		ArrayXdBytes.Index3( destx, desty, destz ),
+																		ArrayXdBytes.Index3( lenx, leny, lenz ) );
 	END CopyHCubeToCube;
 
 	PROCEDURE CopyCubeToHCube*( src, dest: Array;  dimx, dimy, dimz: Index;
-														  srcx, srcy, srcz, destx, desty, destz, destt, lenx, leny, lenz: Index );
+														srcx, srcy, srcz, destx, desty, destz, destt, lenx, leny, lenz: Index );
 	VAR slen: ArrayXdBytes.IndexArray;
 	BEGIN
 		IF (src.dim # 3) OR (dest.dim # 4) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;  slen[dimz] := lenz;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
+																		ArrayXdBytes.Index3( lenx, leny, lenz ),
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
 	END CopyCubeToHCube;
 
 	PROCEDURE CopyHCubeToHCube*( src, dest: Array;
-															 srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
+															srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
 	VAR slen: ArrayXdBytes.IndexArray;
 	BEGIN
 		IF (src.dim # 4) OR (dest.dim # 4) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( lenx, leny, lenz, lent );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ), slen,
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
 	END CopyHCubeToHCube;
 
 	PROCEDURE CopyArrayToVec*( VAR src: ARRAY OF Value;  dest: Array;  srcx, destx, len: Index );
@@ -678,7 +678,7 @@ VAR
 		IF dest.dim # 1 THEN HALT( 1005 ) END;
 		ArrayXdBytes.CheckLEQ( 0, srcx );  ArrayXdBytes.CheckLE( srcx + len, LEN( src ) );
 		ArrayXdBytes.CopyMemoryToArrayPart( ADDRESSOF( src[srcx] ), dest, len, ArrayXdBytes.Index1( destx ),
-																		 ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( len ) );
 	END CopyArrayToVec;
 
 	PROCEDURE CopyVecToArray*( src: Array;  VAR dest: ARRAY OF Value;  srcx, destx, len: Index );
@@ -686,7 +686,7 @@ VAR
 		IF src.dim # 1 THEN HALT( 1005 ) END;
 		ArrayXdBytes.CheckLEQ( 0, destx );  ArrayXdBytes.CheckLE( destx + len, LEN( dest ) );
 		ArrayXdBytes.CopyArrayPartToMemory( src, ADDRESSOF( dest[destx] ), ArrayXdBytes.Index1( srcx ),
-																		 ArrayXdBytes.Index1( len ), len );
+																		ArrayXdBytes.Index1( len ), len );
 	END CopyVecToArray;
 
 	PROCEDURE CopyArrayToMtx*( VAR src: ARRAY OF ARRAY OF Value;  dest: Array;  srcx, srcy, destx, desty, lenx, leny: Index );
@@ -695,10 +695,10 @@ VAR
 		IF dest.dim # 2 THEN HALT( 1005 ) END;
 		srcmem :=
 			ArrayXdBytes.MakeMemoryStructure( 2, ArrayXdBytes.Index2( 0, 0 ), ArrayXdBytes.Index2( LEN( src, 1 ), LEN( src, 0 ) ),
-																		  SIZEOF( Value ), ADDRESSOF( src[0, 0] ) );
+																		SIZEOF( Value ), ADDRESSOF( src[0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( srcmem, dest, ArrayXdBytes.Index2( srcx, srcy ),
-																		   ArrayXdBytes.Index2( lenx, leny ), ArrayXdBytes.Index2( destx, desty ),
-																		   ArrayXdBytes.Index2( lenx, leny ) );
+																		ArrayXdBytes.Index2( lenx, leny ), ArrayXdBytes.Index2( destx, desty ),
+																		ArrayXdBytes.Index2( lenx, leny ) );
 	END CopyArrayToMtx;
 
 	PROCEDURE CopyMtxToArray*( src: Array;  VAR dest: ARRAY OF ARRAY OF Value;  srcx, srcy, destx, desty, lenx, leny: Index );
@@ -707,80 +707,80 @@ VAR
 		IF src.dim # 2 THEN HALT( 1005 ) END;
 		destmem :=
 			ArrayXdBytes.MakeMemoryStructure( 2, ArrayXdBytes.Index2( 0, 0 ), ArrayXdBytes.Index2( LEN( dest, 1 ), LEN( dest, 0 ) ),
-																		  SIZEOF( Value ), ADDRESSOF( dest[0, 0] ) );
+																		SIZEOF( Value ), ADDRESSOF( dest[0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, destmem, ArrayXdBytes.Index2( srcx, srcy ),
-																		   ArrayXdBytes.Index2( lenx, leny ), ArrayXdBytes.Index2( destx, desty ),
-																		   ArrayXdBytes.Index2( lenx, leny ) );
+																		ArrayXdBytes.Index2( lenx, leny ), ArrayXdBytes.Index2( destx, desty ),
+																		ArrayXdBytes.Index2( lenx, leny ) );
 	END CopyMtxToArray;
 
 	PROCEDURE CopyArrayToCube*( VAR src: ARRAY OF ARRAY OF ARRAY OF Value;  dest: Array;
-													    srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
+													srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
 	VAR srcmem: ArrayXdBytes.ArrayMemoryStructure;
 	BEGIN
 		IF dest.dim # 3 THEN HALT( 1005 ) END;
 		srcmem :=
 			ArrayXdBytes.MakeMemoryStructure( 3, ArrayXdBytes.Index3( 0, 0, 0 ),
-																		  ArrayXdBytes.Index3( LEN( src, 2 ), LEN( src, 1 ), LEN( src, 0 ) ), SIZEOF( Value ),
-																		  ADDRESSOF( src[0, 0, 0] ) );
+																		ArrayXdBytes.Index3( LEN( src, 2 ), LEN( src, 1 ), LEN( src, 0 ) ), SIZEOF( Value ),
+																		ADDRESSOF( src[0, 0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( srcmem, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ),
-																		   ArrayXdBytes.Index3( destx, desty, destz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ) );
+																		ArrayXdBytes.Index3( lenx, leny, lenz ),
+																		ArrayXdBytes.Index3( destx, desty, destz ),
+																		ArrayXdBytes.Index3( lenx, leny, lenz ) );
 	END CopyArrayToCube;
 
 	PROCEDURE CopyCubeToArray*( src: Array;  VAR dest: ARRAY OF ARRAY OF ARRAY OF Value;
-													    srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
+													srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
 	VAR destmem: ArrayXdBytes.ArrayMemoryStructure;
 	BEGIN
 		IF src.dim # 3 THEN HALT( 1005 ) END;
 		destmem :=
 			ArrayXdBytes.MakeMemoryStructure( 3, ArrayXdBytes.Index3( 0, 0, 0 ),
-																		  ArrayXdBytes.Index3( LEN( dest, 2 ), LEN( dest, 1 ), LEN( dest, 0 ) ), SIZEOF( Value ),
-																		  ADDRESSOF( dest[0, 0, 0] ) );
+																		ArrayXdBytes.Index3( LEN( dest, 2 ), LEN( dest, 1 ), LEN( dest, 0 ) ), SIZEOF( Value ),
+																		ADDRESSOF( dest[0, 0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, destmem, ArrayXdBytes.Index3( srcx, srcy, srcz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ),
-																		   ArrayXdBytes.Index3( destx, desty, destz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ) );
+																		ArrayXdBytes.Index3( lenx, leny, lenz ),
+																		ArrayXdBytes.Index3( destx, desty, destz ),
+																		ArrayXdBytes.Index3( lenx, leny, lenz ) );
 	END CopyCubeToArray;
 
 	PROCEDURE CopyArrayToHCube*( VAR src: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value;  dest: Array;
-														  srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
+														srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
 	VAR srcmem: ArrayXdBytes.ArrayMemoryStructure;
 	BEGIN
 		IF dest.dim # 4 THEN HALT( 1005 ) END;
 		srcmem :=
 			ArrayXdBytes.MakeMemoryStructure( 4, ArrayXdBytes.Index4( 0, 0, 0, 0 ),
-																		  ArrayXdBytes.Index4( LEN( src, 3 ), LEN( src, 2 ), LEN( src, 1 ), LEN( src, 0 ) ), SIZEOF( Value ),
-																		  ADDRESSOF( src[0, 0, 0] ) );
+																		ArrayXdBytes.Index4( LEN( src, 3 ), LEN( src, 2 ), LEN( src, 1 ), LEN( src, 0 ) ), SIZEOF( Value ),
+																		ADDRESSOF( src[0, 0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( srcmem, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ),
-																		   ArrayXdBytes.Index4( lenx, leny, lenz, lent ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ),
-																		   ArrayXdBytes.Index4( lenx, leny, lenz, lent ) );
+																		ArrayXdBytes.Index4( lenx, leny, lenz, lent ),
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ),
+																		ArrayXdBytes.Index4( lenx, leny, lenz, lent ) );
 	END CopyArrayToHCube;
 
 	PROCEDURE CopyHCubeToArray*( src: Array;  VAR dest: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value;
-														  srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
+														srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
 	VAR destmem: ArrayXdBytes.ArrayMemoryStructure;
 	BEGIN
 		IF src.dim # 4 THEN HALT( 1005 ) END;
 		destmem :=
 			ArrayXdBytes.MakeMemoryStructure( 4, ArrayXdBytes.Index4( 0, 0, 0, 0 ),
-																		  ArrayXdBytes.Index4( LEN( dest, 3 ), LEN( dest, 2 ), LEN( dest, 1 ), LEN( dest, 0 ) ), SIZEOF( Value ),
-																		  ADDRESSOF( dest[0, 0, 0] ) );
+																		ArrayXdBytes.Index4( LEN( dest, 3 ), LEN( dest, 2 ), LEN( dest, 1 ), LEN( dest, 0 ) ), SIZEOF( Value ),
+																		ADDRESSOF( dest[0, 0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, destmem, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ),
-																		   ArrayXdBytes.Index4( lenx, leny, lenz, lent ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ),
-																		   ArrayXdBytes.Index4( lenx, leny, lenz, lent ) );
+																		ArrayXdBytes.Index4( lenx, leny, lenz, lent ),
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ),
+																		ArrayXdBytes.Index4( lenx, leny, lenz, lent ) );
 	END CopyHCubeToArray;
 
 	PROCEDURE CopyArrayToArrayPartB*( src: Array;  dest: ArrayXdBytes.ArrayMemoryStructure;  boundaryCondition: SHORTINT;
-																 srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray );
+																srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray );
 
 	VAR temp: ArrayXdBytes.ArrayMemoryStructure;
 		spos, dpos, last, borigin, blen, srcposcut, srclencut, destoffset: ArrayXdBytes.IndexArray;  i, dim: LONGINT;
 		val: Value;  temp2: Array;  enumB: ArrayXdBytes.BoundaryEnum;
 		Get: PROCEDURE {DELEGATE} ( x: ARRAY OF Index;
-																																													 dim: Index ): Value;
+																																													dim: Index ): Value;
 		noinbound: BOOLEAN;  v: Value;
 
 		(* for debugging
@@ -1177,4 +1177,3 @@ VAR
 BEGIN
 	Register
 END ArrayXdCplx.
-

source/ArrayXdInt.Mod

@@ -158,8 +158,8 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			IF ArrayXdBytes.InBounds( o0, l0, x ) & ArrayXdBytes.InBounds( o1, l1, y ) & ArrayXdBytes.InBounds( o2, l2, z ) &
-			    ArrayXdBytes.InBounds( o3, l3, t ) THEN
-				ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
+				ArrayXdBytes.InBounds( o3, l3, t ) THEN
+					ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
 			ELSE RETURN 0
 			END;
 		END Get4BAbsorbing;
@@ -194,7 +194,7 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			ArrayXdBytes.Get3( SELF, ArrayXdBytes.PeriodicBounds( o0, l0, x ), ArrayXdBytes.PeriodicBounds( o1, l1, y ),
-											 ArrayXdBytes.PeriodicBounds( o2, l2, z ), v );
+											ArrayXdBytes.PeriodicBounds( o2, l2, z ), v );
 			RETURN v
 		END Get3BPeriodic;
 
@@ -202,7 +202,7 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			ArrayXdBytes.Get4( SELF, ArrayXdBytes.PeriodicBounds( o0, l0, x ), ArrayXdBytes.PeriodicBounds( o1, l1, y ),
-											 ArrayXdBytes.PeriodicBounds( o2, l2, z ), ArrayXdBytes.PeriodicBounds( o3, l3, z ), v );
+											ArrayXdBytes.PeriodicBounds( o2, l2, z ), ArrayXdBytes.PeriodicBounds( o3, l3, z ), v );
 			RETURN v
 		END Get4BPeriodic;
 
@@ -231,7 +231,7 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			ArrayXdBytes.Get3( SELF, ArrayXdBytes.MirrorOffB( o0, l0, x ), ArrayXdBytes.MirrorOffB( o1, l1, y ),
-											 ArrayXdBytes.MirrorOffB( o2, l2, z ), v );
+											ArrayXdBytes.MirrorOffB( o2, l2, z ), v );
 			RETURN v
 		END Get3BSymmetricOffB;
 
@@ -239,7 +239,7 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			ArrayXdBytes.Get4( SELF, ArrayXdBytes.MirrorOffB( o0, l0, x ), ArrayXdBytes.MirrorOffB( o1, l1, y ),
-											 ArrayXdBytes.MirrorOffB( o2, l2, z ), ArrayXdBytes.MirrorOffB( o3, l3, z ), v );
+											ArrayXdBytes.MirrorOffB( o2, l2, z ), ArrayXdBytes.MirrorOffB( o3, l3, z ), v );
 			RETURN v
 		END Get4BSymmetricOffB;
 
@@ -314,7 +314,7 @@ TYPE
 				ArrayXdBytes.Get3( SELF, x, y, z, v );  RETURN v
 			ELSE
 				ArrayXdBytes.Get3( SELF, ArrayXdBytes.MirrorOffB( o0, l0, x ), ArrayXdBytes.MirrorOffB( o1, l1, y ),
-												 ArrayXdBytes.MirrorOffB( o2, l2, z ), v );
+												ArrayXdBytes.MirrorOffB( o2, l2, z ), v );
 				RETURN -v
 			END;
 		END Get3BAntisymmetricOffB;
@@ -323,11 +323,11 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			IF ArrayXdBytes.InBounds( o0, l0, x ) & ArrayXdBytes.InBounds( o1, l1, y ) & ArrayXdBytes.InBounds( o2, l2, z ) &
-			    ArrayXdBytes.InBounds( o3, l3, t ) THEN
-				ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
+				ArrayXdBytes.InBounds( o3, l3, t ) THEN
+					ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
 			ELSE
 				ArrayXdBytes.Get4( SELF, ArrayXdBytes.MirrorOffB( o0, l0, x ), ArrayXdBytes.MirrorOffB( o1, l1, y ),
-												 ArrayXdBytes.MirrorOffB( o2, l2, z ), ArrayXdBytes.MirrorOffB( o3, l3, t ), v );
+												ArrayXdBytes.MirrorOffB( o2, l2, z ), ArrayXdBytes.MirrorOffB( o3, l3, t ), v );
 				RETURN -v
 			END;
 		END Get4BAntisymmetricOffB;
@@ -370,7 +370,7 @@ TYPE
 				ArrayXdBytes.Get3( SELF, x, y, z, v );  RETURN v
 			ELSE
 				ArrayXdBytes.Get3( SELF, ArrayXdBytes.MirrorOnB( o0, l0, x ), ArrayXdBytes.MirrorOnB( o1, l1, y ),
-												 ArrayXdBytes.MirrorOnB( o2, l2, z ), v );
+												ArrayXdBytes.MirrorOnB( o2, l2, z ), v );
 				RETURN -v
 			END;
 		END Get3BAntisymmetricOnB;
@@ -379,11 +379,11 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			IF ArrayXdBytes.InBounds( o0, l0, x ) & ArrayXdBytes.InBounds( o1, l1, y ) & ArrayXdBytes.InBounds( o2, l2, z ) &
-			    ArrayXdBytes.InBounds( o3, l3, t ) THEN
-				ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
+				ArrayXdBytes.InBounds( o3, l3, t ) THEN
+					ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
 			ELSE
 				ArrayXdBytes.Get4( SELF, ArrayXdBytes.MirrorOnB( o0, l0, x ), ArrayXdBytes.MirrorOnB( o1, l1, y ),
-												 ArrayXdBytes.MirrorOnB( o2, l2, z ), ArrayXdBytes.MirrorOnB( o3, l3, t ), v );
+												ArrayXdBytes.MirrorOnB( o2, l2, z ), ArrayXdBytes.MirrorOnB( o3, l3, t ), v );
 				RETURN -v
 			END;
 		END Get4BAntisymmetricOnB;
@@ -539,7 +539,7 @@ TYPE
 	BEGIN
 		IF (src.dim # 1) OR (dest.dim # 1) THEN HALT( 1001 ) END;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index1( srcx ), ArrayXdBytes.Index1( len ),
-																		   ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
 	END CopyVecToVec;
 
 	PROCEDURE CopyMtxToVec*( src, dest: Array;  dim: Index;  srcx, srcy, destx, len: Index );
@@ -548,7 +548,7 @@ TYPE
 		IF (src.dim # 2) OR (dest.dim # 1) THEN HALT( 1002 ) END;
 		slen := ArrayXdBytes.Index2( 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index2( srcx, srcy ), slen,
-																		   ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
 	END CopyMtxToVec;
 
 	PROCEDURE CopyVecToMtx*( src, dest: Array;  dim: Index;  srcx, destx, desty, len: Index );
@@ -557,7 +557,7 @@ TYPE
 		IF (src.dim # 1) OR (dest.dim # 2) THEN HALT( 1002 ) END;
 		slen := ArrayXdBytes.Index2( 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index1( srcx ), ArrayXdBytes.Index1( len ),
-																		   ArrayXdBytes.Index2( destx, desty ), slen );
+																		ArrayXdBytes.Index2( destx, desty ), slen );
 	END CopyVecToMtx;
 
 	PROCEDURE CopyCubeToVec*( src, dest: Array;  dim: Index;  srcx, srcy, srcz, destx, len: Index );
@@ -566,7 +566,7 @@ TYPE
 		IF (src.dim # 3) OR (dest.dim # 1) THEN HALT( 1003 ) END;
 		slen := ArrayXdBytes.Index3( 1, 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ), slen,
-																		   ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
 	END CopyCubeToVec;
 
 	PROCEDURE CopyVecToCube*( src, dest: Array;  dim: Index;  srcx, destx, desty, destz, len: Index );
@@ -575,7 +575,7 @@ TYPE
 		IF (src.dim # 1) OR (dest.dim # 3) THEN HALT( 1002 ) END;
 		slen := ArrayXdBytes.Index3( 1, 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index1( srcx ), ArrayXdBytes.Index1( len ),
-																		   ArrayXdBytes.Index3( destx, desty, destz ), slen );
+																		ArrayXdBytes.Index3( destx, desty, destz ), slen );
 	END CopyVecToCube;
 
 	PROCEDURE CopyHCubeToVec*( src, dest: Array;  dim: Index;  srcx, srcy, srcz, srct, destx, len: Index );
@@ -584,7 +584,7 @@ TYPE
 		IF (src.dim # 4) OR (dest.dim # 1) THEN HALT( 1004 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ), slen,
-																		   ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
 	END CopyHCubeToVec;
 
 	PROCEDURE CopyVecToHCube*( src, dest: Array;  dim: Index;  srcx, destx, desty, destz, destt, len: Index );
@@ -593,7 +593,7 @@ TYPE
 		IF (src.dim # 1) OR (dest.dim # 4) THEN HALT( 1002 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index1( srcx ), ArrayXdBytes.Index1( len ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
 	END CopyVecToHCube;
 
 	PROCEDURE CopyMtxToMtx*( src, dest: Array;  srcx, srcy, destx, desty, lenx, leny: Index );
@@ -602,7 +602,7 @@ TYPE
 		IF (src.dim # 2) OR (dest.dim # 2) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index2( lenx, leny );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index2( srcx, srcy ), slen,
-																		   ArrayXdBytes.Index2( destx, desty ), slen );
+																		ArrayXdBytes.Index2( destx, desty ), slen );
 	END CopyMtxToMtx;
 
 	PROCEDURE CopyCubeToMtx*( src, dest: Array;  dimx, dimy: Index;  srcx, srcy, srcz, destx, desty, lenx, leny: Index );
@@ -611,7 +611,7 @@ TYPE
 		IF (src.dim # 3) OR (dest.dim # 2) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index3( 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ), slen,
-																		   ArrayXdBytes.Index2( destx, desty ), ArrayXdBytes.Index2( lenx, leny ) );
+																		ArrayXdBytes.Index2( destx, desty ), ArrayXdBytes.Index2( lenx, leny ) );
 	END CopyCubeToMtx;
 
 	PROCEDURE CopyMtxToCube*( src, dest: Array;  dimx, dimy: Index;  srcx, srcy, destx, desty, destz, lenx, leny: Index );
@@ -620,7 +620,7 @@ TYPE
 		IF (src.dim # 2) OR (dest.dim # 3) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index3( 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index2( srcx, srcy ), ArrayXdBytes.Index2( lenx, leny ),
-																		   ArrayXdBytes.Index3( destx, desty, destz ), slen );
+																		ArrayXdBytes.Index3( destx, desty, destz ), slen );
 	END CopyMtxToCube;
 
 	PROCEDURE CopyHCubeToMtx*( src, dest: Array;  dimx, dimy: Index;  srcx, srcy, srcz, srct, destx, desty, lenx, leny: Index );
@@ -629,17 +629,17 @@ TYPE
 		IF (src.dim # 4) OR (dest.dim # 2) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ), slen,
-																		   ArrayXdBytes.Index2( destx, desty ), ArrayXdBytes.Index2( lenx, leny ) );
+																		ArrayXdBytes.Index2( destx, desty ), ArrayXdBytes.Index2( lenx, leny ) );
 	END CopyHCubeToMtx;
 
 	PROCEDURE CopyMtxToHCube*( src, dest: Array;  dimx, dimy: Index;
-														 srcx, srcy, destx, desty, destz, destt, lenx, leny: Index );
+														srcx, srcy, destx, desty, destz, destt, lenx, leny: Index );
 	VAR slen: ArrayXdBytes.IndexArray;
 	BEGIN
 		IF (src.dim # 2) OR (dest.dim # 4) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index2( srcx, srcy ), ArrayXdBytes.Index2( lenx, leny ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
 	END CopyMtxToHCube;
 
 	PROCEDURE CopyCubeToCube*( src, dest: Array;  srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
@@ -648,39 +648,39 @@ TYPE
 		IF (src.dim # 3) OR (dest.dim # 3) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index3( lenx, leny, lenz );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ), slen,
-																		   ArrayXdBytes.Index3( destx, desty, destz ), slen );
+																		ArrayXdBytes.Index3( destx, desty, destz ), slen );
 	END CopyCubeToCube;
 
 	PROCEDURE CopyHCubeToCube*( src, dest: Array;  dimx, dimy, dimz: Index;
-														  srcx, srcy, srcz, srct, destx, desty, destz, lenx, leny, lenz: Index );
+														srcx, srcy, srcz, srct, destx, desty, destz, lenx, leny, lenz: Index );
 	VAR slen: ArrayXdBytes.IndexArray;
 	BEGIN
 		IF (src.dim # 4) OR (dest.dim # 3) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;  slen[dimz] := lenz;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ), slen,
-																		   ArrayXdBytes.Index3( destx, desty, destz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ) );
+																		ArrayXdBytes.Index3( destx, desty, destz ),
+																		ArrayXdBytes.Index3( lenx, leny, lenz ) );
 	END CopyHCubeToCube;
 
 	PROCEDURE CopyCubeToHCube*( src, dest: Array;  dimx, dimy, dimz: Index;
-														  srcx, srcy, srcz, destx, desty, destz, destt, lenx, leny, lenz: Index );
+														srcx, srcy, srcz, destx, desty, destz, destt, lenx, leny, lenz: Index );
 	VAR slen: ArrayXdBytes.IndexArray;
 	BEGIN
 		IF (src.dim # 3) OR (dest.dim # 4) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;  slen[dimz] := lenz;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
+																		ArrayXdBytes.Index3( lenx, leny, lenz ),
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
 	END CopyCubeToHCube;
 
 	PROCEDURE CopyHCubeToHCube*( src, dest: Array;
-															 srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
+															srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
 	VAR slen: ArrayXdBytes.IndexArray;
 	BEGIN
 		IF (src.dim # 4) OR (dest.dim # 4) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( lenx, leny, lenz, lent );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ), slen,
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
 	END CopyHCubeToHCube;
 
 	PROCEDURE CopyArrayToVec*( VAR src: ARRAY OF Value;  dest: Array;  srcx, destx, len: Index );
@@ -688,7 +688,7 @@ TYPE
 		IF dest.dim # 1 THEN HALT( 1005 ) END;
 		ArrayXdBytes.CheckLEQ( 0, srcx );  ArrayXdBytes.CheckLE( srcx + len, LEN( src ) );
 		ArrayXdBytes.CopyMemoryToArrayPart( ADDRESSOF( src[srcx] ), dest, len, ArrayXdBytes.Index1( destx ),
-																		 ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( len ) );
 	END CopyArrayToVec;
 
 	PROCEDURE CopyVecToArray*( src: Array;  VAR dest: ARRAY OF Value;  srcx, destx, len: Index );
@@ -696,7 +696,7 @@ TYPE
 		IF src.dim # 1 THEN HALT( 1005 ) END;
 		ArrayXdBytes.CheckLEQ( 0, destx );  ArrayXdBytes.CheckLE( destx + len, LEN( dest ) );
 		ArrayXdBytes.CopyArrayPartToMemory( src, ADDRESSOF( dest[destx] ), ArrayXdBytes.Index1( srcx ),
-																		 ArrayXdBytes.Index1( len ), len );
+																		ArrayXdBytes.Index1( len ), len );
 	END CopyVecToArray;
 
 	PROCEDURE CopyArrayToMtx*( VAR src: ARRAY OF ARRAY OF Value;  dest: Array;  srcx, srcy, destx, desty, lenx, leny: Index );
@@ -705,10 +705,10 @@ TYPE
 		IF dest.dim # 2 THEN HALT( 1005 ) END;
 		srcmem :=
 			ArrayXdBytes.MakeMemoryStructure( 2, ArrayXdBytes.Index2( 0, 0 ), ArrayXdBytes.Index2( LEN( src, 1 ), LEN( src, 0 ) ),
-																		  SIZEOF( Value ), ADDRESSOF( src[0, 0] ) );
+																		SIZEOF( Value ), ADDRESSOF( src[0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( srcmem, dest, ArrayXdBytes.Index2( srcx, srcy ),
-																		   ArrayXdBytes.Index2( lenx, leny ), ArrayXdBytes.Index2( destx, desty ),
-																		   ArrayXdBytes.Index2( lenx, leny ) );
+																		ArrayXdBytes.Index2( lenx, leny ), ArrayXdBytes.Index2( destx, desty ),
+																		ArrayXdBytes.Index2( lenx, leny ) );
 	END CopyArrayToMtx;
 
 	PROCEDURE CopyMtxToArray*( src: Array;  VAR dest: ARRAY OF ARRAY OF Value;  srcx, srcy, destx, desty, lenx, leny: Index );
@@ -717,80 +717,80 @@ TYPE
 		IF src.dim # 2 THEN HALT( 1005 ) END;
 		destmem :=
 			ArrayXdBytes.MakeMemoryStructure( 2, ArrayXdBytes.Index2( 0, 0 ), ArrayXdBytes.Index2( LEN( dest, 1 ), LEN( dest, 0 ) ),
-																		  SIZEOF( Value ), ADDRESSOF( dest[0, 0] ) );
+																		SIZEOF( Value ), ADDRESSOF( dest[0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, destmem, ArrayXdBytes.Index2( srcx, srcy ),
-																		   ArrayXdBytes.Index2( lenx, leny ), ArrayXdBytes.Index2( destx, desty ),
-																		   ArrayXdBytes.Index2( lenx, leny ) );
+																		ArrayXdBytes.Index2( lenx, leny ), ArrayXdBytes.Index2( destx, desty ),
+																		ArrayXdBytes.Index2( lenx, leny ) );
 	END CopyMtxToArray;
 
 	PROCEDURE CopyArrayToCube*( VAR src: ARRAY OF ARRAY OF ARRAY OF Value;  dest: Array;
-													    srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
+													srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
 	VAR srcmem: ArrayXdBytes.ArrayMemoryStructure;
 	BEGIN
 		IF dest.dim # 3 THEN HALT( 1005 ) END;
 		srcmem :=
 			ArrayXdBytes.MakeMemoryStructure( 3, ArrayXdBytes.Index3( 0, 0, 0 ),
-																		  ArrayXdBytes.Index3( LEN( src, 2 ), LEN( src, 1 ), LEN( src, 0 ) ), SIZEOF( Value ),
-																		  ADDRESSOF( src[0, 0, 0] ) );
+																		ArrayXdBytes.Index3( LEN( src, 2 ), LEN( src, 1 ), LEN( src, 0 ) ), SIZEOF( Value ),
+																		ADDRESSOF( src[0, 0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( srcmem, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ),
-																		   ArrayXdBytes.Index3( destx, desty, destz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ) );
+																		ArrayXdBytes.Index3( lenx, leny, lenz ),
+																		ArrayXdBytes.Index3( destx, desty, destz ),
+																		ArrayXdBytes.Index3( lenx, leny, lenz ) );
 	END CopyArrayToCube;
 
 	PROCEDURE CopyCubeToArray*( src: Array;  VAR dest: ARRAY OF ARRAY OF ARRAY OF Value;
-													    srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
+													srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
 	VAR destmem: ArrayXdBytes.ArrayMemoryStructure;
 	BEGIN
 		IF src.dim # 3 THEN HALT( 1005 ) END;
 		destmem :=
 			ArrayXdBytes.MakeMemoryStructure( 3, ArrayXdBytes.Index3( 0, 0, 0 ),
-																		  ArrayXdBytes.Index3( LEN( dest, 2 ), LEN( dest, 1 ), LEN( dest, 0 ) ), SIZEOF( Value ),
-																		  ADDRESSOF( dest[0, 0, 0] ) );
+																		ArrayXdBytes.Index3( LEN( dest, 2 ), LEN( dest, 1 ), LEN( dest, 0 ) ), SIZEOF( Value ),
+																		ADDRESSOF( dest[0, 0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, destmem, ArrayXdBytes.Index3( srcx, srcy, srcz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ),
-																		   ArrayXdBytes.Index3( destx, desty, destz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ) );
+																		ArrayXdBytes.Index3( lenx, leny, lenz ),
+																		ArrayXdBytes.Index3( destx, desty, destz ),
+																		ArrayXdBytes.Index3( lenx, leny, lenz ) );
 	END CopyCubeToArray;
 
 	PROCEDURE CopyArrayToHCube*( VAR src: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value;  dest: Array;
-														  srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
+														srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
 	VAR srcmem: ArrayXdBytes.ArrayMemoryStructure;
 	BEGIN
 		IF dest.dim # 4 THEN HALT( 1005 ) END;
 		srcmem :=
 			ArrayXdBytes.MakeMemoryStructure( 4, ArrayXdBytes.Index4( 0, 0, 0, 0 ),
-																		  ArrayXdBytes.Index4( LEN( src, 3 ), LEN( src, 2 ), LEN( src, 1 ), LEN( src, 0 ) ), SIZEOF( Value ),
-																		  ADDRESSOF( src[0, 0, 0] ) );
+																		ArrayXdBytes.Index4( LEN( src, 3 ), LEN( src, 2 ), LEN( src, 1 ), LEN( src, 0 ) ), SIZEOF( Value ),
+																		ADDRESSOF( src[0, 0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( srcmem, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ),
-																		   ArrayXdBytes.Index4( lenx, leny, lenz, lent ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ),
-																		   ArrayXdBytes.Index4( lenx, leny, lenz, lent ) );
+																		ArrayXdBytes.Index4( lenx, leny, lenz, lent ),
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ),
+																		ArrayXdBytes.Index4( lenx, leny, lenz, lent ) );
 	END CopyArrayToHCube;
 
 	PROCEDURE CopyHCubeToArray*( src: Array;  VAR dest: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value;
-														  srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
+														srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
 	VAR destmem: ArrayXdBytes.ArrayMemoryStructure;
 	BEGIN
 		IF src.dim # 4 THEN HALT( 1005 ) END;
 		destmem :=
 			ArrayXdBytes.MakeMemoryStructure( 4, ArrayXdBytes.Index4( 0, 0, 0, 0 ),
-																		  ArrayXdBytes.Index4( LEN( dest, 3 ), LEN( dest, 2 ), LEN( dest, 1 ), LEN( dest, 0 ) ), SIZEOF( Value ),
-																		  ADDRESSOF( dest[0, 0, 0] ) );
+																		ArrayXdBytes.Index4( LEN( dest, 3 ), LEN( dest, 2 ), LEN( dest, 1 ), LEN( dest, 0 ) ), SIZEOF( Value ),
+																		ADDRESSOF( dest[0, 0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, destmem, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ),
-																		   ArrayXdBytes.Index4( lenx, leny, lenz, lent ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ),
-																		   ArrayXdBytes.Index4( lenx, leny, lenz, lent ) );
+																		ArrayXdBytes.Index4( lenx, leny, lenz, lent ),
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ),
+																		ArrayXdBytes.Index4( lenx, leny, lenz, lent ) );
 	END CopyHCubeToArray;
 
 	PROCEDURE CopyArrayToArrayPartB*( src: Array;  dest: ArrayXdBytes.ArrayMemoryStructure;  boundaryCondition: SHORTINT;
-																 srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray );
+																srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray );
 
 	VAR temp: ArrayXdBytes.ArrayMemoryStructure;
 		spos, dpos, last, borigin, blen, srcposcut, srclencut, destoffset: ArrayXdBytes.IndexArray;  i, dim: LONGINT;
 		val: Value;  temp2: Array;  enumB: ArrayXdBytes.BoundaryEnum;
 		Get: PROCEDURE {DELEGATE} ( x: ARRAY OF Index;
-																																													 dim: Index ): Value;
+																																													dim: Index ): Value;
 		noinbound: BOOLEAN;  v: Value;
 
 		(* for debugging
@@ -1168,7 +1168,6 @@ END ArrayXdInt.
 
 System.Free ArrayXdInt ArrayXdBytes Array2dInt Array1dInt Array1dBytes ~
 
-
 ArrayXdInt.dbgTest ~
 
 Decoder.Decode ArrayXdInt.Obj  ~

source/ArrayXdRat.Mod

@@ -155,8 +155,8 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			IF ArrayXdBytes.InBounds( o0, l0, x ) & ArrayXdBytes.InBounds( o1, l1, y ) & ArrayXdBytes.InBounds( o2, l2, z ) &
-			    ArrayXdBytes.InBounds( o3, l3, t ) THEN
-				ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
+				ArrayXdBytes.InBounds( o3, l3, t ) THEN
+					ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
 			ELSE RETURN zero
 			END;
 		END Get4BAbsorbing;
@@ -191,7 +191,7 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			ArrayXdBytes.Get3( SELF, ArrayXdBytes.PeriodicBounds( o0, l0, x ), ArrayXdBytes.PeriodicBounds( o1, l1, y ),
-											 ArrayXdBytes.PeriodicBounds( o2, l2, z ), v );
+											ArrayXdBytes.PeriodicBounds( o2, l2, z ), v );
 			RETURN v
 		END Get3BPeriodic;
 
@@ -199,7 +199,7 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			ArrayXdBytes.Get4( SELF, ArrayXdBytes.PeriodicBounds( o0, l0, x ), ArrayXdBytes.PeriodicBounds( o1, l1, y ),
-											 ArrayXdBytes.PeriodicBounds( o2, l2, z ), ArrayXdBytes.PeriodicBounds( o3, l3, z ), v );
+											ArrayXdBytes.PeriodicBounds( o2, l2, z ), ArrayXdBytes.PeriodicBounds( o3, l3, z ), v );
 			RETURN v
 		END Get4BPeriodic;
 
@@ -228,7 +228,7 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			ArrayXdBytes.Get3( SELF, ArrayXdBytes.MirrorOffB( o0, l0, x ), ArrayXdBytes.MirrorOffB( o1, l1, y ),
-											 ArrayXdBytes.MirrorOffB( o2, l2, z ), v );
+											ArrayXdBytes.MirrorOffB( o2, l2, z ), v );
 			RETURN v
 		END Get3BSymmetricOffB;
 
@@ -236,7 +236,7 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			ArrayXdBytes.Get4( SELF, ArrayXdBytes.MirrorOffB( o0, l0, x ), ArrayXdBytes.MirrorOffB( o1, l1, y ),
-											 ArrayXdBytes.MirrorOffB( o2, l2, z ), ArrayXdBytes.MirrorOffB( o3, l3, z ), v );
+											ArrayXdBytes.MirrorOffB( o2, l2, z ), ArrayXdBytes.MirrorOffB( o3, l3, z ), v );
 			RETURN v
 		END Get4BSymmetricOffB;
 
@@ -311,7 +311,7 @@ TYPE
 				ArrayXdBytes.Get3( SELF, x, y, z, v );  RETURN v
 			ELSE
 				ArrayXdBytes.Get3( SELF, ArrayXdBytes.MirrorOffB( o0, l0, x ), ArrayXdBytes.MirrorOffB( o1, l1, y ),
-												 ArrayXdBytes.MirrorOffB( o2, l2, z ), v );
+												ArrayXdBytes.MirrorOffB( o2, l2, z ), v );
 				RETURN -v
 			END;
 		END Get3BAntisymmetricOffB;
@@ -320,11 +320,11 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			IF ArrayXdBytes.InBounds( o0, l0, x ) & ArrayXdBytes.InBounds( o1, l1, y ) & ArrayXdBytes.InBounds( o2, l2, z ) &
-			    ArrayXdBytes.InBounds( o3, l3, t ) THEN
-				ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
+				ArrayXdBytes.InBounds( o3, l3, t ) THEN
+					ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
 			ELSE
 				ArrayXdBytes.Get4( SELF, ArrayXdBytes.MirrorOffB( o0, l0, x ), ArrayXdBytes.MirrorOffB( o1, l1, y ),
-												 ArrayXdBytes.MirrorOffB( o2, l2, z ), ArrayXdBytes.MirrorOffB( o3, l3, t ), v );
+												ArrayXdBytes.MirrorOffB( o2, l2, z ), ArrayXdBytes.MirrorOffB( o3, l3, t ), v );
 				RETURN -v
 			END;
 		END Get4BAntisymmetricOffB;
@@ -367,7 +367,7 @@ TYPE
 				ArrayXdBytes.Get3( SELF, x, y, z, v );  RETURN v
 			ELSE
 				ArrayXdBytes.Get3( SELF, ArrayXdBytes.MirrorOnB( o0, l0, x ), ArrayXdBytes.MirrorOnB( o1, l1, y ),
-												 ArrayXdBytes.MirrorOnB( o2, l2, z ), v );
+												ArrayXdBytes.MirrorOnB( o2, l2, z ), v );
 				RETURN -v
 			END;
 		END Get3BAntisymmetricOnB;
@@ -376,11 +376,11 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			IF ArrayXdBytes.InBounds( o0, l0, x ) & ArrayXdBytes.InBounds( o1, l1, y ) & ArrayXdBytes.InBounds( o2, l2, z ) &
-			    ArrayXdBytes.InBounds( o3, l3, t ) THEN
-				ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
+				ArrayXdBytes.InBounds( o3, l3, t ) THEN
+					ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
 			ELSE
 				ArrayXdBytes.Get4( SELF, ArrayXdBytes.MirrorOnB( o0, l0, x ), ArrayXdBytes.MirrorOnB( o1, l1, y ),
-												 ArrayXdBytes.MirrorOnB( o2, l2, z ), ArrayXdBytes.MirrorOnB( o3, l3, t ), v );
+												ArrayXdBytes.MirrorOnB( o2, l2, z ), ArrayXdBytes.MirrorOnB( o3, l3, t ), v );
 				RETURN -v
 			END;
 		END Get4BAntisymmetricOnB;
@@ -529,7 +529,7 @@ VAR
 	BEGIN
 		IF (src.dim # 1) OR (dest.dim # 1) THEN HALT( 1001 ) END;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index1( srcx ), ArrayXdBytes.Index1( len ),
-																		   ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
 	END CopyVecToVec;
 
 	PROCEDURE CopyMtxToVec*( src, dest: Array;  dim: Index;  srcx, srcy, destx, len: Index );
@@ -538,7 +538,7 @@ VAR
 		IF (src.dim # 2) OR (dest.dim # 1) THEN HALT( 1002 ) END;
 		slen := ArrayXdBytes.Index2( 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index2( srcx, srcy ), slen,
-																		   ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
 	END CopyMtxToVec;
 
 	PROCEDURE CopyVecToMtx*( src, dest: Array;  dim: Index;  srcx, destx, desty, len: Index );
@@ -547,7 +547,7 @@ VAR
 		IF (src.dim # 1) OR (dest.dim # 2) THEN HALT( 1002 ) END;
 		slen := ArrayXdBytes.Index2( 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index1( srcx ), ArrayXdBytes.Index1( len ),
-																		   ArrayXdBytes.Index2( destx, desty ), slen );
+																		ArrayXdBytes.Index2( destx, desty ), slen );
 	END CopyVecToMtx;
 
 	PROCEDURE CopyCubeToVec*( src, dest: Array;  dim: Index;  srcx, srcy, srcz, destx, len: Index );
@@ -556,7 +556,7 @@ VAR
 		IF (src.dim # 3) OR (dest.dim # 1) THEN HALT( 1003 ) END;
 		slen := ArrayXdBytes.Index3( 1, 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ), slen,
-																		   ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
 	END CopyCubeToVec;
 
 	PROCEDURE CopyVecToCube*( src, dest: Array;  dim: Index;  srcx, destx, desty, destz, len: Index );
@@ -565,7 +565,7 @@ VAR
 		IF (src.dim # 1) OR (dest.dim # 3) THEN HALT( 1002 ) END;
 		slen := ArrayXdBytes.Index3( 1, 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index1( srcx ), ArrayXdBytes.Index1( len ),
-																		   ArrayXdBytes.Index3( destx, desty, destz ), slen );
+																		ArrayXdBytes.Index3( destx, desty, destz ), slen );
 	END CopyVecToCube;
 
 	PROCEDURE CopyHCubeToVec*( src, dest: Array;  dim: Index;  srcx, srcy, srcz, srct, destx, len: Index );
@@ -574,7 +574,7 @@ VAR
 		IF (src.dim # 4) OR (dest.dim # 1) THEN HALT( 1004 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ), slen,
-																		   ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
 	END CopyHCubeToVec;
 
 	PROCEDURE CopyVecToHCube*( src, dest: Array;  dim: Index;  srcx, destx, desty, destz, destt, len: Index );
@@ -583,7 +583,7 @@ VAR
 		IF (src.dim # 1) OR (dest.dim # 4) THEN HALT( 1002 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index1( srcx ), ArrayXdBytes.Index1( len ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
 	END CopyVecToHCube;
 
 	PROCEDURE CopyMtxToMtx*( src, dest: Array;  srcx, srcy, destx, desty, lenx, leny: Index );
@@ -592,7 +592,7 @@ VAR
 		IF (src.dim # 2) OR (dest.dim # 2) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index2( lenx, leny );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index2( srcx, srcy ), slen,
-																		   ArrayXdBytes.Index2( destx, desty ), slen );
+																		ArrayXdBytes.Index2( destx, desty ), slen );
 	END CopyMtxToMtx;
 
 	PROCEDURE CopyCubeToMtx*( src, dest: Array;  dimx, dimy: Index;  srcx, srcy, srcz, destx, desty, lenx, leny: Index );
@@ -601,7 +601,7 @@ VAR
 		IF (src.dim # 3) OR (dest.dim # 2) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index3( 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ), slen,
-																		   ArrayXdBytes.Index2( destx, desty ), ArrayXdBytes.Index2( lenx, leny ) );
+																		ArrayXdBytes.Index2( destx, desty ), ArrayXdBytes.Index2( lenx, leny ) );
 	END CopyCubeToMtx;
 
 	PROCEDURE CopyMtxToCube*( src, dest: Array;  dimx, dimy: Index;  srcx, srcy, destx, desty, destz, lenx, leny: Index );
@@ -610,7 +610,7 @@ VAR
 		IF (src.dim # 2) OR (dest.dim # 3) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index3( 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index2( srcx, srcy ), ArrayXdBytes.Index2( lenx, leny ),
-																		   ArrayXdBytes.Index3( destx, desty, destz ), slen );
+																		ArrayXdBytes.Index3( destx, desty, destz ), slen );
 	END CopyMtxToCube;
 
 	PROCEDURE CopyHCubeToMtx*( src, dest: Array;  dimx, dimy: Index;  srcx, srcy, srcz, srct, destx, desty, lenx, leny: Index );
@@ -619,17 +619,17 @@ VAR
 		IF (src.dim # 4) OR (dest.dim # 2) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ), slen,
-																		   ArrayXdBytes.Index2( destx, desty ), ArrayXdBytes.Index2( lenx, leny ) );
+																		ArrayXdBytes.Index2( destx, desty ), ArrayXdBytes.Index2( lenx, leny ) );
 	END CopyHCubeToMtx;
 
 	PROCEDURE CopyMtxToHCube*( src, dest: Array;  dimx, dimy: Index;
-														 srcx, srcy, destx, desty, destz, destt, lenx, leny: Index );
+														srcx, srcy, destx, desty, destz, destt, lenx, leny: Index );
 	VAR slen: ArrayXdBytes.IndexArray;
 	BEGIN
 		IF (src.dim # 2) OR (dest.dim # 4) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index2( srcx, srcy ), ArrayXdBytes.Index2( lenx, leny ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
 	END CopyMtxToHCube;
 
 	PROCEDURE CopyCubeToCube*( src, dest: Array;  srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
@@ -638,39 +638,39 @@ VAR
 		IF (src.dim # 3) OR (dest.dim # 3) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index3( lenx, leny, lenz );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ), slen,
-																		   ArrayXdBytes.Index3( destx, desty, destz ), slen );
+																		ArrayXdBytes.Index3( destx, desty, destz ), slen );
 	END CopyCubeToCube;
 
 	PROCEDURE CopyHCubeToCube*( src, dest: Array;  dimx, dimy, dimz: Index;
-														  srcx, srcy, srcz, srct, destx, desty, destz, lenx, leny, lenz: Index );
+														srcx, srcy, srcz, srct, destx, desty, destz, lenx, leny, lenz: Index );
 	VAR slen: ArrayXdBytes.IndexArray;
 	BEGIN
 		IF (src.dim # 4) OR (dest.dim # 3) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;  slen[dimz] := lenz;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ), slen,
-																		   ArrayXdBytes.Index3( destx, desty, destz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ) );
+																		ArrayXdBytes.Index3( destx, desty, destz ),
+																		ArrayXdBytes.Index3( lenx, leny, lenz ) );
 	END CopyHCubeToCube;
 
 	PROCEDURE CopyCubeToHCube*( src, dest: Array;  dimx, dimy, dimz: Index;
-														  srcx, srcy, srcz, destx, desty, destz, destt, lenx, leny, lenz: Index );
+														srcx, srcy, srcz, destx, desty, destz, destt, lenx, leny, lenz: Index );
 	VAR slen: ArrayXdBytes.IndexArray;
 	BEGIN
 		IF (src.dim # 3) OR (dest.dim # 4) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;  slen[dimz] := lenz;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
+																		ArrayXdBytes.Index3( lenx, leny, lenz ),
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
 	END CopyCubeToHCube;
 
 	PROCEDURE CopyHCubeToHCube*( src, dest: Array;
-															 srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
+															srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
 	VAR slen: ArrayXdBytes.IndexArray;
 	BEGIN
 		IF (src.dim # 4) OR (dest.dim # 4) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( lenx, leny, lenz, lent );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ), slen,
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
 	END CopyHCubeToHCube;
 
 	PROCEDURE CopyArrayToVec*( VAR src: ARRAY OF Value;  dest: Array;  srcx, destx, len: Index );
@@ -678,7 +678,7 @@ VAR
 		IF dest.dim # 1 THEN HALT( 1005 ) END;
 		ArrayXdBytes.CheckLEQ( 0, srcx );  ArrayXdBytes.CheckLE( srcx + len, LEN( src ) );
 		ArrayXdBytes.CopyMemoryToArrayPart( ADDRESSOF( src[srcx] ), dest, len, ArrayXdBytes.Index1( destx ),
-																		 ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( len ) );
 	END CopyArrayToVec;
 
 	PROCEDURE CopyVecToArray*( src: Array;  VAR dest: ARRAY OF Value;  srcx, destx, len: Index );
@@ -686,7 +686,7 @@ VAR
 		IF src.dim # 1 THEN HALT( 1005 ) END;
 		ArrayXdBytes.CheckLEQ( 0, destx );  ArrayXdBytes.CheckLE( destx + len, LEN( dest ) );
 		ArrayXdBytes.CopyArrayPartToMemory( src, ADDRESSOF( dest[destx] ), ArrayXdBytes.Index1( srcx ),
-																		 ArrayXdBytes.Index1( len ), len );
+																		ArrayXdBytes.Index1( len ), len );
 	END CopyVecToArray;
 
 	PROCEDURE CopyArrayToMtx*( VAR src: ARRAY OF ARRAY OF Value;  dest: Array;  srcx, srcy, destx, desty, lenx, leny: Index );
@@ -695,10 +695,10 @@ VAR
 		IF dest.dim # 2 THEN HALT( 1005 ) END;
 		srcmem :=
 			ArrayXdBytes.MakeMemoryStructure( 2, ArrayXdBytes.Index2( 0, 0 ), ArrayXdBytes.Index2( LEN( src, 1 ), LEN( src, 0 ) ),
-																		  SIZEOF( Value ), ADDRESSOF( src[0, 0] ) );
+																		SIZEOF( Value ), ADDRESSOF( src[0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( srcmem, dest, ArrayXdBytes.Index2( srcx, srcy ),
-																		   ArrayXdBytes.Index2( lenx, leny ), ArrayXdBytes.Index2( destx, desty ),
-																		   ArrayXdBytes.Index2( lenx, leny ) );
+																		ArrayXdBytes.Index2( lenx, leny ), ArrayXdBytes.Index2( destx, desty ),
+																		ArrayXdBytes.Index2( lenx, leny ) );
 	END CopyArrayToMtx;
 
 	PROCEDURE CopyMtxToArray*( src: Array;  VAR dest: ARRAY OF ARRAY OF Value;  srcx, srcy, destx, desty, lenx, leny: Index );
@@ -707,80 +707,80 @@ VAR
 		IF src.dim # 2 THEN HALT( 1005 ) END;
 		destmem :=
 			ArrayXdBytes.MakeMemoryStructure( 2, ArrayXdBytes.Index2( 0, 0 ), ArrayXdBytes.Index2( LEN( dest, 1 ), LEN( dest, 0 ) ),
-																		  SIZEOF( Value ), ADDRESSOF( dest[0, 0] ) );
+																		SIZEOF( Value ), ADDRESSOF( dest[0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, destmem, ArrayXdBytes.Index2( srcx, srcy ),
-																		   ArrayXdBytes.Index2( lenx, leny ), ArrayXdBytes.Index2( destx, desty ),
-																		   ArrayXdBytes.Index2( lenx, leny ) );
+																		ArrayXdBytes.Index2( lenx, leny ), ArrayXdBytes.Index2( destx, desty ),
+																		ArrayXdBytes.Index2( lenx, leny ) );
 	END CopyMtxToArray;
 
 	PROCEDURE CopyArrayToCube*( VAR src: ARRAY OF ARRAY OF ARRAY OF Value;  dest: Array;
-													    srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
+													srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
 	VAR srcmem: ArrayXdBytes.ArrayMemoryStructure;
 	BEGIN
 		IF dest.dim # 3 THEN HALT( 1005 ) END;
 		srcmem :=
 			ArrayXdBytes.MakeMemoryStructure( 3, ArrayXdBytes.Index3( 0, 0, 0 ),
-																		  ArrayXdBytes.Index3( LEN( src, 2 ), LEN( src, 1 ), LEN( src, 0 ) ), SIZEOF( Value ),
-																		  ADDRESSOF( src[0, 0, 0] ) );
+																		ArrayXdBytes.Index3( LEN( src, 2 ), LEN( src, 1 ), LEN( src, 0 ) ), SIZEOF( Value ),
+																		ADDRESSOF( src[0, 0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( srcmem, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ),
-																		   ArrayXdBytes.Index3( destx, desty, destz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ) );
+																		ArrayXdBytes.Index3( lenx, leny, lenz ),
+																		ArrayXdBytes.Index3( destx, desty, destz ),
+																		ArrayXdBytes.Index3( lenx, leny, lenz ) );
 	END CopyArrayToCube;
 
 	PROCEDURE CopyCubeToArray*( src: Array;  VAR dest: ARRAY OF ARRAY OF ARRAY OF Value;
-													    srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
+													srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
 	VAR destmem: ArrayXdBytes.ArrayMemoryStructure;
 	BEGIN
 		IF src.dim # 3 THEN HALT( 1005 ) END;
 		destmem :=
 			ArrayXdBytes.MakeMemoryStructure( 3, ArrayXdBytes.Index3( 0, 0, 0 ),
-																		  ArrayXdBytes.Index3( LEN( dest, 2 ), LEN( dest, 1 ), LEN( dest, 0 ) ), SIZEOF( Value ),
-																		  ADDRESSOF( dest[0, 0, 0] ) );
+																		ArrayXdBytes.Index3( LEN( dest, 2 ), LEN( dest, 1 ), LEN( dest, 0 ) ), SIZEOF( Value ),
+																		ADDRESSOF( dest[0, 0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, destmem, ArrayXdBytes.Index3( srcx, srcy, srcz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ),
-																		   ArrayXdBytes.Index3( destx, desty, destz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ) );
+																		ArrayXdBytes.Index3( lenx, leny, lenz ),
+																		ArrayXdBytes.Index3( destx, desty, destz ),
+																		ArrayXdBytes.Index3( lenx, leny, lenz ) );
 	END CopyCubeToArray;
 
 	PROCEDURE CopyArrayToHCube*( VAR src: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value;  dest: Array;
-														  srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
+														srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
 	VAR srcmem: ArrayXdBytes.ArrayMemoryStructure;
 	BEGIN
 		IF dest.dim # 4 THEN HALT( 1005 ) END;
 		srcmem :=
 			ArrayXdBytes.MakeMemoryStructure( 4, ArrayXdBytes.Index4( 0, 0, 0, 0 ),
-																		  ArrayXdBytes.Index4( LEN( src, 3 ), LEN( src, 2 ), LEN( src, 1 ), LEN( src, 0 ) ), SIZEOF( Value ),
-																		  ADDRESSOF( src[0, 0, 0] ) );
+																		ArrayXdBytes.Index4( LEN( src, 3 ), LEN( src, 2 ), LEN( src, 1 ), LEN( src, 0 ) ), SIZEOF( Value ),
+																		ADDRESSOF( src[0, 0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( srcmem, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ),
-																		   ArrayXdBytes.Index4( lenx, leny, lenz, lent ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ),
-																		   ArrayXdBytes.Index4( lenx, leny, lenz, lent ) );
+																		ArrayXdBytes.Index4( lenx, leny, lenz, lent ),
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ),
+																		ArrayXdBytes.Index4( lenx, leny, lenz, lent ) );
 	END CopyArrayToHCube;
 
 	PROCEDURE CopyHCubeToArray*( src: Array;  VAR dest: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value;
-														  srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
+														srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
 	VAR destmem: ArrayXdBytes.ArrayMemoryStructure;
 	BEGIN
 		IF src.dim # 4 THEN HALT( 1005 ) END;
 		destmem :=
 			ArrayXdBytes.MakeMemoryStructure( 4, ArrayXdBytes.Index4( 0, 0, 0, 0 ),
-																		  ArrayXdBytes.Index4( LEN( dest, 3 ), LEN( dest, 2 ), LEN( dest, 1 ), LEN( dest, 0 ) ), SIZEOF( Value ),
-																		  ADDRESSOF( dest[0, 0, 0] ) );
+																		ArrayXdBytes.Index4( LEN( dest, 3 ), LEN( dest, 2 ), LEN( dest, 1 ), LEN( dest, 0 ) ), SIZEOF( Value ),
+																		ADDRESSOF( dest[0, 0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, destmem, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ),
-																		   ArrayXdBytes.Index4( lenx, leny, lenz, lent ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ),
-																		   ArrayXdBytes.Index4( lenx, leny, lenz, lent ) );
+																		ArrayXdBytes.Index4( lenx, leny, lenz, lent ),
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ),
+																		ArrayXdBytes.Index4( lenx, leny, lenz, lent ) );
 	END CopyHCubeToArray;
 
 	PROCEDURE CopyArrayToArrayPartB*( src: Array;  dest: ArrayXdBytes.ArrayMemoryStructure;  boundaryCondition: SHORTINT;
-																 srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray );
+																srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray );
 
 	VAR temp: ArrayXdBytes.ArrayMemoryStructure;
 		spos, dpos, last, borigin, blen, srcposcut, srclencut, destoffset: ArrayXdBytes.IndexArray;  i, dim: LONGINT;
 		val: Value;  temp2: Array;  enumB: ArrayXdBytes.BoundaryEnum;
 		Get: PROCEDURE {DELEGATE} ( x: ARRAY OF Index;
-																																													 dim: Index ): Value;
+																																													dim: Index ): Value;
 		noinbound: BOOLEAN;  v: Value;
 
 		(* for debugging
@@ -924,7 +924,7 @@ VAR
 	OPERATOR ":="*( VAR l: Array;  r: IntValue );
 	VAR r1: Value;
 	BEGIN
-	  r1 := r; l := r1;
+		r1 := r; l := r1;
 	END ":=";
 	*)
 

source/ArrayXdRe.Mod

@@ -155,8 +155,8 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			IF ArrayXdBytes.InBounds( o0, l0, x ) & ArrayXdBytes.InBounds( o1, l1, y ) & ArrayXdBytes.InBounds( o2, l2, z ) &
-			    ArrayXdBytes.InBounds( o3, l3, t ) THEN
-				ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
+				ArrayXdBytes.InBounds( o3, l3, t ) THEN
+					ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
 			ELSE RETURN 0
 			END;
 		END Get4BAbsorbing;
@@ -191,7 +191,7 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			ArrayXdBytes.Get3( SELF, ArrayXdBytes.PeriodicBounds( o0, l0, x ), ArrayXdBytes.PeriodicBounds( o1, l1, y ),
-											 ArrayXdBytes.PeriodicBounds( o2, l2, z ), v );
+											ArrayXdBytes.PeriodicBounds( o2, l2, z ), v );
 			RETURN v
 		END Get3BPeriodic;
 
@@ -199,7 +199,7 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			ArrayXdBytes.Get4( SELF, ArrayXdBytes.PeriodicBounds( o0, l0, x ), ArrayXdBytes.PeriodicBounds( o1, l1, y ),
-											 ArrayXdBytes.PeriodicBounds( o2, l2, z ), ArrayXdBytes.PeriodicBounds( o3, l3, z ), v );
+											ArrayXdBytes.PeriodicBounds( o2, l2, z ), ArrayXdBytes.PeriodicBounds( o3, l3, z ), v );
 			RETURN v
 		END Get4BPeriodic;
 
@@ -228,7 +228,7 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			ArrayXdBytes.Get3( SELF, ArrayXdBytes.MirrorOffB( o0, l0, x ), ArrayXdBytes.MirrorOffB( o1, l1, y ),
-											 ArrayXdBytes.MirrorOffB( o2, l2, z ), v );
+											ArrayXdBytes.MirrorOffB( o2, l2, z ), v );
 			RETURN v
 		END Get3BSymmetricOffB;
 
@@ -236,7 +236,7 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			ArrayXdBytes.Get4( SELF, ArrayXdBytes.MirrorOffB( o0, l0, x ), ArrayXdBytes.MirrorOffB( o1, l1, y ),
-											 ArrayXdBytes.MirrorOffB( o2, l2, z ), ArrayXdBytes.MirrorOffB( o3, l3, z ), v );
+											ArrayXdBytes.MirrorOffB( o2, l2, z ), ArrayXdBytes.MirrorOffB( o3, l3, z ), v );
 			RETURN v
 		END Get4BSymmetricOffB;
 
@@ -311,7 +311,7 @@ TYPE
 				ArrayXdBytes.Get3( SELF, x, y, z, v );  RETURN v
 			ELSE
 				ArrayXdBytes.Get3( SELF, ArrayXdBytes.MirrorOffB( o0, l0, x ), ArrayXdBytes.MirrorOffB( o1, l1, y ),
-												 ArrayXdBytes.MirrorOffB( o2, l2, z ), v );
+												ArrayXdBytes.MirrorOffB( o2, l2, z ), v );
 				RETURN -v
 			END;
 		END Get3BAntisymmetricOffB;
@@ -320,11 +320,11 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			IF ArrayXdBytes.InBounds( o0, l0, x ) & ArrayXdBytes.InBounds( o1, l1, y ) & ArrayXdBytes.InBounds( o2, l2, z ) &
-			    ArrayXdBytes.InBounds( o3, l3, t ) THEN
-				ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
+				ArrayXdBytes.InBounds( o3, l3, t ) THEN
+					ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
 			ELSE
 				ArrayXdBytes.Get4( SELF, ArrayXdBytes.MirrorOffB( o0, l0, x ), ArrayXdBytes.MirrorOffB( o1, l1, y ),
-												 ArrayXdBytes.MirrorOffB( o2, l2, z ), ArrayXdBytes.MirrorOffB( o3, l3, t ), v );
+												ArrayXdBytes.MirrorOffB( o2, l2, z ), ArrayXdBytes.MirrorOffB( o3, l3, t ), v );
 				RETURN -v
 			END;
 		END Get4BAntisymmetricOffB;
@@ -367,7 +367,7 @@ TYPE
 				ArrayXdBytes.Get3( SELF, x, y, z, v );  RETURN v
 			ELSE
 				ArrayXdBytes.Get3( SELF, ArrayXdBytes.MirrorOnB( o0, l0, x ), ArrayXdBytes.MirrorOnB( o1, l1, y ),
-												 ArrayXdBytes.MirrorOnB( o2, l2, z ), v );
+												ArrayXdBytes.MirrorOnB( o2, l2, z ), v );
 				RETURN -v
 			END;
 		END Get3BAntisymmetricOnB;
@@ -376,11 +376,11 @@ TYPE
 		VAR v: Value;
 		BEGIN
 			IF ArrayXdBytes.InBounds( o0, l0, x ) & ArrayXdBytes.InBounds( o1, l1, y ) & ArrayXdBytes.InBounds( o2, l2, z ) &
-			    ArrayXdBytes.InBounds( o3, l3, t ) THEN
-				ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
+				ArrayXdBytes.InBounds( o3, l3, t ) THEN
+					ArrayXdBytes.Get4( SELF, x, y, z, t, v );  RETURN v
 			ELSE
 				ArrayXdBytes.Get4( SELF, ArrayXdBytes.MirrorOnB( o0, l0, x ), ArrayXdBytes.MirrorOnB( o1, l1, y ),
-												 ArrayXdBytes.MirrorOnB( o2, l2, z ), ArrayXdBytes.MirrorOnB( o3, l3, t ), v );
+												ArrayXdBytes.MirrorOnB( o2, l2, z ), ArrayXdBytes.MirrorOnB( o3, l3, t ), v );
 				RETURN -v
 			END;
 		END Get4BAntisymmetricOnB;
@@ -520,7 +520,7 @@ TYPE
 	BEGIN
 		IF (src.dim # 1) OR (dest.dim # 1) THEN HALT( 1001 ) END;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index1( srcx ), ArrayXdBytes.Index1( len ),
-																		   ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
 	END CopyVecToVec;
 
 	PROCEDURE CopyMtxToVec*( src, dest: Array;  dim: Index;  srcx, srcy, destx, len: Index );
@@ -529,7 +529,7 @@ TYPE
 		IF (src.dim # 2) OR (dest.dim # 1) THEN HALT( 1002 ) END;
 		slen := ArrayXdBytes.Index2( 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index2( srcx, srcy ), slen,
-																		   ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
 	END CopyMtxToVec;
 
 	PROCEDURE CopyVecToMtx*( src, dest: Array;  dim: Index;  srcx, destx, desty, len: Index );
@@ -538,7 +538,7 @@ TYPE
 		IF (src.dim # 1) OR (dest.dim # 2) THEN HALT( 1002 ) END;
 		slen := ArrayXdBytes.Index2( 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index1( srcx ), ArrayXdBytes.Index1( len ),
-																		   ArrayXdBytes.Index2( destx, desty ), slen );
+																		ArrayXdBytes.Index2( destx, desty ), slen );
 	END CopyVecToMtx;
 
 	PROCEDURE CopyCubeToVec*( src, dest: Array;  dim: Index;  srcx, srcy, srcz, destx, len: Index );
@@ -547,7 +547,7 @@ TYPE
 		IF (src.dim # 3) OR (dest.dim # 1) THEN HALT( 1003 ) END;
 		slen := ArrayXdBytes.Index3( 1, 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ), slen,
-																		   ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
 	END CopyCubeToVec;
 
 	PROCEDURE CopyVecToCube*( src, dest: Array;  dim: Index;  srcx, destx, desty, destz, len: Index );
@@ -556,7 +556,7 @@ TYPE
 		IF (src.dim # 1) OR (dest.dim # 3) THEN HALT( 1002 ) END;
 		slen := ArrayXdBytes.Index3( 1, 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index1( srcx ), ArrayXdBytes.Index1( len ),
-																		   ArrayXdBytes.Index3( destx, desty, destz ), slen );
+																		ArrayXdBytes.Index3( destx, desty, destz ), slen );
 	END CopyVecToCube;
 
 	PROCEDURE CopyHCubeToVec*( src, dest: Array;  dim: Index;  srcx, srcy, srcz, srct, destx, len: Index );
@@ -565,7 +565,7 @@ TYPE
 		IF (src.dim # 4) OR (dest.dim # 1) THEN HALT( 1004 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ), slen,
-																		   ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( destx ), ArrayXdBytes.Index1( len ) );
 	END CopyHCubeToVec;
 
 	PROCEDURE CopyVecToHCube*( src, dest: Array;  dim: Index;  srcx, destx, desty, destz, destt, len: Index );
@@ -574,7 +574,7 @@ TYPE
 		IF (src.dim # 1) OR (dest.dim # 4) THEN HALT( 1002 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dim] := len;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index1( srcx ), ArrayXdBytes.Index1( len ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
 	END CopyVecToHCube;
 
 	PROCEDURE CopyMtxToMtx*( src, dest: Array;  srcx, srcy, destx, desty, lenx, leny: Index );
@@ -583,7 +583,7 @@ TYPE
 		IF (src.dim # 2) OR (dest.dim # 2) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index2( lenx, leny );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index2( srcx, srcy ), slen,
-																		   ArrayXdBytes.Index2( destx, desty ), slen );
+																		ArrayXdBytes.Index2( destx, desty ), slen );
 	END CopyMtxToMtx;
 
 	PROCEDURE CopyCubeToMtx*( src, dest: Array;  dimx, dimy: Index;  srcx, srcy, srcz, destx, desty, lenx, leny: Index );
@@ -592,7 +592,7 @@ TYPE
 		IF (src.dim # 3) OR (dest.dim # 2) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index3( 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ), slen,
-																		   ArrayXdBytes.Index2( destx, desty ), ArrayXdBytes.Index2( lenx, leny ) );
+																		ArrayXdBytes.Index2( destx, desty ), ArrayXdBytes.Index2( lenx, leny ) );
 	END CopyCubeToMtx;
 
 	PROCEDURE CopyMtxToCube*( src, dest: Array;  dimx, dimy: Index;  srcx, srcy, destx, desty, destz, lenx, leny: Index );
@@ -601,7 +601,7 @@ TYPE
 		IF (src.dim # 2) OR (dest.dim # 3) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index3( 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index2( srcx, srcy ), ArrayXdBytes.Index2( lenx, leny ),
-																		   ArrayXdBytes.Index3( destx, desty, destz ), slen );
+																		ArrayXdBytes.Index3( destx, desty, destz ), slen );
 	END CopyMtxToCube;
 
 	PROCEDURE CopyHCubeToMtx*( src, dest: Array;  dimx, dimy: Index;  srcx, srcy, srcz, srct, destx, desty, lenx, leny: Index );
@@ -610,17 +610,17 @@ TYPE
 		IF (src.dim # 4) OR (dest.dim # 2) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ), slen,
-																		   ArrayXdBytes.Index2( destx, desty ), ArrayXdBytes.Index2( lenx, leny ) );
+																		ArrayXdBytes.Index2( destx, desty ), ArrayXdBytes.Index2( lenx, leny ) );
 	END CopyHCubeToMtx;
 
 	PROCEDURE CopyMtxToHCube*( src, dest: Array;  dimx, dimy: Index;
-														 srcx, srcy, destx, desty, destz, destt, lenx, leny: Index );
+														srcx, srcy, destx, desty, destz, destt, lenx, leny: Index );
 	VAR slen: ArrayXdBytes.IndexArray;
 	BEGIN
 		IF (src.dim # 2) OR (dest.dim # 4) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index2( srcx, srcy ), ArrayXdBytes.Index2( lenx, leny ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
 	END CopyMtxToHCube;
 
 	PROCEDURE CopyCubeToCube*( src, dest: Array;  srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
@@ -629,39 +629,39 @@ TYPE
 		IF (src.dim # 3) OR (dest.dim # 3) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index3( lenx, leny, lenz );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ), slen,
-																		   ArrayXdBytes.Index3( destx, desty, destz ), slen );
+																		ArrayXdBytes.Index3( destx, desty, destz ), slen );
 	END CopyCubeToCube;
 
 	PROCEDURE CopyHCubeToCube*( src, dest: Array;  dimx, dimy, dimz: Index;
-														  srcx, srcy, srcz, srct, destx, desty, destz, lenx, leny, lenz: Index );
+														srcx, srcy, srcz, srct, destx, desty, destz, lenx, leny, lenz: Index );
 	VAR slen: ArrayXdBytes.IndexArray;
 	BEGIN
 		IF (src.dim # 4) OR (dest.dim # 3) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;  slen[dimz] := lenz;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ), slen,
-																		   ArrayXdBytes.Index3( destx, desty, destz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ) );
+																		ArrayXdBytes.Index3( destx, desty, destz ),
+																		ArrayXdBytes.Index3( lenx, leny, lenz ) );
 	END CopyHCubeToCube;
 
 	PROCEDURE CopyCubeToHCube*( src, dest: Array;  dimx, dimy, dimz: Index;
-														  srcx, srcy, srcz, destx, desty, destz, destt, lenx, leny, lenz: Index );
+														srcx, srcy, srcz, destx, desty, destz, destt, lenx, leny, lenz: Index );
 	VAR slen: ArrayXdBytes.IndexArray;
 	BEGIN
 		IF (src.dim # 3) OR (dest.dim # 4) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( 1, 1, 1, 1 );  slen[dimx] := lenx;  slen[dimy] := leny;  slen[dimz] := lenz;
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
+																		ArrayXdBytes.Index3( lenx, leny, lenz ),
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
 	END CopyCubeToHCube;
 
 	PROCEDURE CopyHCubeToHCube*( src, dest: Array;
-															 srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
+															srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
 	VAR slen: ArrayXdBytes.IndexArray;
 	BEGIN
 		IF (src.dim # 4) OR (dest.dim # 4) THEN HALT( 1005 ) END;
 		slen := ArrayXdBytes.Index4( lenx, leny, lenz, lent );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ), slen,
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ), slen );
 	END CopyHCubeToHCube;
 
 	PROCEDURE CopyArrayToVec*( VAR src: ARRAY OF Value;  dest: Array;  srcx, destx, len: Index );
@@ -669,7 +669,7 @@ TYPE
 		IF dest.dim # 1 THEN HALT( 1005 ) END;
 		ArrayXdBytes.CheckLEQ( 0, srcx );  ArrayXdBytes.CheckLE( srcx + len, LEN( src ) );
 		ArrayXdBytes.CopyMemoryToArrayPart( ADDRESSOF( src[srcx] ), dest, len, ArrayXdBytes.Index1( destx ),
-																		 ArrayXdBytes.Index1( len ) );
+																		ArrayXdBytes.Index1( len ) );
 	END CopyArrayToVec;
 
 	PROCEDURE CopyVecToArray*( src: Array;  VAR dest: ARRAY OF Value;  srcx, destx, len: Index );
@@ -677,7 +677,7 @@ TYPE
 		IF src.dim # 1 THEN HALT( 1005 ) END;
 		ArrayXdBytes.CheckLEQ( 0, destx );  ArrayXdBytes.CheckLE( destx + len, LEN( dest ) );
 		ArrayXdBytes.CopyArrayPartToMemory( src, ADDRESSOF( dest[destx] ), ArrayXdBytes.Index1( srcx ),
-																		 ArrayXdBytes.Index1( len ), len );
+																		ArrayXdBytes.Index1( len ), len );
 	END CopyVecToArray;
 
 	PROCEDURE CopyArrayToMtx*( VAR src: ARRAY OF ARRAY OF Value;  dest: Array;  srcx, srcy, destx, desty, lenx, leny: Index );
@@ -686,10 +686,10 @@ TYPE
 		IF dest.dim # 2 THEN HALT( 1005 ) END;
 		srcmem :=
 			ArrayXdBytes.MakeMemoryStructure( 2, ArrayXdBytes.Index2( 0, 0 ), ArrayXdBytes.Index2( LEN( src, 1 ), LEN( src, 0 ) ),
-																		  SIZEOF( Value ), ADDRESSOF( src[0, 0] ) );
+																		SIZEOF( Value ), ADDRESSOF( src[0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( srcmem, dest, ArrayXdBytes.Index2( srcx, srcy ),
-																		   ArrayXdBytes.Index2( lenx, leny ), ArrayXdBytes.Index2( destx, desty ),
-																		   ArrayXdBytes.Index2( lenx, leny ) );
+																		ArrayXdBytes.Index2( lenx, leny ), ArrayXdBytes.Index2( destx, desty ),
+																		ArrayXdBytes.Index2( lenx, leny ) );
 	END CopyArrayToMtx;
 
 	PROCEDURE CopyMtxToArray*( src: Array;  VAR dest: ARRAY OF ARRAY OF Value;  srcx, srcy, destx, desty, lenx, leny: Index );
@@ -698,80 +698,80 @@ TYPE
 		IF src.dim # 2 THEN HALT( 1005 ) END;
 		destmem :=
 			ArrayXdBytes.MakeMemoryStructure( 2, ArrayXdBytes.Index2( 0, 0 ), ArrayXdBytes.Index2( LEN( dest, 1 ), LEN( dest, 0 ) ),
-																		  SIZEOF( Value ), ADDRESSOF( dest[0, 0] ) );
+																		SIZEOF( Value ), ADDRESSOF( dest[0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, destmem, ArrayXdBytes.Index2( srcx, srcy ),
-																		   ArrayXdBytes.Index2( lenx, leny ), ArrayXdBytes.Index2( destx, desty ),
-																		   ArrayXdBytes.Index2( lenx, leny ) );
+																		ArrayXdBytes.Index2( lenx, leny ), ArrayXdBytes.Index2( destx, desty ),
+																		ArrayXdBytes.Index2( lenx, leny ) );
 	END CopyMtxToArray;
 
 	PROCEDURE CopyArrayToCube*( VAR src: ARRAY OF ARRAY OF ARRAY OF Value;  dest: Array;
-													    srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
+													srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
 	VAR srcmem: ArrayXdBytes.ArrayMemoryStructure;
 	BEGIN
 		IF dest.dim # 3 THEN HALT( 1005 ) END;
 		srcmem :=
 			ArrayXdBytes.MakeMemoryStructure( 3, ArrayXdBytes.Index3( 0, 0, 0 ),
-																		  ArrayXdBytes.Index3( LEN( src, 2 ), LEN( src, 1 ), LEN( src, 0 ) ), SIZEOF( Value ),
-																		  ADDRESSOF( src[0, 0, 0] ) );
+																		ArrayXdBytes.Index3( LEN( src, 2 ), LEN( src, 1 ), LEN( src, 0 ) ), SIZEOF( Value ),
+																		ADDRESSOF( src[0, 0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( srcmem, dest, ArrayXdBytes.Index3( srcx, srcy, srcz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ),
-																		   ArrayXdBytes.Index3( destx, desty, destz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ) );
+																		ArrayXdBytes.Index3( lenx, leny, lenz ),
+																		ArrayXdBytes.Index3( destx, desty, destz ),
+																		ArrayXdBytes.Index3( lenx, leny, lenz ) );
 	END CopyArrayToCube;
 
 	PROCEDURE CopyCubeToArray*( src: Array;  VAR dest: ARRAY OF ARRAY OF ARRAY OF Value;
-													    srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
+													srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index );
 	VAR destmem: ArrayXdBytes.ArrayMemoryStructure;
 	BEGIN
 		IF src.dim # 3 THEN HALT( 1005 ) END;
 		destmem :=
 			ArrayXdBytes.MakeMemoryStructure( 3, ArrayXdBytes.Index3( 0, 0, 0 ),
-																		  ArrayXdBytes.Index3( LEN( dest, 2 ), LEN( dest, 1 ), LEN( dest, 0 ) ), SIZEOF( Value ),
-																		  ADDRESSOF( dest[0, 0, 0] ) );
+																		ArrayXdBytes.Index3( LEN( dest, 2 ), LEN( dest, 1 ), LEN( dest, 0 ) ), SIZEOF( Value ),
+																		ADDRESSOF( dest[0, 0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, destmem, ArrayXdBytes.Index3( srcx, srcy, srcz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ),
-																		   ArrayXdBytes.Index3( destx, desty, destz ),
-																		   ArrayXdBytes.Index3( lenx, leny, lenz ) );
+																		ArrayXdBytes.Index3( lenx, leny, lenz ),
+																		ArrayXdBytes.Index3( destx, desty, destz ),
+																		ArrayXdBytes.Index3( lenx, leny, lenz ) );
 	END CopyCubeToArray;
 
 	PROCEDURE CopyArrayToHCube*( VAR src: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value;  dest: Array;
-														  srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
+														srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
 	VAR srcmem: ArrayXdBytes.ArrayMemoryStructure;
 	BEGIN
 		IF dest.dim # 4 THEN HALT( 1005 ) END;
 		srcmem :=
 			ArrayXdBytes.MakeMemoryStructure( 4, ArrayXdBytes.Index4( 0, 0, 0, 0 ),
-																		  ArrayXdBytes.Index4( LEN( src, 3 ), LEN( src, 2 ), LEN( src, 1 ), LEN( src, 0 ) ), SIZEOF( Value ),
-																		  ADDRESSOF( src[0, 0, 0] ) );
+																		ArrayXdBytes.Index4( LEN( src, 3 ), LEN( src, 2 ), LEN( src, 1 ), LEN( src, 0 ) ), SIZEOF( Value ),
+																		ADDRESSOF( src[0, 0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( srcmem, dest, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ),
-																		   ArrayXdBytes.Index4( lenx, leny, lenz, lent ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ),
-																		   ArrayXdBytes.Index4( lenx, leny, lenz, lent ) );
+																		ArrayXdBytes.Index4( lenx, leny, lenz, lent ),
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ),
+																		ArrayXdBytes.Index4( lenx, leny, lenz, lent ) );
 	END CopyArrayToHCube;
 
 	PROCEDURE CopyHCubeToArray*( src: Array;  VAR dest: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value;
-														  srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
+														srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index );
 	VAR destmem: ArrayXdBytes.ArrayMemoryStructure;
 	BEGIN
 		IF src.dim # 4 THEN HALT( 1005 ) END;
 		destmem :=
 			ArrayXdBytes.MakeMemoryStructure( 4, ArrayXdBytes.Index4( 0, 0, 0, 0 ),
-																		  ArrayXdBytes.Index4( LEN( dest, 3 ), LEN( dest, 2 ), LEN( dest, 1 ), LEN( dest, 0 ) ), SIZEOF( Value ),
-																		  ADDRESSOF( dest[0, 0, 0] ) );
+																		ArrayXdBytes.Index4( LEN( dest, 3 ), LEN( dest, 2 ), LEN( dest, 1 ), LEN( dest, 0 ) ), SIZEOF( Value ),
+																		ADDRESSOF( dest[0, 0, 0] ) );
 		ArrayXdBytes.CopyArrayPartToArrayPart( src, destmem, ArrayXdBytes.Index4( srcx, srcy, srcz, srct ),
-																		   ArrayXdBytes.Index4( lenx, leny, lenz, lent ),
-																		   ArrayXdBytes.Index4( destx, desty, destz, destt ),
-																		   ArrayXdBytes.Index4( lenx, leny, lenz, lent ) );
+																		ArrayXdBytes.Index4( lenx, leny, lenz, lent ),
+																		ArrayXdBytes.Index4( destx, desty, destz, destt ),
+																		ArrayXdBytes.Index4( lenx, leny, lenz, lent ) );
 	END CopyHCubeToArray;
 
 	PROCEDURE CopyArrayToArrayPartB*( src: Array;  dest: ArrayXdBytes.ArrayMemoryStructure;  boundaryCondition: SHORTINT;
-																 srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray );
+																srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray );
 
 	VAR temp: ArrayXdBytes.ArrayMemoryStructure;
 		spos, dpos, last, borigin, blen, srcposcut, srclencut, destoffset: ArrayXdBytes.IndexArray;  i, dim: LONGINT;
 		val: Value;  temp2: Array;  enumB: ArrayXdBytes.BoundaryEnum;
 		Get: PROCEDURE {DELEGATE} ( x: ARRAY OF Index;
-																																													 dim: Index ): Value;
+																																													dim: Index ): Value;
 		noinbound: BOOLEAN;  v: Value;
 
 		(* for debugging
@@ -1229,4 +1229,3 @@ TYPE
 BEGIN
 	Register
 END ArrayXdRe.
-

source/Attributes.Mod

@@ -62,7 +62,7 @@ TYPE
 			INC(nofAttributes);
 		END AddObject;
 
-		(* 	Remove <object> from array. If hint is not <Invalid>, hint is the index of the object.
+		(*	Remove <object> from array. If hint is not <Invalid>, hint is the index of the object.
 			<object> must be contained in array! *)
 		PROCEDURE RemoveObject(object : ANY; hint : LONGINT); (* private *)
 		VAR index, i : LONGINT;

source/BIOS.ATADisks.Mod

@@ -2321,8 +2321,8 @@ BEGIN
 		ScanPCI(1166H, 0211H);		(* Serverworks *)
 		ScanPCI(8086H, 27C0H); (* found on TL device *)
 
- 	ELSIF str = "legacy" THEN
- 		Show("Legacy mode..."); KernelLog.Ln;
+	ELSIF str = "legacy" THEN
+		Show("Legacy mode..."); KernelLog.Ln;
 		NEW(c, 1F0H, 3F0H, 0, 14);
 		AddController(c);
 		NEW(c, 170H, 370H, 0, 15);

source/BIOS.Adaptec7.Mod

@@ -145,40 +145,40 @@ CONST
 (* Scratch RAM *)
 	(* 20H	1 byte per target starting at this address for configuration values*)	TARGSCSIRATE = 20H;
 	(* 30H	Bit vector of targets that have ULTRA enabled. *)	ULTRAENB = 30H;
- 	(* 32H 	Bit vector of targets that have disconnection disabled*)	DISCDSB = 32H;
- 	(* 34H	buffer to designate the type or message to send to a target*)	MSGOUT = 34H;
- 	(* 35H	Parameters for DMA Logic*)	DMAPARAMS = 35H;
- 	(* 36H	*)		SEQFLAGS = 36H;
- 	(* 37H	SAVED_TCL*)	SAVEDTCL = 37H;
- 	(* 38H	SG_COUNT*)
- 	(* 39H	SG_NEXT*)
- 	(* 3DH	LASTPHASE*)	LASTPHASE = 3DH;
- 		(* Signals are declared in SCSISIG *)		PHASEMASK = {CD, MSG, IO};
- 		(* Patterns*)
- 		PhaseStatus = {CD, IO};
- 		PhaseCommand = {CD};
- 		PhaseMsgOut = {CD, MSG};
- 		PhaseMsgIn = {CD, MSG, IO};
- 		PhaseDataIn = {IO};
- 		PhaseDataOut = {};
- 		PhaseBusFree = {0};
- 	(* 3EH	WAITINGSCBH*)	WAITINGSCBH = 3EH;
- 	(* 3FH	DISCONNECTEDSCBH*)	DISCONNECTEDSCBH = 3FH;
- 	(* 40H	head of list of SCBs that are not in use.  Used for SCB paging*)	FREESCBH = 40H;
- 	(* 41H	HSCB_ADDR*)	HSCBARRAY = 41H;
- 	(* 45H	SCBID_ADDR*)	SCBIDADDR = 45H;
- 	(* 49H	TMODE_CMDADDR*)	TMODECMDADDR = 49H;
- 	(* 4DH	KERNEL_QINPOS*)	KERNELQINPOS = 4DH;
- 	(* 4EH	QINPOS*)	QINPOS = 4EH;
- 	(* 4FH	QOUTPOS*)	QOUTPOS = 4FH;
- 	(* 50H	TMODE_CMDADDR_NEXT*)	TMODECMDADDRNEXT = 50H;
- 	(* 51H	ARG_1 / RETURN_1*)	RETURN1 = 51H;
- 		(*	Phase Mismatch *)		MSGOUTPHASEMIS = {4};
- 		(* 	Send Sense *)		SENDSENSE = {6};
- 		(* 	Send Msg *)		SENDMSG = {7};
- 	(* 52H	ARG_2 *)
- 	(* 53H	LAST_MSG*)	LASTMSG = 53H;
- 	(* 54H	PREFETCH_CNT*)
+	(* 32H 	Bit vector of targets that have disconnection disabled*)	DISCDSB = 32H;
+	(* 34H	buffer to designate the type or message to send to a target*)	MSGOUT = 34H;
+	(* 35H	Parameters for DMA Logic*)	DMAPARAMS = 35H;
+	(* 36H	*)		SEQFLAGS = 36H;
+	(* 37H	SAVED_TCL*)	SAVEDTCL = 37H;
+	(* 38H	SG_COUNT*)
+	(* 39H	SG_NEXT*)
+	(* 3DH	LASTPHASE*)	LASTPHASE = 3DH;
+		(* Signals are declared in SCSISIG *)		PHASEMASK = {CD, MSG, IO};
+		(* Patterns*)
+		PhaseStatus = {CD, IO};
+		PhaseCommand = {CD};
+		PhaseMsgOut = {CD, MSG};
+		PhaseMsgIn = {CD, MSG, IO};
+		PhaseDataIn = {IO};
+		PhaseDataOut = {};
+		PhaseBusFree = {0};
+	(* 3EH	WAITINGSCBH*)	WAITINGSCBH = 3EH;
+	(* 3FH	DISCONNECTEDSCBH*)	DISCONNECTEDSCBH = 3FH;
+	(* 40H	head of list of SCBs that are not in use.  Used for SCB paging*)	FREESCBH = 40H;
+	(* 41H	HSCB_ADDR*)	HSCBARRAY = 41H;
+	(* 45H	SCBID_ADDR*)	SCBIDADDR = 45H;
+	(* 49H	TMODE_CMDADDR*)	TMODECMDADDR = 49H;
+	(* 4DH	KERNEL_QINPOS*)	KERNELQINPOS = 4DH;
+	(* 4EH	QINPOS*)	QINPOS = 4EH;
+	(* 4FH	QOUTPOS*)	QOUTPOS = 4FH;
+	(* 50H	TMODE_CMDADDR_NEXT*)	TMODECMDADDRNEXT = 50H;
+	(* 51H	ARG_1 / RETURN_1*)	RETURN1 = 51H;
+		(*	Phase Mismatch *)		MSGOUTPHASEMIS = {4};
+		(* 	Send Sense *)		SENDSENSE = {6};
+		(* 	Send Msg *)		SENDMSG = {7};
+	(* 52H	ARG_2 *)
+	(* 53H	LAST_MSG*)	LASTMSG = 53H;
+	(* 54H	PREFETCH_CNT*)
 
 	(* 5AH	Scsi Configuration *)	SCSICONF = 5AH;
 		(* Bit 6	Reset SCSI-Bus at boot *)		RESETSCSI = 6;

source/BIOS.BenchInterrupts.Mod

@@ -1,12 +1,12 @@
 MODULE BenchInterrupts; (** AUTHOR "staubesv"; PURPOSE "Interrupt latency benchmarks"; *)
 (**
 
- 	Non-comrehensive list of aspects to be considered:
- 	-	The garbage collector prohibits interrupts while running. Depending on the current state of the heap, this can
- 		introduce delays in the order of seconds
- 	- 	There can be multipe handlers per interrupt vector
- 	-	The Machine.SoftInt is a temporary interrupt vector that is potentially used by other applications
- 	-	Result is dependent on other interrupts that have a higher priority and can interrupt our handler
+	Non-comrehensive list of aspects to be considered:
+	-	The garbage collector prohibits interrupts while running. Depending on the current state of the heap, this can
+		introduce delays in the order of seconds
+	- 	There can be multipe handlers per interrupt vector
+	-	The Machine.SoftInt is a temporary interrupt vector that is potentially used by other applications
+	-	Result is dependent on other interrupts that have a higher priority and can interrupt our handler
 
 *)
 

source/BIOS.Objects.Mod

@@ -134,33 +134,33 @@ TYPE
 					IF pc # 0 THEN 	(* process is running already *)
 						WHILE (bp # Heaps.NilVal) & (stack.adr <= bp) & (bp < stack.high) DO
 							FindPointers(bp, pc, d0, d1);
- 							IF first THEN
- 								IF (d0 = 0) OR (d0 = 1) OR (d1 = 3) THEN
- 									(* 	situation where pc and bp are not synchronized: *)
- 									(* 	entry protocol of a procedure:
- 										PUSH 	EBP			-- 1 byte instruction length, if pc points to this instruction at offset 0 from the codeoffset then bp still refers to caller frame -> critical
- 										MOV	EBP, ESP	-- 2 bytes instruction length, do. for offset 1 from the codeoffset
- 										(followed by initialization of local variables)
- 										exit protocol of a procedure:
- 										MOV	ESP, EBP	-- 2 bytes instruction length
- 										POP	EBP			-- 1 byte instruction length
- 										RET		n			-- 3 bytes instruction length, if pc points to this instruction at offset 3 from the last statement then bp already refers to caller's frame -> critical
- 									*)
- 									IF (d0 = 0) OR (d1 = 3) THEN
- 										SYSTEM.GET(state.SP, pc);		(* matching pc is at position of stack pointer *)
- 									ELSE
- 										SYSTEM.GET(state.SP+AddressSize, pc);		(* matching pc is at 4 bytes after stack pointer, pushed base pointer is at stack pointer position *)
+							IF first THEN
+								IF (d0 = 0) OR (d0 = 1) OR (d1 = 3) THEN
+									(* 	situation where pc and bp are not synchronized: *)
+									(* 	entry protocol of a procedure:
+										PUSH 	EBP			-- 1 byte instruction length, if pc points to this instruction at offset 0 from the codeoffset then bp still refers to caller frame -> critical
+										MOV	EBP, ESP	-- 2 bytes instruction length, do. for offset 1 from the codeoffset
+										(followed by initialization of local variables)
+										exit protocol of a procedure:
+										MOV	ESP, EBP	-- 2 bytes instruction length
+										POP	EBP			-- 1 byte instruction length
+										RET		n			-- 3 bytes instruction length, if pc points to this instruction at offset 3 from the last statement then bp already refers to caller's frame -> critical
+									*)
+									IF (d0 = 0) OR (d1 = 3) THEN
+										SYSTEM.GET(state.SP, pc);		(* matching pc is at position of stack pointer *)
+									ELSE
+										SYSTEM.GET(state.SP+AddressSize, pc);		(* matching pc is at 4 bytes after stack pointer, pushed base pointer is at stack pointer position *)
 									END;
- 								ELSE
- 									(* regular case: bp and pc were synchronized *)
- 									curbp := bp;
+								ELSE
+									(* regular case: bp and pc were synchronized *)
+									curbp := bp;
 									SYSTEM.GET(curbp, bp);
 									SYSTEM.GET(curbp+AddressSize, pc);
- 								END;
- 								first := FALSE;
- 							ELSE
- 								(* regular case: bp and pc were synchronized *)
- 								curbp := bp;
+								END;
+								first := FALSE;
+							ELSE
+								(* regular case: bp and pc were synchronized *)
+								curbp := bp;
 								SYSTEM.GET(curbp, bp);
 								SYSTEM.GET(curbp+AddressSize, pc);
 							END
@@ -1705,9 +1705,9 @@ BEGIN (* interrupts off *)
 	Machine.Acquire(Machine.Objects);
 	t := running[Machine.ID ()];
 	IF t # NIL THEN
- 		t.state.PC := Machine.CurrentPC(); (* ug: required information for GC with meta data for stack inspection *)
- 		t.state.SP := SYSTEM.GetStackPointer(); (* ug: not necessarily needed for GC *)
- 		t.state.BP := SYSTEM.GetFramePointer(); (* ug: necessary information for GC with meta data for stack inspection *)
+		t.state.PC := Machine.CurrentPC(); (* ug: required information for GC with meta data for stack inspection *)
+		t.state.SP := SYSTEM.GetStackPointer(); (* ug: not necessarily needed for GC *)
+		t.state.BP := SYSTEM.GetFramePointer(); (* ug: necessary information for GC with meta data for stack inspection *)
 	END;
 	Machine.Release(Machine.Objects)
 END UpdateState;

source/BimboScanner.Mod

@@ -348,8 +348,8 @@ TYPE
 									 IF ch = "." THEN NextChar; s := upto ELSE s := period END
 					| "/"  : s :=  slash; NextChar
 					| "0".."9": isNummer := TRUE; numStartPos := pos-1;
- 						(*	WHILE (ch >="0") & (ch <= "9") OR (ch >= "A") & (ch <="F") OR (ch="H") OR (ch="X") OR (ch=".") DO NextChar END; *)
- 						Number;
+						(*	WHILE (ch >="0") & (ch <= "9") OR (ch >= "A") & (ch <="F") OR (ch="H") OR (ch="X") OR (ch=".") DO NextChar END; *)
+						Number;
 						numEndPos := pos-1; s := number
 					| ":"  : NextChar;
 									 IF ch = "=" THEN NextChar; s := becomes ELSE s := colon END

source/BluetoothTest.Mod

@@ -761,7 +761,7 @@ VAR
 BEGIN
 	IF context.arg.GetString(ident) & context.arg.GetInteger(handle, FALSE) & context.arg.GetInteger(cid, FALSE) THEN
 		context.arg.SkipWhitespace;
- 		d := Find(ident);
+		d := Find(ident);
 		IF (d # NIL) THEN
 			i := 4;
 			WHILE (context.arg.res = Streams.Ok) DO

source/CDRecordUtils.Mod

@@ -3,7 +3,7 @@ MODULE CDRecordUtils;
 IMPORT
 	SYSTEM, Codecs, Strings, Streams, Files, SoundDevices, KernelLog, Disks, DiskVolumes, FATVolumes, ISO9660Volumes, ATADisks,
 	WMWindowManager, WMComponents, WMStandardComponents, WMFileManager, WMSystemComponents, WMGrids, WMStringGrids, WMDialogs,
- 	WMEvents, WMTabComponents, WMProperties, WMGraphics, WMRectangles;
+	WMEvents, WMTabComponents, WMProperties, WMGraphics, WMRectangles;
 
 CONST
 	MaxLen = 256;
@@ -190,43 +190,43 @@ TYPE
 				CASE tmp OF
 					  0: frame.samplerate := 44100;
 					| 1: frame.samplerate := 48000;
- 					| 2: frame.samplerate := 32000;
- 					ELSE RETURN ResErr;
- 				END;
- 			ELSIF frame.mpegver = MPEGVer2 THEN
- 				CASE tmp OF
+					| 2: frame.samplerate := 32000;
+					ELSE RETURN ResErr;
+				END;
+			ELSIF frame.mpegver = MPEGVer2 THEN
+				CASE tmp OF
 					  0: frame.samplerate := 22050;
 					| 1: frame.samplerate := 24000;
- 					| 2: frame.samplerate := 16000;
- 					ELSE RETURN ResErr;
- 				END;
- 			ELSIF frame.mpegver = MPEGVer25 THEN
- 				CASE tmp OF
+					| 2: frame.samplerate := 16000;
+					ELSE RETURN ResErr;
+				END;
+			ELSIF frame.mpegver = MPEGVer25 THEN
+				CASE tmp OF
 					  0: frame.samplerate := 11025;
 					| 1: frame.samplerate := 12000;
- 					| 2: frame.samplerate := 8000;
- 					ELSE RETURN ResErr;
- 				END;
- 			END;
+					| 2: frame.samplerate := 8000;
+					ELSE RETURN ResErr;
+				END;
+			END;
 
- 			frame.padding := ASH(ORD(buf[2]), -1) MOD 2;
+			frame.padding := ASH(ORD(buf[2]), -1) MOD 2;
 
- 			IF frame.mpegver = MPEGVer1 THEN
- 				IF frame.layer = 1 THEN
- 					tmp := 48000;
- 				ELSE
+			IF frame.mpegver = MPEGVer1 THEN
+				IF frame.layer = 1 THEN
+					tmp := 48000;
+				ELSE
 					tmp := 144000;
 				END;
- 			ELSE
- 				IF frame.layer = 1 THEN
- 					tmp := 24000
- 				ELSE
- 					tmp := 72000;
- 				END;
- 			END;
-
- 			frame.size := tmp*frame.bitrate DIV frame.samplerate + frame.padding;
- 			RETURN ResOk;
+			ELSE
+				IF frame.layer = 1 THEN
+					tmp := 24000
+				ELSE
+					tmp := 72000;
+				END;
+			END;
+
+			frame.size := tmp*frame.bitrate DIV frame.samplerate + frame.padding;
+			RETURN ResOk;
 		END GetNextFrame;
 
 		PROCEDURE Open*(filename: String): LONGINT;
@@ -243,19 +243,19 @@ TYPE
 			END;
 
 			Files.OpenReader(r, file, 0);
- 			WHILE GetNextFrame(r, frame) = ResOk DO
- 				INC(nofframes);
- 				r.SkipBytes(frame.size-4);
- 				INC(playtime, (8*frame.size) DIV frame.bitrate); (* in ms *)
- 			END;
-
- 			IF nofframes < 1 THEN RETURN ResErr END;
- 			playtime := (playtime+1000-1) DIV 1000;
-
- 			NEW(id3v1);
- 			IF ReadID3v1(filename, id3v1) # ResOk THEN
- 				id3v1 := NIL;
- 			END;
+			WHILE GetNextFrame(r, frame) = ResOk DO
+				INC(nofframes);
+				r.SkipBytes(frame.size-4);
+				INC(playtime, (8*frame.size) DIV frame.bitrate); (* in ms *)
+			END;
+
+			IF nofframes < 1 THEN RETURN ResErr END;
+			playtime := (playtime+1000-1) DIV 1000;
+
+			NEW(id3v1);
+			IF ReadID3v1(filename, id3v1) # ResOk THEN
+				id3v1 := NIL;
+			END;
 
 			RETURN ResOk;
 		END Open;

source/CryptoBase64.Mod

@@ -36,7 +36,7 @@ VAR
 			INC( ox, 4 );
 		END;
 		b64[ox] := 0X;
- 	END Encode;
+	END Encode;
 
 
 	(* returns image length, negative value = error! *)
@@ -77,7 +77,7 @@ VAR
 
 
 
- 	PROCEDURE EncodeStream*( CONST image: ARRAY OF CHAR; len: LONGINT;
+	PROCEDURE EncodeStream*( CONST image: ARRAY OF CHAR; len: LONGINT;
 						   		  		w: Streams.Writer );
 	VAR
 		group, i, ix, ll: LONGINT;
@@ -105,7 +105,7 @@ VAR
 			w.Char( '=' );
 		END;
 		w.Update
- 	END EncodeStream;
+	END EncodeStream;
 
 
 	(* returns image length, negative value = error! *)

source/CryptoDiffieHellman.Mod

@@ -79,8 +79,8 @@ TYPE
 		ELSIF name = "dh.ssl.1024" THEN	(* openssl 1.0 *)
 			pos := 0;
 			Append( "F881897D 1424C5D1 E6F7BF3A E490F4FC 73FB34B5 FA4C56A2" );
- 			Append( "EAA7E9C0 C0CE89E1 FA633FB0 6B3266F1 D17BB000 8FCA87C2" );
- 			Append( "AE988926 17C205D2 EC08D08C FF17528C C5079303 B1F62FB8" );
+			Append( "EAA7E9C0 C0CE89E1 FA633FB0 6B3266F1 D17BB000 8FCA87C2" );
+			Append( "AE988926 17C205D2 EC08D08C FF17528C C5079303 B1F62FB8" );
 			Append( "1C524727 1BDBD18D 9D691D52 4B3281AA 7F00C8DC E6D9CCC1" );
 			Append( "112D3734 6CEA0297 4B0EBBB1 71330915 FDDD2387 075E89AB" );
 			Append( "6B7C5FEC A624DC53" );
@@ -150,8 +150,8 @@ TYPE
         		Append( "C9B53DCF 4BA80A29 E3FB73C1 6B8E75B9 7EF363E2 FFA31F71" );
         		Append( "CF9DE538 4E71B81C 0AC4DFFE 0C10E64F" );
         		B.AssignHex( p, buf, 512 );
- 			pos := 0;
- 			Append( "AC4032EF 4F2D9AE3 9DF30B5C 8FFDAC50 6CDEBE7B 89998CAF" );
+			pos := 0;
+			Append( "AC4032EF 4F2D9AE3 9DF30B5C 8FFDAC50 6CDEBE7B 89998CAF" );
         		Append( "74866A08 CFE4FFE3 A6824A4E 10B9A6F0 DD921F01 A70C4AFA" );
         		Append( "AB739D77 00C29F52 C57DB17C 620A8652 BE5E9001 A8D66AD7" );
         		Append( "C1766910 1999024A F4D02727 5AC1348B B8A762D0 521BC98A" );
@@ -179,7 +179,7 @@ TYPE
        		B.AssignHex( p, buf, 512 );
 			pos := 0;
 			Append( "3FB32C9B 73134D0B 2E775066 60EDBD48 4CA7B18F 21EF2054" );
- 			Append( "07F4793A 1A0BA125 10DBC150 77BE463F FF4FED4A AC0BB555" );
+			Append( "07F4793A 1A0BA125 10DBC150 77BE463F FF4FED4A AC0BB555" );
        		Append( "BE3A6C1B 0C6B47B1 BC3773BF 7E8C6F62 901228F8 C28CBB18" );
        		Append( "A55AE313 41000A65 0196F931 C77A57F2 DDF463E5 E9EC144B" );
        		Append( "777DE62A AAB8A862 8AC376D2 82D6ED38 64E67982 428EBC83" );

source/DTPEditor.Mod

@@ -1157,7 +1157,7 @@ TYPE
 			w.String('<?xml version="1.0" encoding="UTF-8"?>'); w.Ln;
 			w.String("<content>"); w.Ln;
 			(* processing character styles *)
- 			contents := currentDocument.contents; i := 0;
+			contents := currentDocument.contents; i := 0;
 			WHILE (i<currentDocument.nofContents) DO
 				content := contents[i];
 				w.String('<node name="'); w.String(content.contentName^); w.String('">'); w.Ln;
@@ -2122,7 +2122,7 @@ TYPE
 
 			NEW(spacer); spacer.alignment.Set(WMComponents.AlignTop);
 			spacer.bounds.SetHeight(40);
- 			panel.AddContent(spacer);
+			panel.AddContent(spacer);
 
 			NEW(label); label.alignment.Set(WMComponents.AlignTop);
 			label.bounds.SetHeight(20);
@@ -2148,7 +2148,7 @@ TYPE
 
 			NEW(spacer); spacer.alignment.Set(WMComponents.AlignBottom);
 			spacer.bounds.SetHeight(25);
- 			panel.AddContent(spacer);
+			panel.AddContent(spacer);
 
 			NEW(status); status.alignment.Set(WMComponents.AlignBottom);
 			status.bounds.SetHeight(20);

source/DTPText.Mod

@@ -1855,7 +1855,7 @@ TYPE
 				SelectAll
 			ELSIF keysym = 03H THEN (* Ctrl-C *)
 				CopySelection
- 			ELSIF (keysym = 0FF63H) & (flags * Inputs.Ctrl # {}) THEN  (*Ctrl Insert *)
+			ELSIF (keysym = 0FF63H) & (flags * Inputs.Ctrl # {}) THEN  (*Ctrl Insert *)
 				CopySelection
 			ELSIF keysym = 12H THEN (* Ctrl-R *)
 				layout.FullLayout(firstPos, firstLineI); Invalidate;CheckNumberOfLines;

source/Darwin.Unix.Mod

@@ -422,7 +422,7 @@ TYPE
 
 				r_ax		: HUGEINT;
 				r_bx		: HUGEINT;
- 				r_cx		: HUGEINT;
+				r_cx		: HUGEINT;
 				r_dx		: HUGEINT;
 				r_di		: HUGEINT;
 				r_si		: HUGEINT;

source/DiskBenchmark.Mod

@@ -264,8 +264,8 @@ TYPE
 (** Perform a benchmark on partition *)
 PROCEDURE Bench*(context : Commands.Context); (** dev#part *)
 VAR
- 	selection : Lib.Selection;
- 	bench : DiskBench;
+	selection : Lib.Selection;
+	bench : DiskBench;
 BEGIN
 	IF Partitions.GetSelection(context, FALSE, selection) THEN
 		NEW(bench, selection.disk, selection.partition, context.out);

source/FATFiles.Mod

@@ -735,7 +735,7 @@ TYPE
 				buffer.eoc := FALSE;
 				ASSERT(res = Ok)
 			END
- 		END ReadBuffer;
+		END ReadBuffer;
 
 		(* Write logical cluster. Depending on buf.cluster, a new physical cluster may be allocated. cf. ReadBuffer *)
 		PROCEDURE WriteBuffer(buffer: Buffer);

source/FATScavenger.Mod

@@ -37,7 +37,7 @@ MODULE FATScavenger; (** AUTHOR "staubesv"; PURPOSE "Scavenger and format for FA
 
 IMPORT
 	SYSTEM, KernelLog, Streams, Files, FATVolumes, Disks, FATFiles, UTF8Strings,
- 	Strings, PartitionsLib, Clock;
+	Strings, PartitionsLib, Clock;
 
 CONST
 

source/FirewireLow.Mod

@@ -2563,14 +2563,14 @@ VAR ohci: FirewireLowUtil.OHCIDesc; generation: LONGINT; sid: FirewireLowUtil.Se
 BEGIN
  ohci:= c.OHCI; generation:= FirewireLowUtil.GetGeneration(); i:= 0;
  WHILE ohci.TopologyMap[i] # NIL DO
- 	IF ~(ohci.TopologyMap[i] IS FirewireLowUtil.ExtSelfID) &
- 		(SYSTEM.VAL(LONGINT,ohci.TopologyMap[i].physicalID) # c.OHCI.nodeID) THEN
- 		sid:= ohci.TopologyMap[i];
- 		IF c.ReadBusInfoBlock(ohci,sid.physicalID,generation,buffer,4) THEN
- 			KernelLog.String("There was a problem reading the bus info block::Test1394!"); KernelLog.Ln()
- 		END
- 	END;
- 	INC(i);
+	IF ~(ohci.TopologyMap[i] IS FirewireLowUtil.ExtSelfID) &
+		(SYSTEM.VAL(LONGINT,ohci.TopologyMap[i].physicalID) # c.OHCI.nodeID) THEN
+		sid:= ohci.TopologyMap[i];
+		IF c.ReadBusInfoBlock(ohci,sid.physicalID,generation,buffer,4) THEN
+			KernelLog.String("There was a problem reading the bus info block::Test1394!"); KernelLog.Ln()
+		END
+	END;
+	INC(i);
  END;
 END Test1394;
 

source/I386.DivXDecoder.Mod

@@ -296,8 +296,8 @@ TYPE MacroBlock *= OBJECT
 			END;
 
 		 	IF DT.Debug THEN
- 				log.String( "TransferIDCTCopy: "); log.Int( offset - mp4State.frameRefBaseOffset[cc], 0 ); log.Char( ' ' );
- 				log.Int( iincr, 0 ); log.Ln()
+				log.String( "TransferIDCTCopy: "); log.Int( offset - mp4State.frameRefBaseOffset[cc], 0 ); log.Char( ' ' );
+				log.Int( iincr, 0 ); log.Ln()
 		 	END;
 
 			TransferIDCTCopy( ADDRESSOF(texture.dstBlock[4]), mp4State.frameRef, offset, iincr );
@@ -326,14 +326,14 @@ TYPE MacroBlock *= OBJECT
 
 				(* frame DCT coding *)
 				offset := mp4State.frameRefBaseOffset[cc] + mp4State.chromWidth * by + bx;
- 	   		iincr := mp4State.chromWidth
+	   		iincr := mp4State.chromWidth
 			END;
 
 		 	IF DT.Debug THEN
 		 		log.String( "TransferIDCTAdd: "); log.Int( offset - mp4State.frameRefBaseOffset[cc], 0 ); log.Char( ' ' );
 		 		log.Int( iincr, 0 ); log.Ln()
 		 	END;
- 			TransferIDCTAdd( ADDRESSOF(texture.dstBlock[4]), mp4State.frameRef, offset, iincr );
+			TransferIDCTAdd( ADDRESSOF(texture.dstBlock[4]), mp4State.frameRef, offset, iincr );
 		END AddBlockInter;
 
 		PROCEDURE TransferIDCTAdd( source: LONGINT; dest: DT.PointerToArrayOfCHAR; destOffset, stride: LONGINT );
@@ -743,7 +743,7 @@ TYPE MotionCompensation = OBJECT
 				END;
 			END;
 
- 		 	verMvData := GetMVData(s);
+		 	verMvData := GetMVData(s);
 
 			IF ( scaleFac = 1 ) OR ( verMvData = 0 ) THEN
 				mvdy := verMvData

source/I386.DivXHelper.Mod

@@ -1013,10 +1013,10 @@ IMPORT
 
 	(* column (vertical) IDCT
 
- 	 7                         pi         1 dst[8*k] = sum c[l] * src[8*l] *
- 	 cos( -- * ( k + - ) * l ) l=0                        8          2
+	 7                         pi         1 dst[8*k] = sum c[l] * src[8*l] *
+	 cos( -- * ( k + - ) * l ) l=0                        8          2
 
- 	 where: c[0]    = 1/1024 c[1..7] = (1/1024)*sqrt(2)
+	 where: c[0]    = 1/1024 c[1..7] = (1/1024)*sqrt(2)
 	*)
 	PROCEDURE IDCTCol( blk: DT.PointerToArrayOfLONGINT; baseIndex: LONGINT );
 	VAR

source/I386.IDCT.Mod

@@ -686,10 +686,10 @@ END Row;
 
 (* column (vertical) IDCT
 
- 	 7                         pi         1 dst[8*k] = sum c[l] * src[8*l] *
- 	 cos( -- * ( k + - ) * l ) l=0                        8          2
+	 7                         pi         1 dst[8*k] = sum c[l] * src[8*l] *
+	 cos( -- * ( k + - ) * l ) l=0                        8          2
 
- 	 where: c[0]    = 1/1024 c[1..7] = (1/1024)*sqrt(2)
+	 where: c[0]    = 1/1024 c[1..7] = (1/1024)*sqrt(2)
 *)
 PROCEDURE Col( src: LONGINT);
 VAR

source/I386.UsbKeyboard.Mod

@@ -173,7 +173,7 @@ TYPE
 	VAR
 		pipe : Usbdi.Pipe;
 
- 		(* buffer[0] : modifier byte					*)
+		(* buffer[0] : modifier byte					*)
 		(* buffer[1] : reserved						*)
 		(* buffer[2]-buffer[7] : 6 one byte key codes  	*)
 		buffer : Usbdi.BufferPtr;

source/I386.WMRasterScale.Mod

@@ -1385,11 +1385,11 @@ endofloop47:
 	; dred18f = dred18big && destMaskred128  because >> 11 and << 11 is && mask
 	PAND 		XMM7, XMM6 ; dred18f
 
- 	; dest18nr0 = dest18 && (~destMaskred128)
- 	PANDN 	XMM6, XMM3  				; dest18nr0
+	; dest18nr0 = dest18 && (~destMaskred128)
+	PANDN 	XMM6, XMM3  				; dest18nr0
 
- 	; dest18nrf = dest18nr0 || dred18f
- 	POR 		XMM6, XMM7
+	; dest18nrf = dest18nr0 || dred18f
+	POR 		XMM6, XMM7
 
 	MOVDQU 	XMM3, XMM6
 
@@ -1453,10 +1453,10 @@ endofloop47:
 	PSRLW 		XMM7, 10 					; dgreen18f
 	PSLLW 		XMM7, 5
 
- 	; dest18ng0 = dest18 && (~destMaskgreen128)
+	; dest18ng0 = dest18 && (~destMaskgreen128)
 
- 	; dest18ngf = dest18ng0 || dred18f
- 	POR 		XMM6, XMM7
+	; dest18ngf = dest18ng0 || dred18f
+	POR 		XMM6, XMM7
 	MOVDQU 	XMM3, XMM6
 	; green is calculated
 
@@ -1512,12 +1512,12 @@ endofloop47:
 	PADDUSW 	XMM7, XMM5 				; dblue18big
 	; dblue18f = (dblue18big >> 11)
 	PANDN 	XMM6, XMM3  				; dest18nr0
- 	PSRLW 		XMM7, 11 					; dblue18f
+	PSRLW 		XMM7, 11 					; dblue18f
 
   	; dest18nr0 = dest18 && (~destMaskblue128)
 
- 	; dest18nbf = dest18nb0 || dblue18f
- 	POR 		XMM6, XMM7
+	; dest18nbf = dest18nb0 || dblue18f
+	POR 		XMM6, XMM7
 	MOVDQU 	XMM3, XMM6
 
 	; blue is calculated
@@ -2333,10 +2333,10 @@ alleightpixels:
 	PAND 		XMM7, XMM6 			; dred18f
 
   	; dest18nr0 = dest18 && (~destMaskred128)
- 	PANDN 	XMM6, XMM3  			; dest18nr0
+	PANDN 	XMM6, XMM3  			; dest18nr0
 
- 	 ; dest18nrf = dest18nr0 || dred18f
- 	POR 		XMM6, XMM7
+	 ; dest18nrf = dest18nr0 || dred18f
+	POR 		XMM6, XMM7
 
 	MOVDQU 	XMM3, XMM6
 
@@ -2404,8 +2404,8 @@ alleightpixels:
 
   	; dest18ng0 = dest18 && (~destMaskgreen128)
 
- 	 ; dest18ngf = dest18ng0 || dred18f
- 	POR 		XMM6, XMM7
+	 ; dest18ngf = dest18ng0 || dred18f
+	POR 		XMM6, XMM7
 	MOVDQU 	XMM3, XMM6
 	; green is calculated
 
@@ -2457,12 +2457,12 @@ alleightpixels:
 	 PADDUSW 	XMM7, XMM5 			; dblue18big
 	; dblue18f = (dblue18big >> 11)
 	PANDN 	XMM6, XMM3  			; dest18nr0
- 	PSRLW 		XMM7, 11 				; dblue18f
+	PSRLW 		XMM7, 11 				; dblue18f
 
- 	; dest18nr0 = dest18 && (~destMaskblue128)
+	; dest18nr0 = dest18 && (~destMaskblue128)
 
   	; dest18nbf = dest18nb0 || dblue18f
- 	POR 		XMM6, XMM7
+	POR 		XMM6, XMM7
 	MOVDQU 	XMM3, XMM6
 
 	; blue is calculated

source/IMAPClient.Mod

@@ -851,7 +851,7 @@ TYPE
 			RETURN OK;
 		END FetchSomeMessages;
 
- 		PROCEDURE FetchMessage*(message: Message): LONGINT;
+		PROCEDURE FetchMessage*(message: Message): LONGINT;
 		VAR
 			i: LONGINT;
 			number: ARRAY 20 OF CHAR;

source/JPEG2000DecoderCS.Mod

@@ -920,7 +920,7 @@ TYPE
 					3rd dim: resolution level
 					4th dim: subband (NOTE: 0 = LL at lowest resolution level; 0=HL, 1=LH, 2=HH otherwise)
 					5th dim: precinct index in the subband (in raster order)
- 					6th dim : code-block index in the precinct (in raster order)
+					6th dim : code-block index in the precinct (in raster order)
 				*)
 				cblkInfo : POINTER TO ARRAY OF ARRAY OF POINTER TO ARRAY OF POINTER TO ARRAY OF POINTER TO ARRAY OF POINTER TO ARRAY OF J2KU.CblkInfo;
 
@@ -1797,7 +1797,7 @@ TYPE
 													passtype := i MOD ENTROPY_NUM_PASSES;
 													(* passtype = 1 -> significance propagation pass -> skip *)
 													IF passtype # 1 THEN
- 														bitsUsed := lblock[curTile][comp][reslevel][subband][precno][cblkPrecIdx] + J2KU.Log2Floor(i - lastIdx);
+														bitsUsed := lblock[curTile][comp][reslevel][subband][precno][cblkPrecIdx] + J2KU.Log2Floor(i - lastIdx);
 
 														cblk[blocksInPacket].segLen[j] := NextBits(bitsUsed);
 
@@ -2894,7 +2894,7 @@ TYPE
 									PROG_LRCP:
 										ok := AdvanceLayResComPos ();
 								|	PROG_RLCP:
- 										ok := AdvanceResLayComPos ();
+										ok := AdvanceResLayComPos ();
 								|	PROG_RPCL:
 										ok := AdvanceResPosComLay ();
 								|	PROG_PCRL:
@@ -3316,7 +3316,7 @@ TYPE
 								PROG_LRCP:
 									ok := AdvanceLayResComPos ();
 							|	PROG_RLCP:
- 										ok := AdvanceResLayComPos ();
+										ok := AdvanceResLayComPos ();
 							|	PROG_RPCL:
 									ok := AdvanceResPosComLay ();
 							|	PROG_PCRL:
@@ -5502,7 +5502,7 @@ TYPE
 									PROG_LRCP:
 										ok := AdvanceLayResComPos();
 								|	PROG_RLCP:
- 										ok := AdvanceResLayComPos();
+										ok := AdvanceResLayComPos();
 								|	PROG_RPCL:
 										ok := AdvanceResPosComLay();
 								|	PROG_PCRL:

source/Linker.Mod

@@ -782,7 +782,7 @@ BEGIN
 	ASSERT (arrangement.displacement = BaseAddress);
 	WriteELFHeader;
 	WriteProgramHeader;
- 	WriteBinaryFile (linker, arrangement, writer);
+	WriteBinaryFile (linker, arrangement, writer);
 END WriteELFFile;
 
 PROCEDURE WriteMachOFile (linker: GenericLinker.Linker; arrangement: Arrangement; writer: Files.Writer);
@@ -872,7 +872,7 @@ BEGIN
 	WriteMachHeader;
 	WriteLoadCommand;
 	WriteThreadCommand;
- 	WriteBinaryFile (linker, arrangement, writer);
+	WriteBinaryFile (linker, arrangement, writer);
 END WriteMachOFile;
 
 PROCEDURE GetFileFormat (options: Options.Options; CONST name: Options.Name; default: FileFormat): FileFormat;

source/Oberon.Asteroids.Mod

@@ -871,7 +871,7 @@ BEGIN
 		ship.x:= RandomNumbers.Uniform() * Display.Width;
 		ship.y:= RandomNumbers.Uniform() * Display.Height;
 		ship.xvel:= 0.0; ship.yvel:= 0.0; ship.rot:= 0.0; ship.rotvel:= 0.0;
- 		F.changed:= TRUE;
+		F.changed:= TRUE;
 	END;
 END SWarp;
 

source/Oberon.Backup.Mod

@@ -142,7 +142,7 @@ MODULE Backup IN Oberon;	(** portable, except where noted *) (*JG 20.5.94/pm 16.
 	PROCEDURE ReadAll*;
       VAR freeEntries, freeSpace: INTEGER;
 	BEGIN
- 	   Texts.WriteString(W, "Backup.ReadAll"); Texts.WriteLn(W);
+	   Texts.WriteString(W, "Backup.ReadAll"); Texts.WriteLn(W);
 		Texts.Append(Oberon.Log, W.buf);
 		Diskette.OpenVol(freeEntries, freeSpace);
         Diskette.Enumerate(ReadEntry);

source/Oberon.ColorTools.Mod

@@ -288,7 +288,7 @@ BEGIN
 				ELSE NEW(F0); F.stamp := M.stamp; F.dlink := F0; CopyColorPicker(M, F, F0); M.obj := F0
 				END
 			END
- 		ELSIF M IS Display.FrameMsg THEN
+		ELSIF M IS Display.FrameMsg THEN
 			WITH M: Display.FrameMsg DO
 				x := M.x + F.X; y := M.y + F.Y; w := F.W; h := F.H; (* calculate actual coordinates *)
 				u := M.x; v := M.y; (* store volatile info *)

source/Oberon.DBF.Mod

@@ -116,11 +116,11 @@ MODULE DBF IN Oberon; (* ejz  *)
 	BEGIN
 		R.thisRecord := -1;
 		IF (record >= R.nRecords) OR (record < 0) THEN
- 			R.res := OutOfRange; RETURN
- 		END;
- 		Files.Set(R.R, Files.Base(R.R), R.firstRecord + record*R.sizeRecord);
- 		Files.Read(R.R, ch);
- 		IF ch = " " THEN
+			R.res := OutOfRange; RETURN
+		END;
+		Files.Set(R.R, Files.Base(R.R), R.firstRecord + record*R.sizeRecord);
+		Files.Read(R.R, ch);
+		IF ch = " " THEN
 	 		R.thisRecord := Files.Pos(R.R)-1; R.res := Done
 	 	ELSIF ch = CHR(27) THEN
 	 		R.res := RecordDeleted

source/Oberon.Edit.Mod

@@ -481,7 +481,7 @@ MODULE Edit IN Oberon;	(** portable *) (*JG 4.4.95 / NW 24.1.91*)
 				IF (S.class = Texts.Char) & (S.c = "*") THEN
 					Option; V := Oberon.MarkedViewer();
 					IF (V.dsc IS TextFrames.Frame) & (V.dsc.next IS TextFrames.Frame) THEN
- 						Menu := V.dsc(TextFrames.Frame); Text := V.dsc.next(TextFrames.Frame);
+						Menu := V.dsc(TextFrames.Frame); Text := V.dsc.next(TextFrames.Frame);
 						Texts.OpenScanner(S, Menu.text, 0); Texts.Scan(S);
 						TextFrames.Mark(Text, -1); PrintUnit(Text.text, 0); TextFrames.Mark(Text, 1)
 					END

source/Oberon.FontEditor.Mod

@@ -1163,11 +1163,11 @@ BEGIN
 		IF F # NIL THEN
 			Files.Set(R, F, 0); LoadFont(f, R);
 			Out.Int(f.pos, 0); Out.String(" Bytes loaded");Out.Ln;
- 		   obj := Gadgets.FindObj(Gadgets.context, "table");
+		   obj := Gadgets.FindObj(Gadgets.context, "table");
 			IF obj#NIL THEN
 				obj(Fonttable).f:= f;
 			END;
- 		   obj := Gadgets.FindObj(Gadgets.context, "preview");
+		   obj := Gadgets.FindObj(Gadgets.context, "preview");
 			IF obj#NIL THEN
 				obj(Preview).f:= f;
 				Gadgets.Update(obj)

source/Oberon.HPLaserPrinter.Mod

@@ -199,8 +199,8 @@ END Pos;
 
 PROCEDURE SetRes(res: INTEGER);
 BEGIN
- 	Files.Write(r, ESC);  Files.Write(r, "*");  Files.Write(r, "t");  WriteInt(res);
- 	Files.Write(r, "R")
+	Files.Write(r, ESC);  Files.Write(r, "*");  Files.Write(r, "t");  WriteInt(res);
+	Files.Write(r, "R")
 END SetRes;
 
 PROCEDURE Block(w, h: INTEGER);

source/Oberon.Hex.Mod

@@ -1130,7 +1130,7 @@ END Interpret;
 
 (** Searches for the given pattern in the current or marked document. The pattern is either a string,
 	a hex-stream or a bit-stream.
- 	Usage: HexDocs.Seach ['^' | string | #b{bitdigit} | #h{hexdigit}]
+	Usage: HexDocs.Seach ['^' | string | #b{bitdigit} | #h{hexdigit}]
  *)
 PROCEDURE Search*;
 VAR F: Frame; T: Texts.Text; val, pos, beg, end, time: LONGINT; S: Texts.Scanner;

source/Oberon.NamePlates.Mod

@@ -18,10 +18,10 @@ IMPORT
 	Documents, Viewers, Desktops;
 
 CONST
- 	(* name plates *)
- 	VersionNo = 1; MaxLen = 128; CarHeight = 14; CarWidth = 2; Xoffset = 10;
- 	TranslatePlate = TRUE; (* fof *)
- 	PrefixBehind = FALSE;
+	(* name plates *)
+	VersionNo = 1; MaxLen = 128; CarHeight = 14; CarWidth = 2; Xoffset = 10;
+	TranslatePlate = TRUE; (* fof *)
+	PrefixBehind = FALSE;
 
 TYPE
 	NamePlate* = POINTER TO NamePlateDesc;

source/Oberon.OPC.Mod

@@ -580,7 +580,7 @@ Intel i386 :
 				x.mode := RegRel; x.offs := x.adr; x.adr := sl.adr; x.inx := none
 			END
 		END
- 	END CompleteSL;
+	END CompleteSL;
 
 	PROCEDURE loadAdr (VAR x: Item);
 	(* load address into a register *)
@@ -1865,7 +1865,7 @@ Intel i386 :
 			END;
 			z.typ := type;
 			GenStore(store, z, x);
- 			IF z.mode IN {Var, Abs} THEN INC(z.adr, oldSize) ELSE INC(z.offs, oldSize) END
+			IF z.mode IN {Var, Abs} THEN INC(z.adr, oldSize) ELSE INC(z.offs, oldSize) END
 		ELSIF (size.mode = Con) & (size.adr = 3) & (moveSize = OPO.Bit8) THEN	(* special case, often used *)
 			IF x.mode # Reg THEN loadAdr(x) END;
 			IF z.mode # Reg THEN loadAdr(z) END;

source/Oberon.OPV.Mod

@@ -963,7 +963,7 @@ Statements
 						OPC.Mod (z, x, y)
 				  | and:
 						OPC.And (z, x, y)
- 				 | plus:
+				 | plus:
 						OPC.Add (z, x, y, f)
 				  | minus:
 						OPC.Sub (z, x, y, f)

source/Oberon.Oberon.Mod

@@ -166,17 +166,17 @@ scheduling of tasks, cursor handling and command execution.
   	END FlipStar;
 
  (** Initialize a cursor, setting it to off, and at position 0, 0. *)
- 	PROCEDURE OpenCursor* (VAR c: Cursor);
+	PROCEDURE OpenCursor* (VAR c: Cursor);
   	BEGIN c.on := FALSE; c.X := 0; c.Y := 0
   	END OpenCursor;
 
  (** Fade cursor if visible. *)
- 	PROCEDURE FadeCursor* (VAR c: Cursor);
+	PROCEDURE FadeCursor* (VAR c: Cursor);
   	BEGIN IF c.on THEN c.marker.Fade(c.X, c.Y); c.on := FALSE END
   	END FadeCursor;
 
  (** Draw cursor c using marker m at position X, Y. *)
- 	PROCEDURE DrawCursor* (VAR c: Cursor; VAR m: Marker; X, Y: INTEGER);
+	PROCEDURE DrawCursor* (VAR c: Cursor; VAR m: Marker; X, Y: INTEGER);
   	BEGIN
 	  	IF c.on & ((X # c.X) OR (Y # c.Y) OR (m.Draw # c.marker.Draw)) THEN
             c.marker.Fade(c.X, c.Y); c.on := FALSE

source/Oberon.RXA.Mod

@@ -110,71 +110,71 @@ VAR
 (* set operations for TYPE PosSet *)
 
  PROCEDURE PSEmpty( VAR set : PosSet );
- 	VAR i : INTEGER;
+	VAR i : INTEGER;
  BEGIN
- 	i := 0; WHILE i < mult DO set[i] := {}; INC(i) END
+	i := 0; WHILE i < mult DO set[i] := {}; INC(i) END
  END PSEmpty;
 
  PROCEDURE PSIsEmpty( set : PosSet ) : BOOLEAN;
  VAR i : INTEGER;
  BEGIN
- 	i := 0; WHILE i < mult DO IF set[i] # {} THEN RETURN FALSE END; INC(i) END;
- 	RETURN TRUE
+	i := 0; WHILE i < mult DO IF set[i] # {} THEN RETURN FALSE END; INC(i) END;
+	RETURN TRUE
  END PSIsEmpty;
 
  PROCEDURE PSIsEqual( set1, set2 : PosSet ) : BOOLEAN;
- 	VAR i : INTEGER;
+	VAR i : INTEGER;
  BEGIN
- 	i := 0; WHILE i < mult DO IF set1[i] # set2[i] THEN RETURN FALSE END; INC(i) END;
- 	RETURN TRUE
+	i := 0; WHILE i < mult DO IF set1[i] # set2[i] THEN RETURN FALSE END; INC(i) END;
+	RETURN TRUE
  END PSIsEqual;
 
  PROCEDURE PSIn( set : PosSet; v : INTEGER ) : BOOLEAN;
  BEGIN
- 	RETURN ( v MOD nofSET ) IN set[v DIV nofSET]
+	RETURN ( v MOD nofSET ) IN set[v DIV nofSET]
  END PSIn;
 
  PROCEDURE PSIncl( VAR set : PosSet; v : INTEGER );
  BEGIN
- 	INCL( set[v DIV nofSET], v MOD nofSET )
+	INCL( set[v DIV nofSET], v MOD nofSET )
  END PSIncl;
 
  PROCEDURE PSUnion( set1, set2 : PosSet; VAR resset : PosSet );
- 	VAR i : INTEGER;
+	VAR i : INTEGER;
  BEGIN
- 	i := 0; WHILE i < mult DO resset[i] := set1[i] + set2[i]; INC(i) END
+	i := 0; WHILE i < mult DO resset[i] := set1[i] + set2[i]; INC(i) END
  END PSUnion;
 
 
  PROCEDURE GetChar(): CHAR;
- 	VAR ch: CHAR;
+	VAR ch: CHAR;
  BEGIN
- 	ch := rxl[rxpos];
- 	CASE countflag OF
- 		0 : IF (ch = 0X) OR (rxpos >= LEN(rxl (* ^ *)) ) THEN INC( countflag ); RETURN ")"
- 			 ELSE INC(rxpos); RETURN ch
- 			 END |
- 		1 : INC( countflag ); RETURN ("#")
- 	ELSE
- 		IF errorvar = chrleft THEN errorvar := noerror END; RETURN("#")
- 	END
+	ch := rxl[rxpos];
+	CASE countflag OF
+		0 : IF (ch = 0X) OR (rxpos >= LEN(rxl (* ^ *)) ) THEN INC( countflag ); RETURN ")"
+			 ELSE INC(rxpos); RETURN ch
+			 END |
+		1 : INC( countflag ); RETURN ("#")
+	ELSE
+		IF errorvar = chrleft THEN errorvar := noerror END; RETURN("#")
+	END
  END GetChar;
 
  PROCEDURE SetPosition ( ptr : NodePtr; chr : CHAR );
  BEGIN
- 	IF treepos < nofpos THEN
- 		ptr.pos := treepos;
- 		PSIncl( ptr.first, treepos );
- 		PSIncl( ptr.last, treepos );
- 		ptr.nullable := FALSE;
- 		pd[treepos].ch := chr;
- 		pd[treepos].shorthand := tokenval = shorthand;
- 		pd[treepos].notoperator := notflag;
- 		PSEmpty(pd[treepos].follow);
- 		INC(treepos)
- 	ELSE
- 		errorvar := noposfree
- 	END
+	IF treepos < nofpos THEN
+		ptr.pos := treepos;
+		PSIncl( ptr.first, treepos );
+		PSIncl( ptr.last, treepos );
+		ptr.nullable := FALSE;
+		pd[treepos].ch := chr;
+		pd[treepos].shorthand := tokenval = shorthand;
+		pd[treepos].notoperator := notflag;
+		PSEmpty(pd[treepos].follow);
+		INC(treepos)
+	ELSE
+		errorvar := noposfree
+	END
 END SetPosition;
 
 PROCEDURE NewNode( VAR ptr : NodePtr );

source/Oberon.Rembrandt0.Mod

@@ -354,13 +354,13 @@ BEGIN
 		END
 	ELSIF M IS Objects.AttrMsg THEN
 		WITH M: Objects.AttrMsg DO
- 		 IF M.id = Objects.get THEN
+		 IF M.id = Objects.get THEN
   		  IF M.name = "Gen" THEN
    		   M.class := Objects.String; COPY("Rembrandt0.NewColFrame", M.s); M.res := 0
   		  ELSIF M.name = "Color" THEN
   		    M.class := Objects.Int; M.i := F.col; M.res := 0
   		  ELSE Gadgets.framehandle(F, M)
- 		   END
+		   END
 		  ELSIF M.id = Objects.set THEN
   		  IF M.name = "Color" THEN
    		   IF M.class = Objects.Int THEN
@@ -369,7 +369,7 @@ BEGIN
   		  ELSE Gadgets.framehandle(F, M);
   		  END
 		  ELSIF M.id = Objects.enum THEN
- 		   M.Enum("Color"); M.Enum("Cmd"); Gadgets.framehandle(F, M)
+		   M.Enum("Color"); M.Enum("Cmd"); Gadgets.framehandle(F, M)
   		END
 		END
     ELSIF M IS Objects.CopyMsg THEN

source/Oberon.Swarm.Mod

@@ -609,7 +609,7 @@ MODULE Swarm IN Oberon;  (** BES, Oct 16 96 - Oct 25 96 *)
 			SHORT(GetInt(MinColObj, MinColDef)), SHORT(GetInt(MaxColObj, MaxColDef)),
 			SHORT(GetInt(BAccObj, BAccDef)), SHORT(GetInt(BVelObj, BVelDef)),
 			SHORT(GetInt(WAccObj, WAccDef)), SHORT(GetInt(WVelObj, WVelDef)))
- 	END Screensaver;
+	END Screensaver;
 
 
 	(* Screensaver Task *)

source/OberonFonts.Mod

@@ -69,9 +69,9 @@ TYPE
 		VAR
 			file: Files.File;  font: OType.Font;  i, chars, ranges, xmin, ymin, xmax, ymax, j: INTEGER;
 			beg, end: ARRAY 64 OF INTEGER;  data: RasterData;  no, bytes, k: LONGINT;
- 			ras: OpenTypeScan.Rasterizer;
- 			w: Files.Writer;  ipos, apos: LONGINT;
- 			pattern: ARRAY 360*360 DIV 8 OF CHAR;				(* enough for 36 point at 720 dpi *)
+			ras: OpenTypeScan.Rasterizer;
+			w: Files.Writer;  ipos, apos: LONGINT;
+			pattern: ARRAY 360*360 DIV 8 OF CHAR;				(* enough for 36 point at 720 dpi *)
 	BEGIN
 		file := Files.New( name );
 		ASSERT(file # NIL);

source/OpenTypeFonts.Mod

@@ -89,7 +89,7 @@ MODULE OpenTypeFonts; (** AUTHOR "eos, PL"; PURPOSE "Bluebottle port of OpenType
 		VAR
 			file: Files.File; r, m: Files.Rider; font: OType.Font; i, chars, ranges, xmin, ymin, xmax, ymax, j: INTEGER;
 			beg, end: ARRAY 64 OF INTEGER; data: RasterData; no, bytes, k: LONGINT;
- 			ras: OpenTypeScan.Rasterizer;
+			ras: OpenTypeScan.Rasterizer;
 	BEGIN
 		file := Files.New(name);
 		ASSERT(file # NIL);

source/PCGARM.Mod

@@ -608,8 +608,8 @@ BEGIN
 	| PCLIR.tae: cond := PCO.HI
 	| PCLIR.tne: cond := NE
 	END;
- 	PCO.SWI(cond, instr.val);
- 	IF (instr.op = PCLIR.trap) & (instr.val # MAX(INTEGER)) THEN pool.Flush(PCO.GetCodePos()) END
+	PCO.SWI(cond, instr.val);
+	IF (instr.op = PCLIR.trap) & (instr.val # MAX(INTEGER)) THEN pool.Flush(PCO.GetCodePos()) END
 END Trap;
 
 PROCEDURE SaveRegisters(code: PCLIR.Code; VAR instr: PCLIR.Instruction; pc: LONGINT);

source/PCOF.Mod

@@ -344,9 +344,9 @@ VAR commands: ARRAY 128 OF PCT.Proc;
 					IF bsym.mod # scope.owner THEN UseModule(bsym.mod.adr(PCBT.Module)) END
 				END;
 				rec := rec.link;
- 				ASSERT(rec # scope.records, MAX(INTEGER));
- 					(* Fix bug, sometimes this assertion fails. *)
- 					(* fof 070920: done, cf. PCC.MakeTD *)
+				ASSERT(rec # scope.records, MAX(INTEGER));
+					(* Fix bug, sometimes this assertion fails. *)
+					(* fof 070920: done, cf. PCC.MakeTD *)
 			END
 		END;
 (*
@@ -1167,7 +1167,7 @@ VAR commands: ARRAY 128 OF PCT.Proc;
 						par := par.nextPar
 					END;
 					PCM.ObjWLIntAt(R, nofPtrPos, nofptrs);
- 					IF nofptrs > maxPtrs THEN maxPtrs := nofptrs END;
+					IF nofptrs > maxPtrs THEN maxPtrs := nofptrs END;
 					INC(nofProcs);
 				END;
 				p := s.firstProc;

source/PCV.Mod

@@ -60,7 +60,7 @@ BEGIN
 			(* fof end *)
        	ELSE  size := PCLIR.CG.ParamAlign
        	END
- 		(** fof >> *)
+		(** fof >> *)
 		ELSIF   isRef & enhopen THEN  (* VAR A: ARRAY [..] OF ... *)
 			size := PCLIR.CG.ParamAlign
 		(** << fof  *)

source/PDF.Mod

@@ -323,7 +323,7 @@ TYPE
 			IF WMGraphics.FontBold IN style THEN s := 1;
 				IF WMGraphics.FontItalic IN style THEN s := 3 END;
 			ELSIF WMGraphics.FontItalic IN style THEN s := 2
- 			END;
+			END;
 			CASE type OF
 				|FontTimes :
 					CASE s OF

source/PET.Mod

@@ -2181,7 +2181,7 @@ TYPE
 				compileBtn.caption.SetAOC(currentPage.compilerSettings.caption);
 				findPCBtn.visible.Set(currentPage.compilerSettings.findPC);
 
- 				optionsEdit.GetAsString(options); COPY(options, currentPage.options);
+				optionsEdit.GetAsString(options); COPY(options, currentPage.options);
 				currentPage.modified := FALSE;
 				SetModified(FALSE);
 

source/Partitions.Mod

@@ -306,8 +306,8 @@ END SetConfig;
 (** Perform a read check on partition *)
 PROCEDURE Check*(context : Commands.Context); (** dev#part *)
 VAR
- 	selection : Lib.Selection;
- 	checkPartition : Lib.CheckPartition;
+	selection : Lib.Selection;
+	checkPartition : Lib.CheckPartition;
 BEGIN
 	IF GetSelection(context, FALSE, selection) THEN
 		NEW(checkPartition, selection.disk, selection.partition, context.out);

source/PartitionsLib.Mod

@@ -920,7 +920,7 @@ TYPE
 	 *	2. Pass parameters (child object will have parameters as fields)
 	 *	3. IF parameters are valid, set alive := TRUE, else, set alive := FALSE
 	 *	4. Add object to PartitionsLib.registry via Add
- 	 *	5. Call SetStart
+	 *	5. Call SetStart
 	 *	6. As long as StatusRunning IN state.status the object is active
 	 * 	7. Terminate object via Abort & AwaitDead
 	 *)

source/RTL8136.Mod

@@ -542,7 +542,7 @@ TYPE
 		PROCEDURE hw_init;
 		BEGIN
 			CASE hwCfgMethod OF
- 				|CFG_METHOD_10,CFG_METHOD_11,CFG_METHOD_12,CFG_METHOD_13,CFG_METHOD_14,CFG_METHOD_15,CFG_METHOD_16,CFG_METHOD_17:
+				|CFG_METHOD_10,CFG_METHOD_11,CFG_METHOD_12,CFG_METHOD_13,CFG_METHOD_14,CFG_METHOD_15,CFG_METHOD_16,CFG_METHOD_17:
 					Write8(Cfg9346, Cfg9346_Unlock);
 					Write8(Config5, Read8(Config5) - {0});
 					Write8(Config2, Read8(Config2) - {7});
@@ -1078,7 +1078,7 @@ TYPE
 
 				(* Write8(Config1, 0xDF);*)
 
- 				Write8(0xF4, 0x01);
+				Write8(0xF4, 0x01);
 
 				Write8(Config3, Read8(Config3) & ~Beacon_en);*)
 			ELSIF hwCfgMethod = CFG_METHOD_10 THEN

source/Raster.Mod

@@ -3160,11 +3160,11 @@ MODULE Raster; (** non-portable *)	(* eos, TF  **)
 		; dred18f = dred18big && destMaskred128  because >> 11 and << 11 is && mask
 		PAND 		XMM7, XMM6 ; dred18f
 
- 		; dest18nr0 = dest18 && (~destMaskred128)
- 		PANDN 	XMM6, XMM3  ; dest18nr0
+		; dest18nr0 = dest18 && (~destMaskred128)
+		PANDN 	XMM6, XMM3  ; dest18nr0
 
- 		; dest18nrf = dest18nr0 || dred18f
- 		POR 		XMM6, XMM7
+		; dest18nrf = dest18nr0 || dred18f
+		POR 		XMM6, XMM7
 
 		MOVDQU 	XMM3, XMM6
 
@@ -3230,10 +3230,10 @@ MODULE Raster; (** non-portable *)	(* eos, TF  **)
 		PSRLW 		XMM7, 10 ; dgreen18f
 		PSLLW 		XMM7, 5
 
- 		; dest18ng0 = dest18 && (~destMaskgreen128)
+		; dest18ng0 = dest18 && (~destMaskgreen128)
 
   		; dest18ngf = dest18ng0 || dred18f
- 		POR 		XMM6, XMM7
+		POR 		XMM6, XMM7
 		MOVDQU 	XMM3, XMM6
 
 		; green is calculated
@@ -3286,12 +3286,12 @@ MODULE Raster; (** non-portable *)	(* eos, TF  **)
 	 	PADDUSW 	XMM7, XMM5 ; dblue18big
 		; dblue18f = (dblue18big >> 11)
 		PANDN 	XMM6, XMM3  ; dest18nr0
- 		PSRLW 		XMM7, 11 ; dblue18f
+		PSRLW 		XMM7, 11 ; dblue18f
 
   		; dest18nr0 = dest18 && (~destMaskblue128)
 
   		; dest18nbf = dest18nb0 || dblue18f
- 		POR 		XMM6, XMM7
+		POR 		XMM6, XMM7
 		MOVDQU 	XMM3, XMM6
 
 		; blue is calculated
@@ -3570,11 +3570,11 @@ MODULE Raster; (** non-portable *)	(* eos, TF  **)
 		; dred18f = dred18big && destMaskred128  because >> 11 and << 11 is && mask
 		PAND 		XMM7, XMM6 ; dred18f
 
- 		; dest18nr0 = dest18 && (~destMaskred128)
- 		PANDN 	XMM6, XMM3  ; dest18nr0
+		; dest18nr0 = dest18 && (~destMaskred128)
+		PANDN 	XMM6, XMM3  ; dest18nr0
 
- 		; dest18nrf = dest18nr0 || dred18f
- 		POR 		XMM6, XMM7
+		; dest18nrf = dest18nr0 || dred18f
+		POR 		XMM6, XMM7
 
 		MOVDQU 	XMM3, XMM6
 
@@ -3640,10 +3640,10 @@ MODULE Raster; (** non-portable *)	(* eos, TF  **)
 		PSRLW 		XMM7, 10 ; dgreen18f
 		PSLLW 		XMM7, 5
 
- 		; dest18ng0 = dest18 && (~destMaskgreen128)
+		; dest18ng0 = dest18 && (~destMaskgreen128)
 
   		; dest18ngf = dest18ng0 || dred18f
- 		POR 		XMM6, XMM7
+		POR 		XMM6, XMM7
 		MOVDQU 	XMM3, XMM6
 
 		; green is calculated
@@ -3696,12 +3696,12 @@ MODULE Raster; (** non-portable *)	(* eos, TF  **)
 	 	PADDUSW 	XMM7, XMM5 ; dblue18big
 		; dblue18f = (dblue18big >> 11)
 		PANDN 	XMM6, XMM3  ; dest18nr0
- 		PSRLW 		XMM7, 11 ; dblue18f
+		PSRLW 		XMM7, 11 ; dblue18f
 
   		; dest18nr0 = dest18 && (~destMaskblue128)
 
   		; dest18nbf = dest18nb0 || dblue18f
- 		POR 		XMM6, XMM7
+		POR 		XMM6, XMM7
 		MOVDQU 	XMM3, XMM6
 
 		; blue is calculated

source/SSH.Mod

@@ -800,7 +800,7 @@ TYPE
 		IF  LEN( strings^ ) # 2 THEN  Log.String( usage ); Log.Ln;  RETURN  END;
 		Strings.StrToInt( strings[0]^, locPort );
 		Strings.StrToInt( strings[1]^, destPort );
- 		f := forwarderList;
+		f := forwarderList;
 		WHILE f # NIL DO
 			IF f.localPort = locPort THEN
 				Log.String( "Error: port in use: " );  Log.Int( f.localPort, 1 );  Log.Ln;  RETURN

source/SambaClient.Mod

@@ -112,10 +112,10 @@ TYPE
 
 			IF ~check THEN
 				IF Trace THEN KernelLog.String(" -- ERROR on Delete"); KernelLog.Ln(); END;
- 				res := -1;
- 			ELSE
- 				res := 0;
- 			END;
+				res := -1;
+			ELSE
+				res := 0;
+			END;
 		END Delete0;
 
 		(** Rename a file. res = 0 indicates success.  End users use Files.Rename instead. *)
@@ -156,10 +156,10 @@ TYPE
 
 			IF ~check THEN
 				IF Trace THEN KernelLog.String(" -- ERROR on Rename"); KernelLog.Ln(); END;
- 				res := -1;
- 			ELSE
- 				res := 0;
- 			END;
+				res := -1;
+			ELSE
+				res := 0;
+			END;
 		END Rename0;
 
 		(** Enumerate canonical file names. mask may contain * wildcards.  For internal use only.  End users use Enumerator instead. *)
@@ -216,8 +216,8 @@ TYPE
 				IF ~check THEN
 					IF Trace THEN KernelLog.String(" -- ERROR on Enumerate"); KernelLog.Ln(); END;
 	 				lock.Release();
- 					RETURN;
- 				END;
+					RETURN;
+				END;
 
 				(* RECEIVE *)
 				c.in.SkipBytes(1);		(* wct *)
@@ -345,10 +345,10 @@ TYPE
 
 			IF ~check THEN
 				IF Trace THEN KernelLog.String(" -- ERROR on CreateDirectory"); KernelLog.Ln(); END;
- 				res := -1;
- 			ELSE
- 				res := 0;
- 			END;
+				res := -1;
+			ELSE
+				res := 0;
+			END;
 		END CreateDirectory0;
 
 		(** Remove a directory. If force=TRUE, any subdirectories and files should be automatically deleted.
@@ -377,10 +377,10 @@ TYPE
 
 			IF ~check THEN
 				IF Trace THEN KernelLog.String(" -- ERROR on DeleteDirectory"); KernelLog.Ln(); END;
- 				res := -1;
- 			ELSE
- 				res := 0;
- 			END;
+				res := -1;
+			ELSE
+				res := 0;
+			END;
 		END RemoveDirectory0;
 
 		(** Finalize the file system. *)
@@ -437,9 +437,9 @@ TYPE
 		BEGIN
 			IF Trace THEN KernelLog.String("File.ReadBytes - Read AndX"); KernelLog.Ln(); END;
 
- 			fs(FileSystem).lock.Acquire();
+			fs(FileSystem).lock.Acquire();
 
- 			IF ~(openRead & (key # 0)) THEN
+			IF ~(openRead & (key # 0)) THEN
 				localKey := OpenAndX(c, filename, 40H, FALSE);
 
 				IF localKey # 0 THEN
@@ -450,7 +450,7 @@ TYPE
 					fs(FileSystem).lock.Release();
 					RETURN;
 				END;
- 			END;
+			END;
 
 		 	adjOff := 0;
 			r.res := 0;
@@ -479,12 +479,12 @@ TYPE
 			 	(* RECEIVE *)
 			 	check := RecieveResponse(2EX, c);
 
- 				IF ~check THEN
- 					IF Trace THEN KernelLog.String(" -- ERROR on Read AndX"); KernelLog.Ln(); END;
- 					r.res := r.res + len;
- 					fs(FileSystem).lock.Release();
- 					RETURN;
- 				END;
+				IF ~check THEN
+					IF Trace THEN KernelLog.String(" -- ERROR on Read AndX"); KernelLog.Ln(); END;
+					r.res := r.res + len;
+					fs(FileSystem).lock.Release();
+					RETURN;
+				END;
 
 				c.in.SkipBytes(13);
 				c.in.RawInt(dataOff);
@@ -547,7 +547,7 @@ TYPE
 					fs(FileSystem).lock.Release();
 					RETURN;
 				END;
- 			END;
+			END;
 
 			IF Trace THEN
 				KernelLog.String("FileSystem.WriteBytes - Write AndX");
@@ -591,19 +591,19 @@ TYPE
 			 	c.out.Update();
 
 				(* RECEIVE *)
- 				check := RecieveResponse(2FX, c);
+				check := RecieveResponse(2FX, c);
 
- 				IF ~check THEN
+				IF ~check THEN
 	 				IF Trace THEN KernelLog.String(" -- ERROR on Write AndX"); KernelLog.Ln(); END;
- 					fs(FileSystem).lock.Release();
- 					RETURN;
- 				END;
+					fs(FileSystem).lock.Release();
+					RETURN;
+				END;
 
- 				c.in.SkipBytes(5);
- 				c.in.RawInt(bytesWritten);
+				c.in.SkipBytes(5);
+				c.in.RawInt(bytesWritten);
 
- 				IF Trace THEN
- 					KernelLog.String(" -- Bytes written: "); KernelLog.Int(bytesWritten, 0); KernelLog.Ln();
+				IF Trace THEN
+					KernelLog.String(" -- Bytes written: "); KernelLog.Int(bytesWritten, 0); KernelLog.Ln();
 				END;
 
 				r.apos := r.apos + bytesWritten;
@@ -640,16 +640,16 @@ TYPE
 			(* RECEIVE *)
 		 	check := RecieveResponse(08X, c);
 
- 			IF ~check THEN
- 				IF Trace THEN
+			IF ~check THEN
+				IF Trace THEN
 	 				KernelLog.String(" -- ERROR on Query Information Request"); KernelLog.Ln();
 	 			END;
- 				fs(FileSystem).lock.Release();
- 				RETURN 0;
- 			END;
+				fs(FileSystem).lock.Release();
+				RETURN 0;
+			END;
 
- 			c.in.SkipBytes(7);
- 			c.in.RawLInt(filesize);
+			c.in.SkipBytes(7);
+			c.in.RawLInt(filesize);
 
 			fs(FileSystem).lock.Release();
 

source/Solaris.Unix.Mod

@@ -220,7 +220,7 @@ CONST
 
 
 	FIONREAD*	=  4004667FH;
- 	TIOCMGET*		=  0741DH;
+	TIOCMGET*		=  0741DH;
 	TIOCMSET*		=  0741AH;
 
 	(* Speeds *)

source/StartMenu.Mod

@@ -195,7 +195,7 @@ TYPE
 					IF ptr IS WMStandardComponents.Button THEN
 						b := ptr(WMStandardComponents.Button);
 						s := b.caption.Get();
- 						IF (s # NIL) & (UTF8Strings.Compare(s^, "") # UTF8Strings.CmpEqual) THEN
+						IF (s # NIL) & (UTF8Strings.Compare(s^, "") # UTF8Strings.CmpEqual) THEN
 							menuButtons[i] := b; INC(i);
 							FindSMO(b, smo);
 							IF smo # NIL THEN smos[j] := smo; INC(j) END;

source/System.Mod

@@ -626,7 +626,7 @@ BEGIN
 END Repeat;
 
 (** Time interval measurement
- 	- start/starth [number]: Set timer <number> to current time (number = 0 if omitted)
+	- start/starth [number]: Set timer <number> to current time (number = 0 if omitted)
   	- elapsed/elapsedh [number]: Display time difference between timer <number> and the current time (number = 0 if omitted)
 	- diff/diffh number1 number2: Display time difference between the two timers
 	*)

source/TFPET.Mod

@@ -2138,7 +2138,7 @@ TYPE
 				compileBtn.caption.SetAOC(currentPage.compilerSettings.caption);
 				findPCBtn.visible.Set(currentPage.compilerSettings.findPC);
 
- 				optionsEdit.GetAsString(options); COPY(options, currentPage.options);
+				optionsEdit.GetAsString(options); COPY(options, currentPage.options);
 				currentPage.modified := FALSE;
 				SetModified(FALSE);
 

source/TFTypeSys.Mod

@@ -1013,7 +1013,7 @@ VAR r : Streams.Reader;
 	receiver : Streams.Receiver;
 	fn, name, ofn : ARRAY 128 OF CHAR;
 	m : Module; version : LONGINT;
- 	f : Files.File;
+	f : Files.File;
 	fr : Files.Reader;
 BEGIN
 	IF TarBasedDB THEN

source/TaskScheduler.Mod

@@ -36,7 +36,7 @@ TYPE
 	Task* = OBJECT
 	VAR
 		id- : LONGINT;
- 	 	timestamp- : LONGINT;
+	 	timestamp- : LONGINT;
 
 		info : TaskInfo;
 

source/TestFiles.Mod

@@ -122,7 +122,7 @@ TYPE
 				file.Set(rider, position);
 				log.String("Ok");
 			END;
- 		END FileSet;
+		END FileSet;
 
 		PROCEDURE GetInteger(r : Streams.Reader; VAR integer : LONGINT) : BOOLEAN;
 		BEGIN

source/Unix.DisplayRefresher.Mod

@@ -15,9 +15,9 @@ BEGIN
 	discard := FALSE;
 	IF msg.msgType = WMMessages.MsgKey THEN
 		meta := (msg.flags * Inputs.Meta # {}) OR ((msg.flags * Inputs.Alt # {}) & (msg.flags * Inputs.Shift # {}));
- 		IF ~meta & (msg.y =  0FFC6H) THEN
- 			manager.RefreshView(viewport);
- 		END;
+		IF ~meta & (msg.y =  0FFC6H) THEN
+			manager.RefreshView(viewport);
+		END;
 	END;
 END Handle;
 

source/Unix.Glue.Mod

@@ -60,13 +60,13 @@ VAR
 	END Header;
 
 
- 	PROCEDURE Char ( c: CHAR );
+	PROCEDURE Char ( c: CHAR );
 	BEGIN
 		cout( c )
 	END Char;
 
 
- 	PROCEDURE Dlsym*( handle: ADDRESS; CONST name: ARRAY OF CHAR; adr: ADDRESS );
+	PROCEDURE Dlsym*( handle: ADDRESS; CONST name: ARRAY OF CHAR; adr: ADDRESS );
 	VAR val: ADDRESS;
 	BEGIN
 		val := dlsym( handle, ADDRESSOF( name[0] ) );

source/Unix.X11Api.Mod

@@ -190,7 +190,7 @@ CONST
 				   cmap entry
 				- attempt to store into a read-only
 				   color map entry.
- 				- attempt to modify the access control
+				- attempt to modify the access control
 				   list from other than the local host.
 				*)
 	BadAlloc* = 11; (* insufficient resources *)
@@ -323,7 +323,7 @@ CONST
  **************************************************************** *)
 
 	(* for ChangeHosts *)
- 	HostInsert* = 0; HostDelete* = 1;
+	HostInsert* = 0; HostDelete* = 1;
 
 	(* for ChangeAccessControl *)
 	EnableAccess* = 1; DisableAccess* = 0;
@@ -509,7 +509,7 @@ TYPE
 
 	(*!
 		 This union is defined so Xlib can always use the same sized
- 		event structure internally, to avoid memory fragmentation.
+		event structure internally, to avoid memory fragmentation.
 
 		In C,  XEvent type is union of all event types with size of 192 bytes ,
 		In Oberon, other event fields are padded with chars to prevent memory leaks.

source/UsbEhci.Mod

@@ -102,7 +102,7 @@ CONST
 	StsReclamation * = {13};
 	StsHcHalted * = {12};
 	(* HcUsbSts & HcUsbIntr common fields *)
- 	StsAsyncAdvance * = {5};
+	StsAsyncAdvance * = {5};
 	StsHostSystemError * = {4};
 	StsFrameListRollover * = {3};
 	StsPortChange * = {2};
@@ -2191,7 +2191,7 @@ END ShowItd;
 PROCEDURE ShowInterrupts * (s : SET);
 BEGIN
 	IF Debug.Trace THEN
- 	IF s * StsAsyncAdvance # {} THEN KernelLog.String("[AsyncAdvance]"); END;
+	IF s * StsAsyncAdvance # {} THEN KernelLog.String("[AsyncAdvance]"); END;
 	IF s * StsHostSystemError # {} THEN KernelLog.String("[HostSystemError]"); END;
 	IF s * StsFrameListRollover # {} THEN KernelLog.String("[FrameListRollover]"); END;
 	IF s * StsPortChange # {} THEN KernelLog.String("[PortChange]"); END;

source/UsbFTDI.Mod

@@ -718,7 +718,7 @@ TYPE
 		*   (((BaseClock / 2 / BaudRate) & 4) ? 0x4000    // 0.5
 		*    : ((BaseClock / 2 / BaudRate) & 2) ? 0x8000  // 0.25
 		*    : ((BaseClock / 2 / BaudRate) & 1) ? 0xc000  // 0.125
- 		*    : 0)
+		*    : 0)
 		*
 		* For the FT232BM, a 17th divisor bit was introduced to encode the multiples
 		* of 0.125 missing from the FT8U232AM.  Bits 16 to 14 are coded as follows
@@ -740,7 +740,7 @@ TYPE
 		* 0.  Additionally for the FT232BM, if the calculated divisor value is 0x4001
 		* (1.5), this needs to be replaced with 0x0001 (1) (but this divisor value is
 		* not supported by the FT8U232AM).
- 		*)
+		*)
 
 (*
 		PROCEDURE BaseToDivisor(baud:INTEGER ):LONGINT;

source/UsbSkeleton.Mod

@@ -51,8 +51,8 @@ TYPE
 	END YourDriver;
 
 (**	The Probe procedure uses the device descriptor and configuration descriptors provided by the device to
- 	see whether the device can be handled by the device driver. If not, the probe procedure returns NIL, otherwise
- 	it returns an instance of the device driver object. *)
+	see whether the device can be handled by the device driver. If not, the probe procedure returns NIL, otherwise
+	it returns an instance of the device driver object. *)
 PROCEDURE Probe(dev : Usbdi.UsbDevice; id : Usbdi.InterfaceDescriptor) : Usbdi.Driver;
 VAR driver : YourDriver;
 BEGIN

source/Visualizer.Mod

@@ -537,7 +537,7 @@ TYPE
 						IF (typeDecl.type.procedure.delegate) THEN out.String("[DELEGATE] "); END;
 						FormalPars(typeDecl.type.procedure.formalPars);
 					END;
- 					out.String('}"'); out.Ln;
+					out.String('}"'); out.Ln;
 					Indent(indent + 4); out.String("]"); out.Ln;
 				END;
 			END;

source/WMCDRecorder.Mod

@@ -2,8 +2,8 @@ MODULE WMCDRecorder;
 
 IMPORT
 	WMWindowManager, WMComponents, WMStandardComponents, WMGrids, WMStringGrids, WMMessages, WMDialogs,
- 	WMEvents, Objects, Kernel, WMProperties, WMGraphics, WMEditors, WMTrees, WMRectangles, WMPopups, WMDropTarget,
- 	Modules, Disks, XMLObjects, Files, Strings, CDRecord, Lib := CDRecordLib, MakeIsoImages, Utils := CDRecordUtils;
+	WMEvents, Objects, Kernel, WMProperties, WMGraphics, WMEditors, WMTrees, WMRectangles, WMPopups, WMDropTarget,
+	Modules, Disks, XMLObjects, Files, Strings, CDRecord, Lib := CDRecordLib, MakeIsoImages, Utils := CDRecordUtils;
 
 CONST
 	Title = "CD Recording Tool";

source/WMCalendar.Mod

@@ -329,7 +329,7 @@ TYPE
 				SELF.currentDate := currentDate;
 				Release;
 				Invalidate;
- 			END;
+			END;
 		END UpdateCurrentDate;
 
 	BEGIN {ACTIVE}
@@ -710,7 +710,7 @@ BEGIN
 	nofWindows := 0;
 	InitStrings;
 	InitPrototypes;
- 	Modules.InstallTermHandler(Cleanup);
+	Modules.InstallTermHandler(Cleanup);
 	WeekDay[0] := "ERROR";
 	WeekDay[Monday] := "Mo";
 	WeekDay[Tuesday] := "Tu";

source/WMComponents.Mod

@@ -3624,8 +3624,8 @@ BEGIN
 				END;
 			END;
 		END;
- 	END;
- 	RETURN NIL;
+	END;
+	RETURN NIL;
 END GetElementByName;
 
 PROCEDURE NewComponent*(): XML.Element;

source/WMEditors.Mod

@@ -857,8 +857,8 @@ TYPE
 				SelectAll;
 			ELSIF keySym = 03H THEN (* Ctrl-C *)
 				CopySelection;
- 			ELSIF (keySym = 0FF63H) & (flags * Inputs.Ctrl # {}) THEN  (*Ctrl Insert *)
- 				(* tv.CopySelection *)
+			ELSIF (keySym = 0FF63H) & (flags * Inputs.Ctrl # {}) THEN  (*Ctrl Insert *)
+				(* tv.CopySelection *)
 			ELSIF keySym = 0FF51H THEN (* Cursor Left *)
 				CursorLeft;
 			ELSIF keySym = 0FF53H THEN (* Cursor Right *)
@@ -879,7 +879,7 @@ TYPE
 				DeleteSelection;
 			ELSIF keySym = 0FFFFH THEN (* Delete *)
 				Delete;
- 			ELSIF keySym = 0FF08H THEN (* Backspace *)
+			ELSIF keySym = 0FF08H THEN (* Backspace *)
 				Backspace;
 			ELSIF (keySym = 0FF63H) & (flags * Inputs.Shift # {}) THEN  (* Shift Insert *)
 				Paste;
@@ -1733,8 +1733,8 @@ TYPE
 				IF undoMgr # NIL THEN
 					undoMgr.Undo
 				END
- 			ELSIF (keySym = 0FF63H) & (flags * Inputs.Ctrl # {}) THEN  (*Ctrl Insert *)
- 				tv.CopySelection
+			ELSIF (keySym = 0FF63H) & (flags * Inputs.Ctrl # {}) THEN  (*Ctrl Insert *)
+				tv.CopySelection
 			ELSIF keySym = 0FF51H THEN (* Cursor Left *)
 				IF flags * Inputs.Alt # {} THEN IndentLeft
 				ELSE tv.CursorLeft(flags * Inputs.Ctrl # {}, flags * Inputs.Shift # {})

source/WMFTPClient.Mod

@@ -333,7 +333,7 @@ TYPE
 	END Window;
 
 	(* FTPPanel *)
- 	FTPPanel = OBJECT(WMComponents.VisualComponent)
+	FTPPanel = OBJECT(WMComponents.VisualComponent)
 	VAR
 		grid : WMStringGrids.StringGrid;
 		colWidths : WMGrids.Spacings;

source/WMFigures.Mod

@@ -821,9 +821,9 @@ PROCEDURE arctan2(x,y: REAL): REAL; (*arctan in range 0..2pi*)
 
 PROCEDURE MakePoly(CONST RX, RY, RXstrich, RYstrich, RS: ARRAY OF REAL; n: LONGINT; VAR points : ARRAY OF WMGraphics.Point2d; VAR k: LONGINT);
  TYPE
- 	Polynom = RECORD A, B, C, D: REAL END;
+	Polynom = RECORD A, B, C, D: REAL END;
  VAR
- 	i, cs, smax, k1: LONGINT; px, py: Polynom;
+	i, cs, smax, k1: LONGINT; px, py: Polynom;
 	x, dx1, dx2, dx3, y, dy1, dy2, dy3: REAL; L, B, R, T,dW  : LONGINT;
 
 	PROCEDURE GetPolynom((* VAR *) y1, y2, y1s, y2s: REAL; VAR p: Polynom);

source/WMFontCCGConverter.Mod

@@ -193,7 +193,7 @@ TYPE
 						KernelLog.Ln
 					END
 				ELSIF glyph.strokes[i].cmd = CMDStrokeLine THEN
- 					IF TraceGlyphs IN Trace THEN
+					IF TraceGlyphs IN Trace THEN
 						KernelLog.String(" --> Execute"); KernelLog.Int(glyph.strokes[i].x, 5); KernelLog.String(", "); KernelLog.Int(glyph.strokes[i].y, 5);
 						KernelLog.Ln;
 						IF i = 0 THEN KernelLog.String("Strange... no move to"); KernelLog.Ln END;

source/WMGraphicUtilities.Mod

@@ -197,7 +197,7 @@ END RepeatImageVertical;
 PROCEDURE Circle*(CONST c: WMGraphics.Canvas; CX, CY, R : LONGINT);
 VAR
 	X, Y : LONGINT;
- 	XChange, YChange : LONGINT;
+	XChange, YChange : LONGINT;
 	RadiusError : LONGINT;
 BEGIN
 	X := R;

source/WMGraphics.Mod

@@ -999,6 +999,6 @@ END ClearCache;
 
 
 BEGIN
- 	nofFallbackFonts := 3;
+	nofFallbackFonts := 3;
 	NEW(imgCache)
 END WMGraphics.

source/WMModuleState.Mod

@@ -519,11 +519,11 @@ BEGIN
 	IF interval < 1 THEN interval := 2000 END;	(* default interval *)
 
 	NEW(stateWin, "Module State", interval, name);
- 	INC(nrWins);
- 	BEGIN {EXCLUSIVE}
- 		IF stateWins = NIL THEN
- 			NEW(stateWins, 1);
- 			stateWins[0] := stateWin;
+	INC(nrWins);
+	BEGIN {EXCLUSIVE}
+		IF stateWins = NIL THEN
+			NEW(stateWins, 1);
+			stateWins[0] := stateWin;
 		ELSE
 	 	 	NEW(wins, LEN(stateWins) + 1);
 		 	FOR i := 0 TO LEN(stateWins) - 1 DO

source/WMPartitionsComponents.Mod

@@ -808,7 +808,7 @@ TYPE
 					END;
 					grid.model.Release;
 					grid.Release;
- 					model.disks[i].titlegrid := BuildTitleGrid(); model.disks[i].panel.AddInternalComponent(model.disks[i].titlegrid);
+					model.disks[i].titlegrid := BuildTitleGrid(); model.disks[i].panel.AddInternalComponent(model.disks[i].titlegrid);
 					NEW(model.disks[i].buttons, LEN(model.disks[i].table));
 					FOR j := 0 TO LEN(model.disks[i].table)-1 DO
 						NEW(model.disks[i].buttons[j]);
@@ -952,7 +952,7 @@ TYPE
 			END;
 		END CalcDiskPanelBounds;
 
- 		PROCEDURE BuildTitleGrid() : NoWheelGrid;
+		PROCEDURE BuildTitleGrid() : NoWheelGrid;
 		VAR grid : NoWheelGrid;
 		BEGIN
 			NEW(grid);

source/WMRestorable.Mod

@@ -332,8 +332,8 @@ BEGIN
 				END;
 			END;
 		END;
- 	END;
- 	RETURN NIL;
+	END;
+	RETURN NIL;
 END GetElementByName;
 
 PROCEDURE ShowLoadError(CONST procedureName : ARRAY OF CHAR; elem : XML.Element; CONST name : ARRAY OF CHAR);

source/WMSlideshow.Mod

@@ -894,7 +894,7 @@ END SlideshowWindow;
 
 
  TYPE SlideshowData= OBJECT
- 	VAR
+	VAR
 		slides : List;
 		hasErrors : BOOLEAN; (* XML Parsing *)
 

source/WMStandardComponents.Mod

@@ -553,12 +553,12 @@ TYPE
 			NEW(imgPressedNameLeft, PrototypeImgPressedNameLeft, NIL, NIL); properties.Add(imgPressedNameLeft);
 		 	NEW(imgPressedNameRight, PrototypeImgPressedNameRight, NIL, NIL); properties.Add(imgPressedNameRight);
 		 	NEW(imgPressedNameMiddle, PrototypeImgPressedNameMiddle, NIL, NIL); properties.Add(imgPressedNameMiddle);
- 				(* --- *)
- 			NEW(useDeco, PrototypeUseDeco, NIL, NIL); properties.Add(useDeco);
+				(* --- *)
+			NEW(useDeco, PrototypeUseDeco, NIL, NIL); properties.Add(useDeco);
 			NEW(decoDefaultName, PrototypeDecoDefaultName, NIL, NIL); properties.Add(decoDefaultName);
 			NEW(decoHoverName, PrototypeDecoHoverName, NIL, NIL); properties.Add(decoHoverName);
 			NEW(decoPressedName, PrototypeDecoPressedName, NIL, NIL); properties.Add(decoPressedName);
- 				(* --- *)
+				(* --- *)
 			NEW(imgDefaultNameTop, PrototypeImgDefaultNameTop, NIL, NIL); properties.Add(imgDefaultNameTop);
 		 	NEW(imgDefaultNameBottom, PrototypeImgDefaultNameBottom, NIL, NIL); properties.Add(imgDefaultNameBottom);
 			NEW(imgHoverNameTop, PrototypeImgHoverNameTop, NIL, NIL); properties.Add(imgHoverNameTop);
@@ -882,9 +882,9 @@ TYPE
 			RETURN t
 		END IsHit;
 
- 		PROCEDURE IsHitHorizontal(x, y: LONGINT) : BOOLEAN;
- 		VAR a, b, c : WMGraphics.Image; aw, bw, cw : LONGINT;
- 		BEGIN
+		PROCEDURE IsHitHorizontal(x, y: LONGINT) : BOOLEAN;
+		VAR a, b, c : WMGraphics.Image; aw, bw, cw : LONGINT;
+		BEGIN
 			IF imgDefault # NIL THEN
 				RETURN WMGraphics.IsScaledBitmapHit (x,y,bounds.GetWidth(), bounds.GetHeight(), 64,imgDefault);
 			ELSE
@@ -908,21 +908,21 @@ TYPE
 		 			END
 				END
 			END
- 		END IsHitHorizontal;
+		END IsHitHorizontal;
 
- 		PROCEDURE IsHitVertical(x, y: LONGINT) : BOOLEAN;
- 		VAR a, b, c : WMGraphics.Image; ah, bh, ch : LONGINT;
- 		BEGIN
- 			GetVerticalImages(a, b, c);
+		PROCEDURE IsHitVertical(x, y: LONGINT) : BOOLEAN;
+		VAR a, b, c : WMGraphics.Image; ah, bh, ch : LONGINT;
+		BEGIN
+			GetVerticalImages(a, b, c);
 	 		IF a # NIL THEN ah := a.height ELSE ah := 0 END;
 	 		IF c # NIL THEN ch := c.height ELSE ch := 0 END;
 	 		bh := bounds.GetHeight() - ah - ch;
 	 		IF y < ah THEN
 	 			x := x * a.width DIV bounds.GetWidth();
- 				RETURN WMGraphics.IsBitmapHit(x, y, 64, a)
+				RETURN WMGraphics.IsBitmapHit(x, y, 64, a)
 	 		ELSIF y > bounds.GetHeight() - ch THEN
 	 			x := x * c.width DIV bounds.GetWidth();
- 				RETURN WMGraphics.IsBitmapHit(x, y-ah-bh, 64, c)
+				RETURN WMGraphics.IsBitmapHit(x, y-ah-bh, 64, c)
 	 		ELSE (* middle image *)
 	 			IF b = NIL THEN RETURN FALSE END; (* no image loaded, so the button cannot be hit *)
 	 			x := x * b.width DIV bounds.GetWidth();
@@ -932,13 +932,13 @@ TYPE
 		 			RETURN WMGraphics.IsBitmapHit(x, (y-ah) * b.height DIV bh, 64, b)
 	 			END
 			END
- 		END IsHitVertical;
+		END IsHitVertical;
 
- 		(* load images appropriate to the actual state of the button. a: left, b: middle, c: right *)
- 		PROCEDURE GetHorizontalImages(VAR a, b, c : WMGraphics.Image);
- 		VAR down : BOOLEAN;
- 		BEGIN
- 			down := pressed & (mouseOver OR isToggle.Get() OR keyboardPressed);
+		(* load images appropriate to the actual state of the button. a: left, b: middle, c: right *)
+		PROCEDURE GetHorizontalImages(VAR a, b, c : WMGraphics.Image);
+		VAR down : BOOLEAN;
+		BEGIN
+			down := pressed & (mouseOver OR isToggle.Get() OR keyboardPressed);
 			IF down THEN
 				IF imgPressedMiddle # NIL THEN
 					a := imgPressedLeft; b := imgPressedMiddle; c := imgPressedRight; RETURN
@@ -956,13 +956,13 @@ TYPE
 			ELSE
 				a := imgDefaultLeft; b := imgDefaultMiddle; c := imgDefaultRight; RETURN
 			END
- 		END GetHorizontalImages;
+		END GetHorizontalImages;
 
- 		(* load images appropriate to the actual state of the button. a: top, b: middle, c: bottom *)
- 		PROCEDURE GetVerticalImages(VAR a, b, c : WMGraphics.Image);
- 		VAR down : BOOLEAN;
- 		BEGIN
- 			down := pressed & (mouseOver OR isToggle.Get() OR keyboardPressed);
+		(* load images appropriate to the actual state of the button. a: top, b: middle, c: bottom *)
+		PROCEDURE GetVerticalImages(VAR a, b, c : WMGraphics.Image);
+		VAR down : BOOLEAN;
+		BEGIN
+			down := pressed & (mouseOver OR isToggle.Get() OR keyboardPressed);
 			IF down THEN
 				IF imgPressedMiddle # NIL THEN
 					a := imgPressedTop; b := imgPressedMiddle; c := imgPressedBottom; RETURN
@@ -980,9 +980,9 @@ TYPE
 			ELSE
 				a := imgDefaultTop; b := imgDefaultMiddle; c:= imgDefaultBottom; RETURN
 			END
- 		END GetVerticalImages;
+		END GetVerticalImages;
 
- 		PROCEDURE GetDecorationImage(name: String; CONST suffix: ARRAY OF CHAR; VAR image:WMGraphics.Image);
+		PROCEDURE GetDecorationImage(name: String; CONST suffix: ARRAY OF CHAR; VAR image:WMGraphics.Image);
 		VAR fileName, extension: Files.FileName;
 		BEGIN
 			IF (name = NIL) OR (name^="") THEN
@@ -1016,10 +1016,10 @@ TYPE
 		END GetDecoration;
 
 		 (* load images appropriate to the actual state of the button. a: left, b: middle, c: right *)
- 		PROCEDURE GetThisDecoration(VAR d : Decoration);
- 		VAR down : BOOLEAN;
- 		BEGIN
- 			down := pressed & (mouseOver OR isToggle.Get() OR keyboardPressed);
+		PROCEDURE GetThisDecoration(VAR d : Decoration);
+		VAR down : BOOLEAN;
+		BEGIN
+			down := pressed & (mouseOver OR isToggle.Get() OR keyboardPressed);
 			IF down THEN
 				IF decoPressed # NIL THEN d := decoPressed;
 				ELSIF decoHover # NIL THEN d := decoHover
@@ -1031,7 +1031,7 @@ TYPE
 				END
 			ELSE d := decoDefault
 			END
- 		END GetThisDecoration;
+		END GetThisDecoration;
 
 		PROCEDURE DrawBackground*(canvas : WMGraphics.Canvas);
 		VAR mode, borderWidth : LONGINT; mid: WMGraphics.Color;
@@ -2990,7 +2990,7 @@ VAR
 	 RectanglePrototype : WMProperties.RectangleProperty;
 	 PrototypeBlinking*: WMProperties.BooleanProperty;
 
- 	 (* Button prototypes *)
+	 (* Button prototypes *)
 	 PrototypeBBounds* : WMProperties.RectangleProperty;
 	 PrototypeBUseBgImages* : WMProperties.BooleanProperty;
 	 PrototypeBclDefault*, PrototypeBclHover*, PrototypeBclPressed*, PrototypeBclInactive*,
@@ -2998,12 +2998,12 @@ VAR
 	 PrototypeBRepeatMiddleImg*, PrototypeBisRepeating*, PrototypeBisToggle*, PrototypeBisInverse*, PrototypeBindicateToggle*, PrototypeBIsHorizontal* : WMProperties.BooleanProperty;
 	 PrototypeBcaption*, PrototypeBonClickHandler* : WMProperties.StringProperty;
 	 PrototypeBimgDefaultName*, PrototypeBimgInactiveName*, PrototypeBimgHoverName*, PrototypeBimgPressedName*, PrototypeBimageName* : WMProperties.StringProperty;
- 	 PrototypeImgDefaultNameLeft*, PrototypeImgDefaultNameRight*, PrototypeImgDefaultNameMiddle*,
- 	 PrototypeImgDefaultNameTop*, PrototypeImgDefaultNameBottom*,
- 	 PrototypeImgHoverNameLeft*, PrototypeImgHoverNameRight*, PrototypeImgHoverNameMiddle*,
- 	 PrototypeImgHoverNameTop*, PrototypeImgHoverNameBottom*,
- 	 PrototypeImgPressedNameLeft*, PrototypeImgPressedNameRight*, PrototypeImgPressedNameMiddle*,
- 	 PrototypeImgPressedNameTop*, PrototypeImgPressedNameBottom* : WMProperties.StringProperty;
+	 PrototypeImgDefaultNameLeft*, PrototypeImgDefaultNameRight*, PrototypeImgDefaultNameMiddle*,
+	 PrototypeImgDefaultNameTop*, PrototypeImgDefaultNameBottom*,
+	 PrototypeImgHoverNameLeft*, PrototypeImgHoverNameRight*, PrototypeImgHoverNameMiddle*,
+	 PrototypeImgHoverNameTop*, PrototypeImgHoverNameBottom*,
+	 PrototypeImgPressedNameLeft*, PrototypeImgPressedNameRight*, PrototypeImgPressedNameMiddle*,
+	 PrototypeImgPressedNameTop*, PrototypeImgPressedNameBottom* : WMProperties.StringProperty;
 	 PrototypeBEffect3D : WMProperties.Int32Property;
 
 	PrototypeUseDeco*: WMProperties.BooleanProperty;
@@ -3014,29 +3014,29 @@ VAR
 	 PrototypeSmin*, PrototypeSmax*, PrototypeSpos*, PrototypeSpageSize*, PrototypeTrackerSize*, PrototypeSWidth*,
 	 PrototypeSMinTrackerSize* : WMProperties.Int32Property;
 		 (* presentation : colors / images *)
- 	 PrototypeSUseArrowImages*, PrototypeSUseTrackerImages*, PrototypeSRepeatMiddleBitmap* : WMProperties.BooleanProperty;
+	 PrototypeSUseArrowImages*, PrototypeSUseTrackerImages*, PrototypeSRepeatMiddleBitmap* : WMProperties.BooleanProperty;
 	 	(* background *)
 	 PrototypeSUseBgBitmaps*, PrototypeSRepeateBgBitmap* : WMProperties.BooleanProperty;
- 	 PrototypeSClDefault*, PrototypeSClHover*, PrototypeSClPressed*,
- 	 PrototypeSClBtnDefault*, PrototypeSClBtnHover*, PrototypeSClBtnPressed* : WMProperties.ColorProperty;
- 	 PrototypeSEffect3D* : WMProperties.Int32Property;
- 	 PrototypeSvBgDefault*, PrototypeSvBgHover*, PrototypeSvBgPressed*,
- 	 PrototypeShBgDefault*, PrototypeShBgHover*, PrototypeShBgPressed* : WMProperties.StringProperty;
- 	 	(* arrow images *)
- 	 PrototypeSArrowLeftDefault*, PrototypeSArrowLeftHover*, PrototypeSArrowLeftPressed*,
- 	 PrototypeSArrowUpDefault*, PrototypeSArrowUpHover*, PrototypeSArrowUpPressed*,
- 	 PrototypeSArrowRightDefault*, PrototypeSArrowRightHover*, PrototypeSArrowRightPressed*,
- 	 PrototypeSArrowDownDefault*, PrototypeSArrowDownHover*, PrototypeSArrowDownPressed*  : WMProperties.StringProperty;
- 	 	(* horizontal tracker *)
- 	 PrototypeShTrackerDefaultLeft*, PrototypeShTrackerHoverLeft*, PrototypeShTrackerPressedLeft*,
- 	 PrototypeShTrackerDefaultMiddle*, PrototypeShTrackerHoverMiddle*, PrototypeShTrackerPressedMiddle*,
- 	 PrototypeShTrackerDefaultRight*, PrototypeShTrackerHoverRight*, PrototypeShTrackerPressedRight*,
- 	 	(* vertical tracker *)
- 	 PrototypeSvTrackerDefaultTop*, PrototypeSvTrackerHoverTop*, PrototypeSvTrackerPressedTop*,
- 	 PrototypeSvTrackerDefaultMiddle*, PrototypeSvTrackerHoverMiddle*, PrototypeSvTrackerPressedMiddle*,
- 	 PrototypeSvTrackerDefaultBottom*, PrototypeSvTrackerHoverBottom*, PrototypeSvTrackerPressedBottom* : WMProperties.StringProperty;
-
- 	 (* Slider prototypes *)
+	 PrototypeSClDefault*, PrototypeSClHover*, PrototypeSClPressed*,
+	 PrototypeSClBtnDefault*, PrototypeSClBtnHover*, PrototypeSClBtnPressed* : WMProperties.ColorProperty;
+	 PrototypeSEffect3D* : WMProperties.Int32Property;
+	 PrototypeSvBgDefault*, PrototypeSvBgHover*, PrototypeSvBgPressed*,
+	 PrototypeShBgDefault*, PrototypeShBgHover*, PrototypeShBgPressed* : WMProperties.StringProperty;
+	 	(* arrow images *)
+	 PrototypeSArrowLeftDefault*, PrototypeSArrowLeftHover*, PrototypeSArrowLeftPressed*,
+	 PrototypeSArrowUpDefault*, PrototypeSArrowUpHover*, PrototypeSArrowUpPressed*,
+	 PrototypeSArrowRightDefault*, PrototypeSArrowRightHover*, PrototypeSArrowRightPressed*,
+	 PrototypeSArrowDownDefault*, PrototypeSArrowDownHover*, PrototypeSArrowDownPressed*  : WMProperties.StringProperty;
+	 	(* horizontal tracker *)
+	 PrototypeShTrackerDefaultLeft*, PrototypeShTrackerHoverLeft*, PrototypeShTrackerPressedLeft*,
+	 PrototypeShTrackerDefaultMiddle*, PrototypeShTrackerHoverMiddle*, PrototypeShTrackerPressedMiddle*,
+	 PrototypeShTrackerDefaultRight*, PrototypeShTrackerHoverRight*, PrototypeShTrackerPressedRight*,
+	 	(* vertical tracker *)
+	 PrototypeSvTrackerDefaultTop*, PrototypeSvTrackerHoverTop*, PrototypeSvTrackerPressedTop*,
+	 PrototypeSvTrackerDefaultMiddle*, PrototypeSvTrackerHoverMiddle*, PrototypeSvTrackerPressedMiddle*,
+	 PrototypeSvTrackerDefaultBottom*, PrototypeSvTrackerHoverBottom*, PrototypeSvTrackerPressedBottom* : WMProperties.StringProperty;
+
+	 (* Slider prototypes *)
 	PrototypeSlhTrackerDefault*, PrototypeSlhTrackerHover*, PrototypeSlhTrackerPressed*,
 	PrototypeSlvTrackerDefault*, PrototypeSlvTrackerHover*, PrototypeSlvTrackerPressed*,
 	PrototypeSlhBgDefault*, PrototypelShBgHover*, PrototypeSlhBgPressed*,
@@ -3048,7 +3048,7 @@ VAR
 	 PrototypeSlmin*, PrototypeSlmax*, PrototypeSlpos*, PrototypeSlpageSize*,
 	 PrototypeSlMinTrackerSize* : WMProperties.Int32Property;
 
- 	 (* Resizer prototypes *)
+	 (* Resizer prototypes *)
 	 PrototypeRclDefault* : WMProperties.ColorProperty;
 	 PrototypeRisFlat* : WMProperties.BooleanProperty;
 	 PrototypeRBounds* : WMProperties.RectangleProperty;
@@ -3279,18 +3279,18 @@ BEGIN
 	NEW(PrototypeSMinTrackerSize, Int32Prototype, NIL, NIL); plScrollbar.Add(PrototypeSMinTrackerSize);
 			(* color *)
 	NEW(ColorPrototype, NIL, NewString("ClDefault"), NewString("Default background color")); ColorPrototype.Set(000000077H);
- 	NEW(PrototypeSClDefault, ColorPrototype, NIL, NIL); plScrollbar.Add(PrototypeSClDefault);
+	NEW(PrototypeSClDefault, ColorPrototype, NIL, NIL); plScrollbar.Add(PrototypeSClDefault);
 	NEW(ColorPrototype, NIL, NewString("ClHover"), NewString("Mouseover background color")); ColorPrototype.Set(WMGraphics.Yellow);
- 	NEW(PrototypeSClHover, ColorPrototype, NIL, NIL); plScrollbar.Add(PrototypeSClHover);
+	NEW(PrototypeSClHover, ColorPrototype, NIL, NIL); plScrollbar.Add(PrototypeSClHover);
 	NEW(ColorPrototype, NIL, NewString("ClPressed"), NewString("Pressed background color")); ColorPrototype.Set(WMGraphics.Yellow);
- 	NEW(PrototypeSClPressed, ColorPrototype, NIL, NIL); plScrollbar.Add(PrototypeSClPressed);
+	NEW(PrototypeSClPressed, ColorPrototype, NIL, NIL); plScrollbar.Add(PrototypeSClPressed);
 	NEW(ColorPrototype, NIL, NewString("ClBtnDefault"), NewString("Default background color")); ColorPrototype.Set(1010C080H);
- 	NEW(PrototypeSClBtnDefault, ColorPrototype, NIL, NIL); plScrollbar.Add(PrototypeSClBtnDefault);
+	NEW(PrototypeSClBtnDefault, ColorPrototype, NIL, NIL); plScrollbar.Add(PrototypeSClBtnDefault);
 	NEW(ColorPrototype, NIL, NewString("ClBtnHover"), NewString("Mouseover background color")); ColorPrototype.Set(LONGINT(0EEEE00FFH));
- 	NEW(PrototypeSClBtnHover, ColorPrototype, NIL, NIL); plScrollbar.Add(PrototypeSClBtnHover);
+	NEW(PrototypeSClBtnHover, ColorPrototype, NIL, NIL); plScrollbar.Add(PrototypeSClBtnHover);
 	NEW(ColorPrototype, NIL, NewString("ClBtnPressed"), NewString("Pressed background color")); ColorPrototype.Set(LONGINT(0EEEE00FFH));
- 	NEW(PrototypeSClBtnPressed, ColorPrototype, NIL, NIL); plScrollbar.Add(PrototypeSClBtnPressed);
- 	NEW(PrototypeSEffect3D, NIL, NewString("Effect3D"), NewString("Degree of 3d-effect. Zero for flat presentation")); PrototypeSEffect3D.Set(2);
+	NEW(PrototypeSClBtnPressed, ColorPrototype, NIL, NIL); plScrollbar.Add(PrototypeSClBtnPressed);
+	NEW(PrototypeSEffect3D, NIL, NewString("Effect3D"), NewString("Degree of 3d-effect. Zero for flat presentation")); PrototypeSEffect3D.Set(2);
 		(* background *)
 	NEW(BooleanPrototype, NIL, NewString("UseBackgroundBitmaps"), NewString("Should background be decorated by bitmaps or simple color?")); BooleanPrototype.Set(FALSE);
 	NEW(PrototypeSUseBgBitmaps, BooleanPrototype, NIL, NIL);  plScrollbar.Add(PrototypeSUseBgBitmaps);
@@ -3355,13 +3355,13 @@ BEGIN
 		(* arrows *)
 	NEW(BooleanPrototype, NIL, NewString("UseArrowBitmaps"), NewString("Have the arrow-buttons to be decorated by bitmaps or simple colors")); BooleanPrototype.Set(FALSE);
 	NEW(PrototypeSUseArrowImages, BooleanPrototype, NIL, NIL);  plScrollbar.Add(PrototypeSUseArrowImages);
- 			(* left *)
- 	NEW(StringPrototype, NIL, NewString("ArrowLeftDefault"), NewString("Default bitmap for the left-arrow")); StringPrototype.Set(NewString(""));
- 	NEW(PrototypeSArrowLeftDefault, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowLeftDefault);
- 	NEW(StringPrototype, NIL, NewString("ArrowLeftHover"), NewString("Mouseover bitmap for the left-arrow")); StringPrototype.Set(NewString(""));
- 	NEW(PrototypeSArrowLeftHover, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowLeftHover);
- 	NEW(StringPrototype, NIL, NewString("ArrowLeftPressed"), NewString("Pressed bitmap for the left-arrow")); StringPrototype.Set(NewString(""));
- 	NEW(PrototypeSArrowLeftPressed, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowLeftPressed);
+			(* left *)
+	NEW(StringPrototype, NIL, NewString("ArrowLeftDefault"), NewString("Default bitmap for the left-arrow")); StringPrototype.Set(NewString(""));
+	NEW(PrototypeSArrowLeftDefault, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowLeftDefault);
+	NEW(StringPrototype, NIL, NewString("ArrowLeftHover"), NewString("Mouseover bitmap for the left-arrow")); StringPrototype.Set(NewString(""));
+	NEW(PrototypeSArrowLeftHover, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowLeftHover);
+	NEW(StringPrototype, NIL, NewString("ArrowLeftPressed"), NewString("Pressed bitmap for the left-arrow")); StringPrototype.Set(NewString(""));
+	NEW(PrototypeSArrowLeftPressed, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowLeftPressed);
 			(* right *)
 	NEW(StringPrototype, NIL, NewString("ArrowRightDefault"), NewString("Default bitmap for the right-arrow")); StringPrototype.Set(NewString(""));
 	NEW(PrototypeSArrowRightDefault, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowRightDefault);
@@ -3370,19 +3370,19 @@ BEGIN
 	NEW(StringPrototype, NIL, NewString("ArrowRightPressed"), NewString("Pressed bitmap for the right-arrow")); StringPrototype.Set(NewString(""));
 	NEW(PrototypeSArrowRightPressed, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowRightPressed);
 			(* up *)
- 	NEW(StringPrototype, NIL, NewString("ArrowUpDefault"), NewString("Default bitmap for the up-arrow"));StringPrototype.Set(NewString(""));
- 	NEW(PrototypeSArrowUpDefault, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowUpDefault);
- 	NEW(StringPrototype, NIL, NewString("ArrowUpHover"), NewString("Mouseover bitmap for the up-arrow")); StringPrototype.Set(NewString(""));
- 	NEW(PrototypeSArrowUpHover, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowUpHover);
+	NEW(StringPrototype, NIL, NewString("ArrowUpDefault"), NewString("Default bitmap for the up-arrow"));StringPrototype.Set(NewString(""));
+	NEW(PrototypeSArrowUpDefault, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowUpDefault);
+	NEW(StringPrototype, NIL, NewString("ArrowUpHover"), NewString("Mouseover bitmap for the up-arrow")); StringPrototype.Set(NewString(""));
+	NEW(PrototypeSArrowUpHover, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowUpHover);
 	NEW(StringPrototype, NIL, NewString("ArrowUpPressed"), NewString("Pressed bitmap for the up-arrow")); StringPrototype.Set(NewString(""));
- 	NEW(PrototypeSArrowUpPressed, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowUpPressed);
+	NEW(PrototypeSArrowUpPressed, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowUpPressed);
 			(* down *)
 	NEW(StringPrototype, NIL, NewString("ArrowDownDefault"), NewString("Default bitmap for the down-arrow"));StringPrototype.Set(NewString(""));
 	NEW(PrototypeSArrowDownDefault, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowDownDefault);
 	NEW(StringPrototype, NIL, NewString("ArrowDownHover"), NewString("Mouseover bitmap for the down-arrow")); StringPrototype.Set(NewString(""));
- 	NEW(PrototypeSArrowDownHover, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowDownHover);
+	NEW(PrototypeSArrowDownHover, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowDownHover);
 	NEW(StringPrototype, NIL, NewString("ArrowDownPressed"), NewString("Pressed bitmap for the down-arrow")); StringPrototype.Set(NewString(""));
- 	NEW(PrototypeSArrowDownPressed, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowDownPressed);
+	NEW(PrototypeSArrowDownPressed, StringPrototype, NIL, NIL); plScrollbar.Add(PrototypeSArrowDownPressed);
 
 	 (* Slider prototypes *)
 	NEW(plSlider); WMComponents.propertyListList.Add("Slider", plSlider);
@@ -3423,15 +3423,15 @@ BEGIN
 	NEW(PrototypeSlpageSize, NIL, NewString("PageSize"),NewString("defines the slider page size"));
 	PrototypeSlpageSize.Set(20);
 
- 	(* Resizer *)
- 	NEW(plResizer);	WMComponents.propertyListList.Add("Resizer", plResizer);
- 	NEW(ColorPrototype, NIL, NewString("ClDefault"), NewString("Default Color")); ColorPrototype.Set(WMGraphics.White);
- 	NEW(PrototypeRclDefault, ColorPrototype, NIL, NIL); plResizer.Add(PrototypeRclDefault);
+	(* Resizer *)
+	NEW(plResizer);	WMComponents.propertyListList.Add("Resizer", plResizer);
+	NEW(ColorPrototype, NIL, NewString("ClDefault"), NewString("Default Color")); ColorPrototype.Set(WMGraphics.White);
+	NEW(PrototypeRclDefault, ColorPrototype, NIL, NIL); plResizer.Add(PrototypeRclDefault);
 	NEW(BooleanPrototype, NIL, NewString("IsFlat"), NewString("Is the resizer flat or 3d?")); BooleanPrototype.Set(FALSE);
- 	NEW(PrototypeRisFlat, BooleanPrototype, NIL, NIL); plResizer.Add(PrototypeRisFlat);
- 	NEW(RectanglePrototype, NIL, NewString("Bounds"), NewString("Default width and height")); RectanglePrototype.SetWidth(5); RectanglePrototype.SetHeight(5);
- 	NEW(PrototypeRBounds, RectanglePrototype, NIL, NIL); plResizer.Add(PrototypeRBounds);
- 	(* Checkbox *)
+	NEW(PrototypeRisFlat, BooleanPrototype, NIL, NIL); plResizer.Add(PrototypeRisFlat);
+	NEW(RectanglePrototype, NIL, NewString("Bounds"), NewString("Default width and height")); RectanglePrototype.SetWidth(5); RectanglePrototype.SetHeight(5);
+	NEW(PrototypeRBounds, RectanglePrototype, NIL, NIL); plResizer.Add(PrototypeRBounds);
+	(* Checkbox *)
 	NEW(plCheckbox); WMComponents.propertyListList.Add("Checkbox", plCheckbox);
 
 	NEW(ProtCBCaption, NIL, NewString("Caption"), NewString("caption text")); plCheckbox.Add(ProtCBCaption);

source/WMTextView.Mod

@@ -3608,7 +3608,7 @@ TYPE
 				SelectAll
 			ELSIF keysym = 03H THEN (* Ctrl-C *)
 				CopySelection
- 			ELSIF (keysym = 0FF63H) & (flags * Inputs.Ctrl # {}) THEN  (*Ctrl Insert *)
+			ELSIF (keysym = 0FF63H) & (flags * Inputs.Ctrl # {}) THEN  (*Ctrl Insert *)
 				CopySelection
 			ELSIF keysym = 12H THEN (* Ctrl-R *)
 				layout.FullLayout(TRUE); Invalidate;CheckNumberOfLines;