WebSVN – Kolibri OS – Diff – /programs/develop/oberon07/source/UTILS.ob07


﻿(*
    BSD 2-Clause License
 
    Copyright (c) 2018-2023, Anton Krotov
    All rights reserved.
*)
 
MODULE UTILS;
 
IMPORT HOST;
 
 
CONST
 
    slash* = HOST.slash;
    eol* = HOST.eol;
 
    bit_depth* = HOST.bit_depth;
    maxint* = HOST.maxint;
    minint* = HOST.minint;
 
    min32* = -2147483647-1;
    max32* =  2147483647;
 
    vMajor* = 1;
    vMinor* = 64;
    Date* = "22-jan-2023";
 
    FILE_EXT* = ".ob07";
    RTL_NAME* = "RTL";
 
    MAX_GLOBAL_SIZE* = 1600000000;
 
 
VAR
 
    time*: INTEGER;
 
    maxreal*, inf*: REAL;
 
    target*:
 
      RECORD
 
          bit_depth*,
          maxInt*,
          minInt*,
          maxSet*,
          maxHex*:    INTEGER;
 
          maxReal*:   REAL
 
      END;
 
    bit_diff*: INTEGER;
 
 
PROCEDURE FileRead* (F: INTEGER; VAR Buffer: ARRAY OF CHAR; bytes: INTEGER): INTEGER;
    RETURN HOST.FileRead(F, Buffer, bytes)
END FileRead;
 
 
PROCEDURE FileWrite* (F: INTEGER; Buffer: ARRAY OF BYTE; bytes: INTEGER): INTEGER;
    RETURN HOST.FileWrite(F, Buffer, bytes)
END FileWrite;
 
 
PROCEDURE FileCreate* (FName: ARRAY OF CHAR): INTEGER;
    RETURN HOST.FileCreate(FName)
END FileCreate;
 
 
PROCEDURE FileClose* (F: INTEGER);
BEGIN
    HOST.FileClose(F)
END FileClose;
 
 
PROCEDURE FileOpen* (FName: ARRAY OF CHAR): INTEGER;
    RETURN HOST.FileOpen(FName)
END FileOpen;
 
 
PROCEDURE chmod* (FName: ARRAY OF CHAR);
BEGIN
    HOST.chmod(FName)
END chmod;
 
 
PROCEDURE GetArg* (i: INTEGER; VAR str: ARRAY OF CHAR);
BEGIN
    HOST.GetArg(i, str)
END GetArg;
 
 
PROCEDURE Exit* (code: INTEGER);
BEGIN
    HOST.ExitProcess(code)
END Exit;
 
 
PROCEDURE GetTickCount* (): INTEGER;
    RETURN HOST.GetTickCount()
END GetTickCount;
 
 
PROCEDURE OutChar* (c: CHAR);
BEGIN
    HOST.OutChar(c)
END OutChar;
 
 
PROCEDURE splitf* (x: REAL; VAR a, b: INTEGER): INTEGER;
    RETURN HOST.splitf(x, a, b)
END splitf;
 
 
PROCEDURE d2s* (x: REAL): INTEGER;
    RETURN HOST.d2s(x)
END d2s;
 
 
PROCEDURE isRelative* (path: ARRAY OF CHAR): BOOLEAN;
    RETURN HOST.isRelative(path)
END isRelative;
 
 
PROCEDURE GetCurrentDirectory* (VAR path: ARRAY OF CHAR);
BEGIN
    HOST.GetCurrentDirectory(path)
END GetCurrentDirectory;
 
 
PROCEDURE UnixTime* (): INTEGER;
    RETURN HOST.UnixTime()
END UnixTime;
 
 
PROCEDURE SetBitDepth* (BitDepth: INTEGER; Double: BOOLEAN);
BEGIN
    ASSERT((BitDepth = 16) OR (BitDepth = 32) OR (BitDepth = 64));
    bit_diff := bit_depth - BitDepth;
    ASSERT(bit_diff >= 0);
 
    target.bit_depth := BitDepth;
    target.maxSet    := BitDepth - 1;
    target.maxHex    := BitDepth DIV 4;
    target.minInt    := ASR(minint, bit_diff);
    target.maxInt    := ASR(maxint, bit_diff);
 
    IF Double THEN
        target.maxReal := maxreal
    ELSE
        target.maxReal := 1.9;
        PACK(target.maxReal, 127)
    END
END SetBitDepth;
 
 
PROCEDURE Byte* (n: INTEGER; idx: INTEGER): BYTE;
    RETURN ASR(n, 8 * idx) MOD 256
END Byte;
 
 
PROCEDURE Align* (VAR bytes: INTEGER; align: INTEGER): BOOLEAN;
BEGIN
    INC(bytes, (-bytes) MOD align)
    RETURN bytes >= 0
END Align;
 
 
PROCEDURE Long* (value: INTEGER): INTEGER;
    RETURN ASR(LSL(value, bit_diff), bit_diff)
END Long;
 
 
PROCEDURE Short* (value: INTEGER): INTEGER;
    RETURN LSR(LSL(value, bit_diff), bit_diff)
END Short;
 
 
PROCEDURE Log2* (x: INTEGER): INTEGER;
VAR
    n: INTEGER;
 
BEGIN
    n := 0;
    WHILE ~ODD(x) DO
        x := x DIV 2;
        INC(n)
    END;
 
    IF x # 1 THEN
        n := -1
    END
 
    RETURN n
END Log2;
 
 
PROCEDURE hexdgt* (n: BYTE): BYTE;
BEGIN
    IF n < 10 THEN
        INC(n, ORD("0"))
    ELSE
        INC(n, ORD("A") - 10)
    END
 
    RETURN n
END hexdgt;
 
 
BEGIN
    time := HOST.GetTickCount();
    inf := HOST.inf;
    maxreal := HOST.maxreal
END UTILS.

Rev 9893	Rev 9895
1	(*	1	(*
2	BSD 2-Clause License	2	BSD 2-Clause License
3		3
4	Copyright (c) 2018-2023, Anton Krotov	4	Copyright (c) 2018-2023, Anton Krotov
5	All rights reserved.	5	All rights reserved.
6	*)	6	*)
7		7
8	MODULE UTILS;	8	MODULE UTILS;
9		9
10	IMPORT HOST;	10	IMPORT HOST;
11		11
12		12
13	CONST	13	CONST
14		14
15	slash* = HOST.slash;	15	slash* = HOST.slash;
16	eol* = HOST.eol;	16	eol* = HOST.eol;
17		17
18	bit_depth* = HOST.bit_depth;	18	bit_depth* = HOST.bit_depth;
19	maxint* = HOST.maxint;	19	maxint* = HOST.maxint;
20	minint* = HOST.minint;	20	minint* = HOST.minint;
21		21
22	min32* = -2147483647-1;	22	min32* = -2147483647-1;
23	max32* = 2147483647;	23	max32* = 2147483647;
24		24
25	vMajor* = 1;	25	vMajor* = 1;
26	vMinor* = 63;	26	vMinor* = 64;
27	Date* = "21-jan-2023";	27	Date* = "22-jan-2023";
28		28
29	FILE_EXT* = ".ob07";	29	FILE_EXT* = ".ob07";
30	RTL_NAME* = "RTL";	30	RTL_NAME* = "RTL";
31		31
32	MAX_GLOBAL_SIZE* = 1600000000;	32	MAX_GLOBAL_SIZE* = 1600000000;
33		33
34		34
35	VAR	35	VAR
36		36
37	time*: INTEGER;	37	time*: INTEGER;
38		38
39	maxreal, inf: REAL;	39	maxreal, inf: REAL;
40		40
41	target*:	41	target*:
42		42
43	RECORD	43	RECORD
44		44
45	bit_depth*,	45	bit_depth*,
46	maxInt*,	46	maxInt*,
47	minInt*,	47	minInt*,
48	maxSet*,	48	maxSet*,
49	maxHex*: INTEGER;	49	maxHex*: INTEGER;
50		50
51	maxReal*: REAL	51	maxReal*: REAL
52		52
53	END;	53	END;
54		54
55	bit_diff*: INTEGER;	55	bit_diff*: INTEGER;
56		56
57		57
58	PROCEDURE FileRead* (F: INTEGER; VAR Buffer: ARRAY OF CHAR; bytes: INTEGER): INTEGER;	58	PROCEDURE FileRead* (F: INTEGER; VAR Buffer: ARRAY OF CHAR; bytes: INTEGER): INTEGER;
59	RETURN HOST.FileRead(F, Buffer, bytes)	59	RETURN HOST.FileRead(F, Buffer, bytes)
60	END FileRead;	60	END FileRead;
61		61
62		62
63	PROCEDURE FileWrite* (F: INTEGER; Buffer: ARRAY OF BYTE; bytes: INTEGER): INTEGER;	63	PROCEDURE FileWrite* (F: INTEGER; Buffer: ARRAY OF BYTE; bytes: INTEGER): INTEGER;
64	RETURN HOST.FileWrite(F, Buffer, bytes)	64	RETURN HOST.FileWrite(F, Buffer, bytes)
65	END FileWrite;	65	END FileWrite;
66		66
67		67
68	PROCEDURE FileCreate* (FName: ARRAY OF CHAR): INTEGER;	68	PROCEDURE FileCreate* (FName: ARRAY OF CHAR): INTEGER;
69	RETURN HOST.FileCreate(FName)	69	RETURN HOST.FileCreate(FName)
70	END FileCreate;	70	END FileCreate;
71		71
72		72
73	PROCEDURE FileClose* (F: INTEGER);	73	PROCEDURE FileClose* (F: INTEGER);
74	BEGIN	74	BEGIN
75	HOST.FileClose(F)	75	HOST.FileClose(F)
76	END FileClose;	76	END FileClose;
77		77
78		78
79	PROCEDURE FileOpen* (FName: ARRAY OF CHAR): INTEGER;	79	PROCEDURE FileOpen* (FName: ARRAY OF CHAR): INTEGER;
80	RETURN HOST.FileOpen(FName)	80	RETURN HOST.FileOpen(FName)
81	END FileOpen;	81	END FileOpen;
82		82
83		83
84	PROCEDURE chmod* (FName: ARRAY OF CHAR);	84	PROCEDURE chmod* (FName: ARRAY OF CHAR);
85	BEGIN	85	BEGIN
86	HOST.chmod(FName)	86	HOST.chmod(FName)
87	END chmod;	87	END chmod;
88		88
89		89
90	PROCEDURE GetArg* (i: INTEGER; VAR str: ARRAY OF CHAR);	90	PROCEDURE GetArg* (i: INTEGER; VAR str: ARRAY OF CHAR);
91	BEGIN	91	BEGIN
92	HOST.GetArg(i, str)	92	HOST.GetArg(i, str)
93	END GetArg;	93	END GetArg;
94		94
95		95
96	PROCEDURE Exit* (code: INTEGER);	96	PROCEDURE Exit* (code: INTEGER);
97	BEGIN	97	BEGIN
98	HOST.ExitProcess(code)	98	HOST.ExitProcess(code)
99	END Exit;	99	END Exit;
100		100
101		101
102	PROCEDURE GetTickCount* (): INTEGER;	102	PROCEDURE GetTickCount* (): INTEGER;
103	RETURN HOST.GetTickCount()	103	RETURN HOST.GetTickCount()
104	END GetTickCount;	104	END GetTickCount;
105		105
106		106
107	PROCEDURE OutChar* (c: CHAR);	107	PROCEDURE OutChar* (c: CHAR);
108	BEGIN	108	BEGIN
109	HOST.OutChar(c)	109	HOST.OutChar(c)
110	END OutChar;	110	END OutChar;
111		111
112		112
113	PROCEDURE splitf* (x: REAL; VAR a, b: INTEGER): INTEGER;	113	PROCEDURE splitf* (x: REAL; VAR a, b: INTEGER): INTEGER;
114	RETURN HOST.splitf(x, a, b)	114	RETURN HOST.splitf(x, a, b)
115	END splitf;	115	END splitf;
116		116
117		117
118	PROCEDURE d2s* (x: REAL): INTEGER;	118	PROCEDURE d2s* (x: REAL): INTEGER;
119	RETURN HOST.d2s(x)	119	RETURN HOST.d2s(x)
120	END d2s;	120	END d2s;
121		121
122		122
123	PROCEDURE isRelative* (path: ARRAY OF CHAR): BOOLEAN;	123	PROCEDURE isRelative* (path: ARRAY OF CHAR): BOOLEAN;
124	RETURN HOST.isRelative(path)	124	RETURN HOST.isRelative(path)
125	END isRelative;	125	END isRelative;
126		126
127		127
128	PROCEDURE GetCurrentDirectory* (VAR path: ARRAY OF CHAR);	128	PROCEDURE GetCurrentDirectory* (VAR path: ARRAY OF CHAR);
129	BEGIN	129	BEGIN
130	HOST.GetCurrentDirectory(path)	130	HOST.GetCurrentDirectory(path)
131	END GetCurrentDirectory;	131	END GetCurrentDirectory;
132		132
133		133
134	PROCEDURE UnixTime* (): INTEGER;	134	PROCEDURE UnixTime* (): INTEGER;
135	RETURN HOST.UnixTime()	135	RETURN HOST.UnixTime()
136	END UnixTime;	136	END UnixTime;
137		137
138		138
139	PROCEDURE SetBitDepth* (BitDepth: INTEGER; Double: BOOLEAN);	139	PROCEDURE SetBitDepth* (BitDepth: INTEGER; Double: BOOLEAN);
140	BEGIN	140	BEGIN
141	ASSERT((BitDepth = 16) OR (BitDepth = 32) OR (BitDepth = 64));	141	ASSERT((BitDepth = 16) OR (BitDepth = 32) OR (BitDepth = 64));
142	bit_diff := bit_depth - BitDepth;	142	bit_diff := bit_depth - BitDepth;
143	ASSERT(bit_diff >= 0);	143	ASSERT(bit_diff >= 0);
144		144
145	target.bit_depth := BitDepth;	145	target.bit_depth := BitDepth;
146	target.maxSet := BitDepth - 1;	146	target.maxSet := BitDepth - 1;
147	target.maxHex := BitDepth DIV 4;	147	target.maxHex := BitDepth DIV 4;
148	target.minInt := ASR(minint, bit_diff);	148	target.minInt := ASR(minint, bit_diff);
149	target.maxInt := ASR(maxint, bit_diff);	149	target.maxInt := ASR(maxint, bit_diff);
150		150
151	IF Double THEN	151	IF Double THEN
152	target.maxReal := maxreal	152	target.maxReal := maxreal
153	ELSE	153	ELSE
154	target.maxReal := 1.9;	154	target.maxReal := 1.9;
155	PACK(target.maxReal, 127)	155	PACK(target.maxReal, 127)
156	END	156	END
157	END SetBitDepth;	157	END SetBitDepth;
158		158
159		159
160	PROCEDURE Byte* (n: INTEGER; idx: INTEGER): BYTE;	160	PROCEDURE Byte* (n: INTEGER; idx: INTEGER): BYTE;
161	RETURN ASR(n, 8 * idx) MOD 256	161	RETURN ASR(n, 8 * idx) MOD 256
162	END Byte;	162	END Byte;
163		163
164		164
165	PROCEDURE Align* (VAR bytes: INTEGER; align: INTEGER): BOOLEAN;	165	PROCEDURE Align* (VAR bytes: INTEGER; align: INTEGER): BOOLEAN;
166	BEGIN	166	BEGIN
167	INC(bytes, (-bytes) MOD align)	167	INC(bytes, (-bytes) MOD align)
168	RETURN bytes >= 0	168	RETURN bytes >= 0
169	END Align;	169	END Align;
170		170
171		171
172	PROCEDURE Long* (value: INTEGER): INTEGER;	172	PROCEDURE Long* (value: INTEGER): INTEGER;
173	RETURN ASR(LSL(value, bit_diff), bit_diff)	173	RETURN ASR(LSL(value, bit_diff), bit_diff)
174	END Long;	174	END Long;
175		175
176		176
177	PROCEDURE Short* (value: INTEGER): INTEGER;	177	PROCEDURE Short* (value: INTEGER): INTEGER;
178	RETURN LSR(LSL(value, bit_diff), bit_diff)	178	RETURN LSR(LSL(value, bit_diff), bit_diff)
179	END Short;	179	END Short;
180		180
181		181
182	PROCEDURE Log2* (x: INTEGER): INTEGER;	182	PROCEDURE Log2* (x: INTEGER): INTEGER;
183	VAR	183	VAR
184	n: INTEGER;	184	n: INTEGER;
185		185
186	BEGIN	186	BEGIN
187	n := 0;	187	n := 0;
188	WHILE ~ODD(x) DO	188	WHILE ~ODD(x) DO
189	x := x DIV 2;	189	x := x DIV 2;
190	INC(n)	190	INC(n)
191	END;	191	END;
192		192
193	IF x # 1 THEN	193	IF x # 1 THEN
194	n := -1	194	n := -1
195	END	195	END
196		196
197	RETURN n	197	RETURN n
198	END Log2;	198	END Log2;
199		199
200		200
201	PROCEDURE hexdgt* (n: BYTE): BYTE;	201	PROCEDURE hexdgt* (n: BYTE): BYTE;
202	BEGIN	202	BEGIN
203	IF n < 10 THEN	203	IF n < 10 THEN
204	INC(n, ORD("0"))	204	INC(n, ORD("0"))
205	ELSE	205	ELSE
206	INC(n, ORD("A") - 10)	206	INC(n, ORD("A") - 10)
207	END	207	END
208		208
209	RETURN n	209	RETURN n
210	END hexdgt;	210	END hexdgt;
211		211
212		212
213	BEGIN	213	BEGIN
214	time := HOST.GetTickCount();	214	time := HOST.GetTickCount();
215	inf := HOST.inf;	215	inf := HOST.inf;
216	maxreal := HOST.maxreal	216	maxreal := HOST.maxreal
217	END UTILS.	217	END UTILS.

Subversion Repositories Kolibri OS

(root)/programs/develop/oberon07/source/UTILS.ob07 – Rev 9893 → 9895