модифицировал структуру подсистемы для разработки модулей под fw

Src/System/Mod/Cons.cp

@@ -0,0 +1,111 @@
+MODULE Cons;
+	
+	IMPORT 
+		Log:=Out, Console, Str;
+		
+	TYPE
+		Hook = POINTER TO RECORD (Log.Hook) END;
+
+	PROCEDURE (log: Hook) ClearBuf;
+	BEGIN
+	
+	END ClearBuf;
+	
+	PROCEDURE (log: Hook) FlushBuf;
+	BEGIN
+	
+	END FlushBuf;
+	
+	PROCEDURE (log: Hook) Beep;
+	BEGIN
+	
+	END Beep;
+	
+	PROCEDURE (log: Hook) Char (ch: CHAR);
+	BEGIN
+	
+	END Char;
+	
+	PROCEDURE (log: Hook) Int (n: LONGINT);
+	BEGIN
+		Console.Int(n)
+	END Int;
+	
+	PROCEDURE (log: Hook) Real (x: REAL);
+		VAR vs: ARRAY 64 OF CHAR;
+	BEGIN
+		Str.RealToString(x, vs);
+		Console.String(" ");
+		Console.String(vs);
+	END Real;
+	
+	PROCEDURE (log: Hook) String (IN str: ARRAY OF CHAR);
+	BEGIN
+		Console.String(str)
+	END String;
+	
+	PROCEDURE (log: Hook) Bool (x: BOOLEAN);
+	BEGIN
+		Console.Bool(x)
+	END Bool;
+	
+	PROCEDURE (log: Hook) Set (x: SET);
+		VAR i: INTEGER; ret: ARRAY 100 OF CHAR; vs: ARRAY 15 OF CHAR;
+	BEGIN
+		ret := "{"; i := MIN(SET);
+		WHILE x # {} DO
+			IF i IN x THEN 
+				Str.IntToString(i, vs);
+				ret:=ret$+vs$; 
+				EXCL(x, i);
+				IF (i + 2 <= MAX(SET)) & (i+1 IN x) & (i+2 IN x) THEN 
+					ret:=ret$+"..";
+					x := x - {i+1, i+2}; INC(i, 3);
+					WHILE (i <= MAX(SET)) & (i IN x) DO EXCL(x, i); INC(i) END;
+					Str.IntToString(i-1, vs);
+					ret:=ret$+vs$;
+				END;
+				IF x # {} THEN ret:=ret+", "; END
+			END;
+			INC(i);
+		END;
+		ret:=ret$+"}";
+		Console.String(" ");
+		Console.String(ret);
+	END Set;
+	
+	PROCEDURE (log: Hook) Tab;
+	BEGIN
+	
+	END Tab;
+	
+	PROCEDURE (log: Hook) Ln;
+	BEGIN
+		Console.Ln;
+	END Ln;
+	
+	PROCEDURE (log: Hook) ParamMsg (IN s, p0, p1, p2: ARRAY OF CHAR);
+	BEGIN
+	
+	END ParamMsg;
+	
+	PROCEDURE (log: Hook) IntForm (x: INTEGER; base, minWidth: INTEGER; fillCh: CHAR; showBase: BOOLEAN);
+	BEGIN
+	
+	END IntForm;
+	
+	PROCEDURE (log: Hook) RealForm (x: REAL; precision, minW, expW: INTEGER; fillCh: CHAR);
+	BEGIN
+	
+	END RealForm;
+	
+	PROCEDURE Init;
+		VAR h: Hook;
+	BEGIN
+		NEW(h);
+		Log.SetHook(h);
+	END Init;
+	
+BEGIN
+	Init
+END Cons.

Src/System/Mod/Console.cp

@@ -0,0 +1,35 @@
+MODULE Console;
+
+	IMPORT
+		Str;
+		
+	VAR
+		go_process*: PROCEDURE (IN s: ARRAY OF SHORTCHAR);
+		
+	PROCEDURE String*(s: ARRAY OF CHAR);
+		VAR x: ARRAY 1024 OF CHAR;
+	BEGIN
+		x:='{"type": "log", "data": "'+s$+'"}';
+		go_process(SHORT(x));
+	END String;
+	
+	PROCEDURE Bool*(x: BOOLEAN);
+	BEGIN
+		IF x THEN String(" $TRUE") ELSE String(" $FALSE") END
+	END Bool;
+	
+	PROCEDURE Int*(i: LONGINT);
+		VAR s: ARRAY 32 OF CHAR;
+	BEGIN
+		Str.IntToString(i, s);
+		String(" ");
+		String(s)
+	END Int;
+	
+	PROCEDURE Ln*;
+	BEGIN
+		String("\n")
+	END Ln;
+	
+END Console.
+

Src/System/Mod/Core.cp

@@ -0,0 +1,12 @@
+MODULE Core;
+	VAR
+		go_process*: PROCEDURE (IN s: ARRAY OF SHORTCHAR);
+	
+	PROCEDURE LoadMod*(name: ARRAY OF CHAR);
+		VAR x: ARRAY 1024 OF CHAR;
+	BEGIN
+		x:='{"type": "core", "command": "load", "data": "'+name$+'"}';
+		go_process(SHORT(x));		
+	END LoadMod;
+	
+END Core.

Src/System/Mod/Mathe.cp

@@ -0,0 +1,61 @@
+MODULE Mathe;
+
+	CONST
+		ln10 = 2.3025850929940456840179914546844;
+	
+	CONST
+		LN* = 1;
+		MANT* = 2;
+		EXP* = 3;
+		
+	VAR eps, e: REAL;
+	VAR go_math*: PROCEDURE (VAR x: ARRAY OF REAL): REAL;
+	VAR go: ARRAY 10 OF REAL;
+	
+	PROCEDURE IntPower* (x: REAL; n: LONGINT): REAL;
+		VAR y: REAL;
+	BEGIN y := 1.0E+0;
+		IF n < 0 THEN x := 1.0E+0 / x; n := - n END;
+		WHILE n > 0 DO
+			IF ODD(n) THEN y := y * x; DEC(n)
+			ELSE x := x * x; n := n DIV 2
+			END
+		END;
+		RETURN y
+	END IntPower;
+
+	PROCEDURE Ln* (x: REAL): REAL;
+	BEGIN
+		go[0]:=LN;
+		go[1]:=x;
+		RETURN go_math(go)
+	END Ln;
+
+	PROCEDURE Log* (x: REAL): REAL;
+	BEGIN
+		RETURN Ln(x) / ln10
+	END Log;
+	
+	PROCEDURE Mantissa* (x: REAL): REAL;
+	BEGIN
+		go[0]:=MANT;
+		go[1]:=x;
+	RETURN go_math(go)
+	END Mantissa;
+
+	PROCEDURE Exponent* (x: REAL): INTEGER;
+	BEGIN
+		go[0]:=EXP;
+		go[1]:=x;
+	RETURN SHORT(ENTIER(go_math(go)));
+	END Exponent;
+	
+	PROCEDURE Eps* (): REAL;
+	BEGIN
+		RETURN eps
+	END Eps;
+	
+BEGIN
+	eps := 1.0E+0; e := 2.0E+0;
+	WHILE e > 1.0E+0 DO eps := eps / 2.0E+0; e := 1.0E+0 + eps END; eps := 2.0E+0 * eps;
+END Mathe.

Src/System/Mod/Out.cp

@@ -0,0 +1,119 @@
+MODULE Out;
+(**
+	project	= "BlackBox"
+	organization	= "www.oberon.ch"
+	contributors	= "Oberon microsystems"
+	version	= "(*JediPlain*gvFTdGRMaW5rcy5MaW5rRGVzYwDxVmlld3MuVmlld0Rlc2MA8FN0b3Jlcy5TdG9yZURlc2MAAAAAAAAAAAAAAAAARgAAAAAAAAE+AAAAU3RkQ21kcy5PcGVuVG9vbERpYWxvZygnU3lzdGVtL1JzcmMvQWJvdXQnLCAnQWJvdXQgQmxhY2tCb3gnKQA=*)System/Rsrc/About(*JediPlain*gvFTdGRMaW5rcy5MaW5rRGVzYwDxVmlld3MuVmlld0Rlc2MA8FN0b3Jlcy5TdG9yZURlc2MAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAA*)"
+	copyright	= "(*JediPlain*gvFTdGRMaW5rcy5MaW5rRGVzYwDxVmlld3MuVmlld0Rlc2MA8FN0b3Jlcy5TdG9yZURlc2MAAAAAAAAAAAAAAAAARgAAAAAAAAE+AAAAU3RkQ21kcy5PcGVuVG9vbERpYWxvZygnU3lzdGVtL1JzcmMvQWJvdXQnLCAnQWJvdXQgQmxhY2tCb3gnKQA=*)System/Rsrc/About(*JediPlain*gvFTdGRMaW5rcy5MaW5rRGVzYwDxVmlld3MuVmlld0Rlc2MA8FN0b3Jlcy5TdG9yZURlc2MAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAA*)"
+	license	= "(*JediPlain*gvFTdGRMaW5rcy5MaW5rRGVzYwDxVmlld3MuVmlld0Rlc2MA8FN0b3Jlcy5TdG9yZURlc2MAAAAAAAAAAAAAAAAAQwAAAAAAAAE7AAAAU3RkQ21kcy5PcGVuQnJvd3NlcignRG9jdS9CQi1MaWNlbnNlJywgJ0JsYWNrQm94IExpY2Vuc2UnKQA=*)Docu/BB-License(*JediPlain*gvFTdGRMaW5rcy5MaW5rRGVzYwDxVmlld3MuVmlld0Rlc2MA8FN0b3Jlcy5TdG9yZURlc2MAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAA*)"
+	changes	= ""
+	issues	= ""
+
+**)
+
+	TYPE
+		Hook* = POINTER TO ABSTRACT RECORD END;
+
+	VAR
+		hook: Hook;
+
+	PROCEDURE (log: Hook) ClearBuf*, NEW, ABSTRACT;
+	PROCEDURE (log: Hook) FlushBuf*, NEW, ABSTRACT;
+
+	PROCEDURE (log: Hook) Beep*, NEW, ABSTRACT;
+	PROCEDURE (log: Hook) Char* (ch: CHAR), NEW, ABSTRACT;
+	PROCEDURE (log: Hook) Int* (n: LONGINT), NEW, ABSTRACT;
+	PROCEDURE (log: Hook) Real* (x: REAL), NEW, ABSTRACT;
+	PROCEDURE (log: Hook) String* (IN str: ARRAY OF CHAR), NEW, ABSTRACT;
+	PROCEDURE (log: Hook) Bool* (x: BOOLEAN), NEW, ABSTRACT;
+	PROCEDURE (log: Hook) Set* (x: SET), NEW, ABSTRACT;
+	PROCEDURE (log: Hook) Tab*, NEW, ABSTRACT;
+	PROCEDURE (log: Hook) Ln*, NEW, ABSTRACT;
+	PROCEDURE (log: Hook) ParamMsg* (IN s, p0, p1, p2: ARRAY OF CHAR), NEW, ABSTRACT;
+	PROCEDURE (log: Hook) IntForm* (x: INTEGER; base, minWidth: INTEGER; fillCh: CHAR;
+														showBase: BOOLEAN), NEW, ABSTRACT;
+	PROCEDURE (log: Hook) RealForm* (x: REAL; precision, minW, expW: INTEGER;
+																fillCh: CHAR), NEW, ABSTRACT;
+
+
+	PROCEDURE SetHook*(h: Hook);
+	BEGIN
+		hook := h
+	END SetHook;
+
+	PROCEDURE ClearBuf*;
+	BEGIN
+		IF hook # NIL THEN hook.ClearBuf END
+	END ClearBuf;
+
+	PROCEDURE FlushBuf*;
+	BEGIN
+		IF hook # NIL THEN hook.FlushBuf END
+	END FlushBuf;
+
+	PROCEDURE Beep*;
+	BEGIN
+		IF hook # NIL THEN hook.Beep() END
+	END Beep;
+
+	PROCEDURE Char* (ch: CHAR);
+	BEGIN
+		IF hook # NIL THEN hook.Char(ch) END
+	END Char;
+
+	PROCEDURE Int* (n: LONGINT);
+	BEGIN
+		IF hook # NIL THEN hook.Int(n) END
+	END Int;
+
+	PROCEDURE Real* (x: REAL);
+	BEGIN
+		IF hook # NIL THEN hook.Real(x) END
+	END Real;
+
+	PROCEDURE String* (str: ARRAY OF CHAR);
+	BEGIN
+		IF hook # NIL THEN hook.String(str) END
+	END String;
+
+	PROCEDURE Bool* (x: BOOLEAN);
+	BEGIN
+		IF hook # NIL THEN hook.Bool(x) END
+	END Bool;
+
+	PROCEDURE Set* (x: SET);
+	BEGIN
+		IF hook # NIL THEN hook.Set(x) END
+	END Set;
+
+	PROCEDURE IntForm* (x: INTEGER; base, minWidth: INTEGER; fillCh: CHAR; showBase: BOOLEAN);
+	BEGIN
+		IF hook # NIL THEN hook.IntForm(x, base, minWidth, fillCh, showBase) END
+	END IntForm;
+
+	PROCEDURE RealForm* (x: REAL; precision, minW, expW: INTEGER; fillCh: CHAR);
+	BEGIN
+		IF hook # NIL THEN hook.RealForm(x, precision, minW, expW, fillCh) END
+	END RealForm;
+
+	PROCEDURE Tab*;
+	BEGIN
+		IF hook # NIL THEN hook.Tab END
+	END Tab;
+
+	PROCEDURE Ln*;
+	BEGIN
+		IF hook # NIL THEN hook.Ln END
+	END Ln;
+
+	PROCEDURE ParamMsg* (s, p0, p1, p2: ARRAY OF CHAR);
+	BEGIN
+		IF hook # NIL THEN hook.ParamMsg(s, p0, p1, p2) END
+	END ParamMsg;
+
+	PROCEDURE Msg* (s: ARRAY OF CHAR);
+	BEGIN
+		ParamMsg(s, "", "", "")
+	END Msg;
+
+END Out.

Src/System/Mod/Start.cp

@@ -0,0 +1,9 @@
+MODULE Start;
+	IMPORT Cons, Core;
+BEGIN
+	Core.LoadMod("TestA0");
+	Core.LoadMod("TestA1");
+	Core.LoadMod("TestA2");
+	Core.LoadMod("TestMath");
+	Core.LoadMod("TestStrings");
+END Start.

Src/System/Mod/Str.cp

@@ -0,0 +1,146 @@
+MODULE Str;
+	(* по идее, Strings должен полностью работать *)
+	
+	IMPORT
+		Mathe;
+		
+	CONST
+		minLongIntRev = "8085774586302733229";	(* reversed string of -MIN(LONGINT) *)
+		digitspace* = 08FX;
+	
+	VAR
+		maxExp: INTEGER;
+		maxDig: INTEGER;
+		factor: REAL;	(* 10^maxDig *)	
+	
+	(* integer conversions *)
+
+	PROCEDURE IntToString* (x: LONGINT; OUT s: ARRAY OF CHAR);
+		VAR j, k: INTEGER; ch: CHAR; a: ARRAY 32 OF CHAR;
+	BEGIN
+		IF x # MIN(LONGINT) THEN
+			IF x < 0 THEN s[0] := "-"; k := 1; x := -x ELSE k := 0 END;
+			j := 0; REPEAT a[j] := CHR(x MOD 10 + ORD("0")); x := x DIV 10; INC(j) UNTIL x = 0
+		ELSE
+			a := minLongIntRev; s[0] := "-"; k := 1;
+			j := 0; WHILE a[j] # 0X DO INC(j) END
+		END;
+		ASSERT(k + j < LEN(s), 23);
+		REPEAT DEC(j); ch := a[j]; s[k] := ch; INC(k) UNTIL j = 0;
+		s[k] := 0X
+	END IntToString;
+	
+		(* real conversions *)
+
+	PROCEDURE RealToStringForm* (x: REAL; precision, minW, expW: INTEGER; fillCh: CHAR;
+														OUT s: ARRAY OF CHAR);
+		VAR exp, len, i, j, n, k, p: INTEGER; m: ARRAY 80 OF CHAR; neg: BOOLEAN;
+	BEGIN
+		ASSERT((precision > 0) (*& (precision <= 18)*), 20);
+		ASSERT((minW >= 0) & (minW < LEN(s)), 21);
+		ASSERT((expW > -LEN(s)) & (expW <= 3), 22);
+		exp := Mathe.Exponent(x);
+		IF exp = MAX(INTEGER) THEN
+			IF fillCh = "0" THEN fillCh := digitspace END;
+			x := Mathe.Mantissa(x);
+			IF x = -1 THEN m := "-inf"; n := 4
+			ELSIF x = 1 THEN m := "inf"; n := 3
+			ELSE m := "nan"; n := 3
+			END;
+			i := 0; j := 0;
+			WHILE minW > n DO s[i] := fillCh; INC(i); DEC(minW) END;
+			WHILE (j <= n) & (i < LEN(s)) DO s[i] := m[j]; INC(i); INC(j) END
+		ELSE
+			neg := FALSE; len := 1; m := "00";
+			IF x < 0 THEN x := -x; neg := TRUE; DEC(minW) END;
+			IF x # 0 THEN
+				exp := (exp - 8) * 30103 DIV 100000;	(* * log(2) *)
+				IF exp > 0 THEN
+					n := SHORT(ENTIER(x / Mathe.IntPower(10, exp)));
+					x := x / Mathe.IntPower(10, exp) - n
+				ELSIF exp > -maxExp THEN
+					n := SHORT(ENTIER(x * Mathe.IntPower(10, -exp)));
+					x := x * Mathe.IntPower(10, -exp) - n
+				ELSE
+					n := SHORT(ENTIER(x * Mathe.IntPower(10, -exp - 2 * maxDig) * factor * factor));
+					x := x * Mathe.IntPower(10, -exp - 2 * maxDig) * factor * factor - n
+				END;
+				(* x0 = (n + x) * 10^exp, 200 < n < 5000 *)
+				p := precision - 4;
+				IF n < 1000 THEN INC(p) END;
+				IF (expW < 0) & (p > exp - expW) THEN p := exp - expW END;
+				IF p >= 0 THEN
+					x := x + 0.5 / Mathe.IntPower(10, p);	(* rounding correction *)
+					IF x >= 1 THEN INC(n); x := x - 1 END
+				ELSIF p = -1 THEN INC(n, 5)
+				ELSIF p = -2 THEN INC(n, 50)
+				ELSIF p = -3 THEN INC(n, 500)
+				END;
+				i := 0; k := 1000; INC(exp, 3);
+				IF n < 1000 THEN k := 100; DEC(exp) END;
+				WHILE (i < precision) & ((k > 0) OR (x # 0)) DO
+					IF k > 0 THEN p := n DIV k; n := n MOD k; k := k DIV 10
+					ELSE x := x * 10; p := SHORT(ENTIER(x)); x := x - p
+					END;
+					m[i] := CHR(p + ORD("0")); INC(i);
+					IF p # 0 THEN len := i END
+				END
+			END;
+			(* x0 = m[0].m[1]...m[len-1] * 10^exp *)
+			i := 0;
+			IF (expW < 0) OR (expW = 0) & (exp >= -3) & (exp <= len + 1) THEN
+				n := exp + 1; k := len - n;
+				IF n < 1 THEN n := 1 END;
+				IF expW < 0 THEN k := -expW ELSIF k < 1 THEN k := 1 END;
+				j := minW - n - k - 1; p := -exp;
+				IF neg & (p >= MAX(0, n) + MAX(0, k)) THEN neg := FALSE; INC(j) END
+			ELSE
+				IF ABS(exp) >= 100 THEN expW := 3
+				ELSIF (expW < 2) & (ABS(exp) >= 10) THEN expW := 2
+				ELSIF expW < 1 THEN expW := 1
+				END;
+				IF len < 2 THEN len := 2 END;
+				j := minW - len - 3 - expW; k := len;
+				IF j > 0 THEN
+					k := k + j; j := 0;
+					IF k > precision THEN j := k - precision; k := precision END
+				END;
+				n := 1; DEC(k); p := 0
+			END;
+			IF neg & (fillCh = "0") THEN s[i] := "-"; INC(i); neg := FALSE END;
+			WHILE j > 0 DO s[i] := fillCh; INC(i); DEC(j) END;
+			IF neg & (i < LEN(s)) THEN s[i] := "-"; INC(i) END;
+			j := 0;
+			WHILE (n > 0) & (i < LEN(s)) DO
+				IF (p <= 0) & (j < len) THEN s[i] := m[j]; INC(j) ELSE s[i] := "0" END;
+				INC(i); DEC(n); DEC(p)
+			END;
+			IF i < LEN(s) THEN s[i] := "."; INC(i) END;
+			WHILE (k > 0) & (i < LEN(s)) DO
+				IF (p <= 0) & (j < len) THEN s[i] := m[j]; INC(j) ELSE s[i] := "0" END;
+				INC(i); DEC(k); DEC(p)
+			END;
+			IF expW > 0 THEN
+				IF i < LEN(s) THEN s[i] := "E"; INC(i) END;
+				IF i < LEN(s) THEN
+					IF exp < 0 THEN s[i] := "-"; exp := -exp ELSE s[i] := "+" END;
+					INC(i)
+				END;
+				IF (expW = 3) & (i < LEN(s)) THEN s[i] := CHR(exp DIV 100 + ORD("0")); INC(i) END;
+				IF (expW >= 2) & (i < LEN(s)) THEN s[i] := CHR(exp DIV 10 MOD 10 + ORD("0")); INC(i) END;
+				IF i < LEN(s) THEN s[i] := CHR(exp MOD 10 + ORD("0")); INC(i) END
+			END
+		END;
+		IF i < LEN(s) THEN s[i] := 0X ELSE HALT(23) END
+	END RealToStringForm;
+
+	PROCEDURE RealToString* (x: REAL; OUT s: ARRAY OF CHAR);
+	BEGIN
+		RealToStringForm(x, 16, 0, 0, digitspace, s)
+	END RealToString;
+	
+BEGIN
+	maxExp := SHORT(ENTIER(Mathe.Log(MAX(REAL)))) + 1;	
+	maxDig := SHORT(ENTIER(-Mathe.Log(Mathe.Eps())));
+	factor := Mathe.IntPower(10, maxDig)
+END Str.

Src/Test/Mod/A0.cp

@@ -0,0 +1,94 @@
+MODULE TestA0;
+
+	IMPORT Log:=Out, Core;
+	
+	TYPE
+		Item = POINTER TO RECORD
+			x: INTEGER;
+			next: Item;
+		END;
+	
+	VAR
+		test: Item;
+	
+	PROCEDURE (i: Item) FINALIZE;
+	BEGIN
+		Log.String(".");
+	END FINALIZE;
+			
+	PROCEDURE Do*;
+		VAR root, item: Item; i: INTEGER;
+	BEGIN 
+		i:=0;
+		WHILE i<20 DO
+			NEW(item);
+			item.next:=root;
+			root:=item;
+			INC(i);
+			item.x:=i			
+		END;
+		item:=root;
+		WHILE item#NIL DO
+			Log.Int(item.x);
+			item:=item.next
+		END;
+		Log.Ln;
+	END Do;
+	
+	PROCEDURE Do0;
+		VAR p: Item;
+	BEGIN
+		IF p#NIL THEN
+			p.next:=NIL (* NIL trap here? *)
+		END;
+	END Do0;
+	
+	PROCEDURE Do1;
+		VAR x: BOOLEAN;
+		
+		PROCEDURE A(): BOOLEAN;
+		BEGIN
+			RETURN TRUE;
+		END A;
+		
+		PROCEDURE B(): BOOLEAN;
+		BEGIN
+			RETURN FALSE;
+		END B;
+		
+		PROCEDURE C(): BOOLEAN;
+		BEGIN
+			HALT(100);
+			RETURN FALSE;
+		END C;
+		
+	BEGIN
+		x:= A() & B();
+		Log.Bool(x); Log.Ln;
+		x:=B() & C();
+		Log.Bool(x); Log.Ln;
+		x:=A() OR C();
+		Log.Bool(x); Log.Ln;
+	END Do1;
+	
+	PROCEDURE Do2;
+		VAR i: INTEGER;
+	BEGIN
+		Log.String("cycle start"); Log.Ln;
+		i:=0;
+		WHILE i<10000 DO INC(i) END;
+		Log.String("cycle stop"); Log.Ln;
+	END Do2;
+	
+BEGIN
+	NEW(test);
+	Log.String("Hello, world!");
+	Log.Int(1945);
+	Log.Real(0.34423);
+	Log.Ln;
+	test:=NIL;
+	Do;
+	Do1;
+	Do2;
+	Do0;
+END TestA0.

Src/Test/Mod/A1.cp

@@ -0,0 +1,32 @@
+MODULE TestA1;
+	IMPORT Log:=Out;
+	
+	PROCEDURE Do;
+		VAR a, b, c: SET;
+	BEGIN
+		a:={1..4, 7, 15..30};
+		b:={1};
+		c:=a-b;
+		Log.Set(a); Log.String("-"); Log.Set(b); Log.Set(c); Log.Ln;
+
+		a:={1..4, 7, 15..30};
+		b:={8, 16};
+		c:=a+b;
+		Log.Set(a); Log.String("+"); Log.Set(b); Log.Set(c); Log.Ln;
+		
+		a:={1..4, 7, 15..30};
+		b:=BITS(3467);
+		c:=a*b;
+		Log.Set(a); Log.String("*"); Log.Set(b); Log.Set(c); Log.Ln;
+		
+		a:={1..4, 7, 15..30};
+		b:=BITS(3467);
+		c:=a/b;
+		Log.Set(a); Log.String("/"); Log.Set(b); Log.Set(c); Log.Ln;
+
+	END Do;
+	
+BEGIN
+	Log.String("Test SET's"); Log.Ln;
+	Do;
+END TestA1.

Src/Test/Mod/A2.cp

@@ -0,0 +1,19 @@
+MODULE TestA2;
+	IMPORT
+		Log:=Out;
+	
+	PROCEDURE Do;
+		VAR a, b: BOOLEAN;
+	BEGIN
+		a:=TRUE; b:=FALSE;
+		Log.Bool(a OR b); Log.Ln;
+		Log.Bool(a & b); Log.Ln;
+		Log.Bool(a # b); Log.Ln;
+		Log.Bool(~a); Log.Ln;
+		Log.Bool(~b); Log.Ln;
+	END Do;
+	
+BEGIN
+	Log.String("TEST logic"); Log.Ln;
+	Do;
+END TestA2.

Src/Test/Mod/Math.cp

@@ -0,0 +1,35 @@
+MODULE TestMath;
+	
+	IMPORT
+		Log:=Out;
+	
+	PROCEDURE Do;
+		VAR a, b: INTEGER; 
+	BEGIN
+		a:=5; b:=3;
+		Log.Int(a); Log.String(" DIV"); Log.Int(b); Log.Int(a DIV b); Log.Ln; ASSERT((a DIV b) = 1, 60);
+		Log.Int(a); Log.String(" MOD"); Log.Int(b); Log.Int(a MOD b); Log.Ln; ASSERT((a MOD b) = 2, 61);
+		Log.Ln;
+		
+		a:=-5; b:=3;
+		Log.Int(a); Log.String(" DIV"); Log.Int(b); Log.Int(a DIV b); Log.Ln; ASSERT((a DIV b) = -2, 62);
+		Log.Int(a); Log.String(" MOD"); Log.Int(b); Log.Int(a MOD b); Log.Ln; ASSERT((a MOD b) = 1, 63);
+		Log.Ln;
+		
+		a:=5; b:=-3;
+		Log.Int(a); Log.String(" DIV"); Log.Int(b); Log.Int(a DIV b); Log.Ln; ASSERT((a DIV b) = -2, 64);
+		Log.Int(a); Log.String(" MOD"); Log.Int(b); Log.Int(a MOD b); Log.Ln; ASSERT((a MOD b) = -1, 65);
+		Log.Ln;
+		
+		a:=-5; b:=-3;
+		Log.Int(a); Log.String(" DIV"); Log.Int(b); Log.Int(a DIV b); Log.Ln; ASSERT((a DIV b) = 1, 66);
+		Log.Int(a); Log.String(" MOD"); Log.Int(b); Log.Int(a MOD b); Log.Ln; ASSERT((a MOD b) = -2, 67);
+		
+		ASSERT(a = (a DIV b) * b + (a MOD b), 68);
+		ASSERT(LONG(a DIV b) = ENTIER(a / b), 69);
+	END Do;
+	
+BEGIN
+	Log.String("TEST math"); Log.Ln;
+	Do;	
+END TestMath.

Src/Test/Mod/Strings.cp

@@ -0,0 +1,65 @@
+MODULE TestStrings;
+	IMPORT
+		Log:=Out;
+	
+	TYPE
+		List = ARRAY 64 OF ARRAY 256 OF CHAR;
+		
+	VAR 
+		l: List;
+		count: INTEGER;
+	
+	PROCEDURE Sort;
+		VAR i, j: INTEGER; buf: ARRAY 256 OF CHAR;
+	BEGIN
+		i:=0;
+		WHILE i<count DO
+			j:=0;
+			WHILE j<count-i-1 DO
+				IF l[j]>l[j+1] THEN
+					buf:=l[j]$;
+					l[j]:=l[j+1];
+					l[j+1]:=buf$;
+				END;
+				INC(j);
+			END;
+			INC(i);
+		END; 
+	END Sort;
+	
+	PROCEDURE Dump;
+		VAR i: INTEGER;
+	BEGIN
+		Log.String("TEST dump"); Log.Ln;
+		i:=0;
+		WHILE i<count DO Log.String(l[i]); Log.Ln; INC(i) END;
+	END Dump;
+	
+	PROCEDURE Do;
+		VAR s: ARRAY 256 OF CHAR; buf: ARRAY 50 OF CHAR; i, j, len, x: INTEGER;
+	BEGIN
+		s:="Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc dignissim vitae eros nec gravida. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.";
+		len:=LEN(s$);
+		Log.Int(len); Log.Ln;
+		i:=0; j:=0; buf:="";
+		WHILE i<len DO
+			CASE s[i] OF
+			" ", ",", ".": IF buf$#"" THEN l[j]:=buf$; Log.String(buf$); Log.Ln; buf:=""; INC(j); INC(count); END; |
+			ELSE
+				x:=LEN(buf$);
+				buf[x]:=s[i];
+				buf[x+1]:=0X;
+			END;
+			INC(i);
+		END;
+	END Do;
+	
+BEGIN
+	Log.String("TEST strings"); Log.Ln;
+	count:=0;
+	Do;
+	Dump;
+	Log.String("TEST sort"); Log.Ln;
+	Sort;
+	Dump;
+END TestStrings.

xev.bat

@@ -0,0 +1,4 @@
+@echo off 
+cd ..
+start bbcb.exe /USE %CD%\Xev\Src
+