WebSVN – Kolibri OS – Diff – /programs/develop/oberon07/Lib/Linux32/HOST.ob07


(*
    BSD 2-Clause License
 
    Copyright (c) 2019, Anton Krotov
    All rights reserved.
*)
 
MODULE HOST;
 
IMPORT SYSTEM, API, RTL;
 
 
CONST
 
    slash* = "/";
    OS* = "LINUX";
 
    bit_depth* = RTL.bit_depth;
    maxint* = RTL.maxint;
    minint* = RTL.minint;
 
 
VAR
 
    argc: INTEGER;
 
    eol*: ARRAY 2 OF CHAR;
 
 
PROCEDURE ExitProcess* (code: INTEGER);
BEGIN
    API.exit(code)
END ExitProcess;
 
 
PROCEDURE GetArg* (n: INTEGER; VAR s: ARRAY OF CHAR);
VAR
    i, len, ptr: INTEGER;
    c: CHAR;
 
BEGIN
    i := 0;
    len := LEN(s) - 1;
    IF (n < argc) & (len > 0) THEN
        SYSTEM.GET(API.MainParam + (n + 1) * SYSTEM.SIZE(INTEGER), ptr);
        REPEAT
            SYSTEM.GET(ptr, c);
            s[i] := c;
            INC(i);
            INC(ptr)
        UNTIL (c = 0X) OR (i = len)
    END;
    s[i] := 0X
END GetArg;
 
 
PROCEDURE GetCurrentDirectory* (VAR path: ARRAY OF CHAR);
VAR
    n: INTEGER;
 
BEGIN
    GetArg(0, path);
    n := LENGTH(path) - 1;
    WHILE path[n] # slash DO
        DEC(n)
    END;
    path[n + 1] := 0X
END GetCurrentDirectory;
 
 
 
 
 
 
 
 
 
 
 
 
PROCEDURE FileRead* (F: INTEGER; VAR Buffer: ARRAY OF CHAR; bytes: INTEGER): INTEGER;
VAR
    res: INTEGER;
 
BEGIN
    res := API.fread(SYSTEM.ADR(Buffer[0]), 1, bytes, F);
    IF res <= 0 THEN
        res := -1
    END
 
    RETURN res
END FileRead;
 
 
PROCEDURE FileWrite* (F: INTEGER; Buffer: ARRAY OF BYTE; bytes: INTEGER): INTEGER;
VAR
    res: INTEGER;
 
BEGIN
    res := API.fwrite(SYSTEM.ADR(Buffer[0]), 1, bytes, F);
    IF res <= 0 THEN
        res := -1
    END
 
    RETURN res
END FileWrite;
 
 
PROCEDURE FileCreate* (FName: ARRAY OF CHAR): INTEGER;
    RETURN API.fopen(SYSTEM.ADR(FName[0]), SYSTEM.SADR("wb"))
END FileCreate;
 
 
PROCEDURE FileClose* (File: INTEGER);
BEGIN
    File := API.fclose(File)
END FileClose;
 
 
PROCEDURE FileOpen* (FName: ARRAY OF CHAR): INTEGER;
    RETURN API.fopen(SYSTEM.ADR(FName[0]), SYSTEM.SADR("rb"))
END FileOpen;
 
 
PROCEDURE OutChar* (c: CHAR);
BEGIN
    API.putc(c)
END OutChar;
 
 
PROCEDURE GetTickCount* (): INTEGER;
VAR
    tp:  API.TP;
    res: INTEGER;
 
BEGIN
    IF API.clock_gettime(0, tp) = 0 THEN
        res := tp[0] * 100 + tp[1] DIV 10000000
    ELSE
        res := 0
    END
 
    RETURN res
END GetTickCount;
 
 
PROCEDURE isRelative* (path: ARRAY OF CHAR): BOOLEAN;
    RETURN path[0] # slash
END isRelative;
 
 
PROCEDURE now* (VAR year, month, day, hour, min, sec: INTEGER);
END now;
 
 
PROCEDURE UnixTime* (): INTEGER;
    RETURN API.time(0)
END UnixTime;
 
 
PROCEDURE splitf* (x: REAL; VAR a, b: INTEGER): INTEGER;
VAR
    res: INTEGER;
 
BEGIN
    a := 0;
    b := 0;
    SYSTEM.MOVE(SYSTEM.ADR(x), SYSTEM.ADR(a), 4);
    SYSTEM.MOVE(SYSTEM.ADR(x) + 4, SYSTEM.ADR(b), 4);
    SYSTEM.GET(SYSTEM.ADR(x), res)
    RETURN res
END splitf;
 
 
BEGIN
    eol := 0AX;
    SYSTEM.GET(API.MainParam, argc)
END HOST.

Rev 7597	Rev 7696
1	(*	1	(*
2	BSD 2-Clause License	2	BSD 2-Clause License
3		3
4	Copyright (c) 2019, Anton Krotov	4	Copyright (c) 2019, Anton Krotov
5	All rights reserved.	5	All rights reserved.
6	*)	6	*)
7		7
8	MODULE HOST;	8	MODULE HOST;
9		9
10	IMPORT SYSTEM, API, RTL;	10	IMPORT SYSTEM, API, RTL;
11		11
12		12
13	CONST	13	CONST
14		14
15	slash* = "/";	15	slash* = "/";
16	OS* = "LINUX";	16	OS* = "LINUX";
17		17
18	bit_depth* = RTL.bit_depth;	18	bit_depth* = RTL.bit_depth;
19	maxint* = RTL.maxint;	19	maxint* = RTL.maxint;
20	minint* = RTL.minint;	20	minint* = RTL.minint;
21		21
22		22
23	VAR	23	VAR
24		24
25	argc: INTEGER;	25	argc: INTEGER;
26		26
27	eol*: ARRAY 2 OF CHAR;	27	eol*: ARRAY 2 OF CHAR;
28		28
29		29
30	PROCEDURE ExitProcess* (code: INTEGER);	30	PROCEDURE ExitProcess* (code: INTEGER);
31	BEGIN	31	BEGIN
32	API.exit(code)	32	API.exit(code)
33	END ExitProcess;	33	END ExitProcess;
34		34
35		35
36	PROCEDURE GetArg* (n: INTEGER; VAR s: ARRAY OF CHAR);	36	PROCEDURE GetArg* (n: INTEGER; VAR s: ARRAY OF CHAR);
37	VAR	37	VAR
38	i, len, ptr: INTEGER;	38	i, len, ptr: INTEGER;
39	c: CHAR;	39	c: CHAR;
40		40
41	BEGIN	41	BEGIN
42	i := 0;	42	i := 0;
43	len := LEN(s) - 1;	43	len := LEN(s) - 1;
44	IF (n < argc) & (len > 0) THEN	44	IF (n < argc) & (len > 0) THEN
45	SYSTEM.GET(API.MainParam + (n + 1) * SYSTEM.SIZE(INTEGER), ptr);	45	SYSTEM.GET(API.MainParam + (n + 1) * SYSTEM.SIZE(INTEGER), ptr);
46	REPEAT	46	REPEAT
47	SYSTEM.GET(ptr, c);	47	SYSTEM.GET(ptr, c);
48	s[i] := c;	48	s[i] := c;
49	INC(i);	49	INC(i);
50	INC(ptr)	50	INC(ptr)
51	UNTIL (c = 0X) OR (i = len)	51	UNTIL (c = 0X) OR (i = len)
52	END;	52	END;
53	s[i] := 0X	53	s[i] := 0X
54	END GetArg;	54	END GetArg;
55		55
56		56
57	PROCEDURE GetCurrentDirectory* (VAR path: ARRAY OF CHAR);	57	PROCEDURE GetCurrentDirectory* (VAR path: ARRAY OF CHAR);
58	VAR	58	VAR
59	n: INTEGER;	59	n: INTEGER;
60		60
61	BEGIN	61	BEGIN
62	GetArg(0, path);	62	GetArg(0, path);
63	n := LENGTH(path) - 1;	63	n := LENGTH(path) - 1;
64	WHILE path[n] # slash DO	64	WHILE path[n] # slash DO
65	DEC(n)	65	DEC(n)
66	END;	66	END;
67	path[n + 1] := 0X	67	path[n + 1] := 0X
68	END GetCurrentDirectory;	68	END GetCurrentDirectory;
69		69
70		-
71	PROCEDURE ReadFile (F: INTEGER; VAR Buffer: ARRAY OF BYTE; bytes: INTEGER): INTEGER;	-
72	RETURN API.fread(SYSTEM.ADR(Buffer[0]), 1, bytes, F)	-
73	END ReadFile;	-
74		-
75		-
76	PROCEDURE WriteFile (F: INTEGER; Buffer: ARRAY OF BYTE; bytes: INTEGER): INTEGER;	-
77	RETURN API.fwrite(SYSTEM.ADR(Buffer[0]), 1, bytes, F)	-
78	END WriteFile;	-
79		-
80		70
81	PROCEDURE FileRead* (F: INTEGER; VAR Buffer: ARRAY OF BYTE; bytes: INTEGER): INTEGER;	71	PROCEDURE FileRead* (F: INTEGER; VAR Buffer: ARRAY OF CHAR; bytes: INTEGER): INTEGER;
82	VAR	72	VAR
83	res: INTEGER;	73	res: INTEGER;
84		74
85	BEGIN	75	BEGIN
86	res := ReadFile(F, Buffer, bytes);	76	res := API.fread(SYSTEM.ADR(Buffer[0]), 1, bytes, F);
87	IF res <= 0 THEN	77	IF res <= 0 THEN
88	res := -1	78	res := -1
89	END	79	END
90		80
91	RETURN res	81	RETURN res
92	END FileRead;	82	END FileRead;
93		83
94		84
95	PROCEDURE FileWrite* (F: INTEGER; Buffer: ARRAY OF BYTE; bytes: INTEGER): INTEGER;	85	PROCEDURE FileWrite* (F: INTEGER; Buffer: ARRAY OF BYTE; bytes: INTEGER): INTEGER;
96	VAR	86	VAR
97	res: INTEGER;	87	res: INTEGER;
98		88
99	BEGIN	89	BEGIN
100	res := WriteFile(F, Buffer, bytes);	90	res := API.fwrite(SYSTEM.ADR(Buffer[0]), 1, bytes, F);
101	IF res <= 0 THEN	91	IF res <= 0 THEN
102	res := -1	92	res := -1
103	END	93	END
104		94
105	RETURN res	95	RETURN res
106	END FileWrite;	96	END FileWrite;
107		97
108		98
109	PROCEDURE FileCreate* (FName: ARRAY OF CHAR): INTEGER;	99	PROCEDURE FileCreate* (FName: ARRAY OF CHAR): INTEGER;
110	RETURN API.fopen(SYSTEM.ADR(FName[0]), SYSTEM.SADR("wb"))	100	RETURN API.fopen(SYSTEM.ADR(FName[0]), SYSTEM.SADR("wb"))
111	END FileCreate;	101	END FileCreate;
112		102
113		103
114	PROCEDURE FileClose* (File: INTEGER);	104	PROCEDURE FileClose* (File: INTEGER);
115	BEGIN	105	BEGIN
116	File := API.fclose(File)	106	File := API.fclose(File)
117	END FileClose;	107	END FileClose;
118		108
119		109
120	PROCEDURE FileOpen* (FName: ARRAY OF CHAR): INTEGER;	110	PROCEDURE FileOpen* (FName: ARRAY OF CHAR): INTEGER;
121	RETURN API.fopen(SYSTEM.ADR(FName[0]), SYSTEM.SADR("rb"))	111	RETURN API.fopen(SYSTEM.ADR(FName[0]), SYSTEM.SADR("rb"))
122	END FileOpen;	112	END FileOpen;
123		113
124		114
125	PROCEDURE OutChar* (c: CHAR);	115	PROCEDURE OutChar* (c: CHAR);
126	BEGIN	116	BEGIN
127	API.putc(c)	117	API.putc(c)
128	END OutChar;	118	END OutChar;
129		119
130		120
131	PROCEDURE GetTickCount* (): INTEGER;	121	PROCEDURE GetTickCount* (): INTEGER;
132	VAR	122	VAR
133	tp: API.TP;	123	tp: API.TP;
134	res: INTEGER;	124	res: INTEGER;
135		125
136	BEGIN	126	BEGIN
137	IF API.clock_gettime(0, tp) = 0 THEN	127	IF API.clock_gettime(0, tp) = 0 THEN
138	res := tp[0] * 100 + tp[1] DIV 10000000	128	res := tp[0] * 100 + tp[1] DIV 10000000
139	ELSE	129	ELSE
140	res := 0	130	res := 0
141	END	131	END
142		132
143	RETURN res	133	RETURN res
144	END GetTickCount;	134	END GetTickCount;
145		135
146		136
147	PROCEDURE isRelative* (path: ARRAY OF CHAR): BOOLEAN;	137	PROCEDURE isRelative* (path: ARRAY OF CHAR): BOOLEAN;
148	RETURN path[0] # slash	138	RETURN path[0] # slash
149	END isRelative;	139	END isRelative;
150		140
151		141
152	PROCEDURE now* (VAR year, month, day, hour, min, sec: INTEGER);	142	PROCEDURE now* (VAR year, month, day, hour, min, sec: INTEGER);
153	END now;	143	END now;
154		144
155		145
156	PROCEDURE UnixTime* (): INTEGER;	146	PROCEDURE UnixTime* (): INTEGER;
157	RETURN API.time(0)	147	RETURN API.time(0)
158	END UnixTime;	148	END UnixTime;
159		149
160		150
161	PROCEDURE splitf* (x: REAL; VAR a, b: INTEGER): INTEGER;	151	PROCEDURE splitf* (x: REAL; VAR a, b: INTEGER): INTEGER;
162	VAR	152	VAR
163	res: INTEGER;	153	res: INTEGER;
164		154
165	BEGIN	155	BEGIN
166	a := 0;	156	a := 0;
167	b := 0;	157	b := 0;
168	SYSTEM.MOVE(SYSTEM.ADR(x), SYSTEM.ADR(a), 4);	158	SYSTEM.MOVE(SYSTEM.ADR(x), SYSTEM.ADR(a), 4);
169	SYSTEM.MOVE(SYSTEM.ADR(x) + 4, SYSTEM.ADR(b), 4);	159	SYSTEM.MOVE(SYSTEM.ADR(x) + 4, SYSTEM.ADR(b), 4);
170	SYSTEM.GET(SYSTEM.ADR(x), res)	160	SYSTEM.GET(SYSTEM.ADR(x), res)
171	RETURN res	161	RETURN res
172	END splitf;	162	END splitf;
173		163
174		164
175	BEGIN	165	BEGIN
176	eol := 0AX;	166	eol := 0AX;
177	SYSTEM.GET(API.MainParam, argc)	167	SYSTEM.GET(API.MainParam, argc)
178	END HOST.	168	END HOST.

Subversion Repositories Kolibri OS

(root)/programs/develop/oberon07/Lib/Linux32/HOST.ob07 – Rev 7597 → 7696