WebSVN – Kolibri OS – Diff – /programs/develop/oberon07/Lib/KolibriOS/Vector.ob07


﻿(*
    Copyright 2016 Anton Krotov
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    along with this program.  If not, see .
*)
 
MODULE Vector;
 
 
IMPORT sys := SYSTEM, K := KOSAPI;
 
 
TYPE
 
  DESC_VECTOR = RECORD
 
    data   : INTEGER;
    count  : INTEGER;
    size   : INTEGER
 
  END;
 
  VECTOR* = POINTER TO DESC_VECTOR;
 
  ANYREC* = RECORD END;
 
  ANYPTR* = POINTER TO ANYREC;
 
  DESTRUCTOR* = PROCEDURE (VAR ptr: ANYPTR);
 
 
PROCEDURE count* (vector: VECTOR): INTEGER;
BEGIN
  ASSERT(vector # NIL)
  RETURN vector.count
END count;
 
 
PROCEDURE push* (vector: VECTOR; value: ANYPTR);
BEGIN
  ASSERT(vector # NIL);
  IF vector.count = vector.size THEN
    vector.data := K.realloc(vector.data, (vector.size + 1024) * 4);
    ASSERT(vector.data # 0);
    vector.size := vector.size + 1024
  END;
  sys.PUT(vector.data + vector.count * 4, value);
  INC(vector.count)
END push;
 
 
PROCEDURE get* (vector: VECTOR; idx: INTEGER): ANYPTR;
VAR res: ANYPTR;
BEGIN
  ASSERT(vector # NIL);
  ASSERT( (0 <= idx) & (idx < vector.count) );
  sys.GET(vector.data + idx * 4, res)
  RETURN res
END get;
 
 
PROCEDURE put* (vector: VECTOR; idx: INTEGER; value: ANYPTR);
BEGIN
  ASSERT(vector # NIL);
  ASSERT( (0 <= idx) & (idx < vector.count) );
  sys.PUT(vector.data + idx * 4, value)
END put;
 
 
PROCEDURE create* (size: INTEGER): VECTOR;
VAR vector: VECTOR;
BEGIN
  NEW(vector);
  IF vector # NIL THEN
    vector.data  := K.malloc(4 * size);
    IF vector.data # 0 THEN
      vector.size  := size;
      vector.count := 0
    ELSE
      DISPOSE(vector)
    END
  END
  RETURN vector
END create;
 
 
PROCEDURE def_destructor (VAR any: ANYPTR);
BEGIN
  DISPOSE(any)
END def_destructor;
 
 
PROCEDURE destroy* (VAR vector: VECTOR; destructor: DESTRUCTOR);
VAR i: INTEGER;
    any: ANYPTR;
BEGIN
  ASSERT(vector # NIL);
  IF destructor = NIL THEN
    destructor := def_destructor
  END;
  FOR i := 0 TO vector.count - 1 DO
    any := get(vector, i);
    destructor(any)
  END;
  vector.data := K.free(vector.data);
  DISPOSE(vector)
END destroy;
 
 
END Vector.

Rev 6755	Rev 7693
1	(*	1	(*
2	Copyright 2016 Anton Krotov	2	Copyright 2016 Anton Krotov
3		3
4	This program is free software: you can redistribute it and/or modify	4	This program is free software: you can redistribute it and/or modify
5	it under the terms of the GNU Lesser General Public License as published by	5	it under the terms of the GNU Lesser General Public License as published by
6	the Free Software Foundation, either version 3 of the License, or	6	the Free Software Foundation, either version 3 of the License, or
7	(at your option) any later version.	7	(at your option) any later version.
8		8
9	This program is distributed in the hope that it will be useful,	9	This program is distributed in the hope that it will be useful,
10	but WITHOUT ANY WARRANTY; without even the implied warranty of	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	GNU Lesser General Public License for more details.	12	GNU Lesser General Public License for more details.
13		13
14	You should have received a copy of the GNU Lesser General Public License	14	You should have received a copy of the GNU Lesser General Public License
15	along with this program. If not, see .	15	along with this program. If not, see .
16	*)	16	*)
17		17
18	MODULE Vector;	18	MODULE Vector;
19		19
20		20
21	IMPORT sys := SYSTEM, K := KOSAPI;	21	IMPORT sys := SYSTEM, K := KOSAPI;
22		22
23		23
24	TYPE	24	TYPE
25		25
26	DESC_VECTOR = RECORD	26	DESC_VECTOR = RECORD
27		27
28	data : INTEGER;	28	data : INTEGER;
29	count : INTEGER;	29	count : INTEGER;
30	size : INTEGER	30	size : INTEGER
31		31
32	END;	32	END;
33		33
34	VECTOR* = POINTER TO DESC_VECTOR;	34	VECTOR* = POINTER TO DESC_VECTOR;
35		35
36	ANYREC* = RECORD END;	36	ANYREC* = RECORD END;
37		37
38	ANYPTR* = POINTER TO ANYREC;	38	ANYPTR* = POINTER TO ANYREC;
39		39
40	DESTRUCTOR* = PROCEDURE (VAR ptr: ANYPTR);	40	DESTRUCTOR* = PROCEDURE (VAR ptr: ANYPTR);
41		41
42		42
43	PROCEDURE count* (vector: VECTOR): INTEGER;	43	PROCEDURE count* (vector: VECTOR): INTEGER;
44	BEGIN	44	BEGIN
45	ASSERT(vector # NIL)	45	ASSERT(vector # NIL)
46	RETURN vector.count	46	RETURN vector.count
47	END count;	47	END count;
48		48
49		49
50	PROCEDURE push* (vector: VECTOR; value: ANYPTR);	50	PROCEDURE push* (vector: VECTOR; value: ANYPTR);
51	BEGIN	51	BEGIN
52	ASSERT(vector # NIL);	52	ASSERT(vector # NIL);
53	IF vector.count = vector.size THEN	53	IF vector.count = vector.size THEN
54	vector.data := K.realloc(vector.data, (vector.size + 1024) * 4);	54	vector.data := K.realloc(vector.data, (vector.size + 1024) * 4);
55	ASSERT(vector.data # 0);	55	ASSERT(vector.data # 0);
56	vector.size := vector.size + 1024	56	vector.size := vector.size + 1024
57	END;	57	END;
58	sys.PUT(vector.data + vector.count * 4, value);	58	sys.PUT(vector.data + vector.count * 4, value);
59	INC(vector.count)	59	INC(vector.count)
60	END push;	60	END push;
61		61
62		62
63	PROCEDURE get* (vector: VECTOR; idx: INTEGER): ANYPTR;	63	PROCEDURE get* (vector: VECTOR; idx: INTEGER): ANYPTR;
64	VAR res: ANYPTR;	64	VAR res: ANYPTR;
65	BEGIN	65	BEGIN
66	ASSERT(vector # NIL);	66	ASSERT(vector # NIL);
67	ASSERT( (0 <= idx) & (idx < vector.count) );	67	ASSERT( (0 <= idx) & (idx < vector.count) );
68	sys.GET(vector.data + idx * 4, res)	68	sys.GET(vector.data + idx * 4, res)
69	RETURN res	69	RETURN res
70	END get;	70	END get;
71		71
72		72
73	PROCEDURE put* (vector: VECTOR; idx: INTEGER; value: ANYPTR);	73	PROCEDURE put* (vector: VECTOR; idx: INTEGER; value: ANYPTR);
74	BEGIN	74	BEGIN
75	ASSERT(vector # NIL);	75	ASSERT(vector # NIL);
76	ASSERT( (0 <= idx) & (idx < vector.count) );	76	ASSERT( (0 <= idx) & (idx < vector.count) );
77	sys.PUT(vector.data + idx * 4, value)	77	sys.PUT(vector.data + idx * 4, value)
78	END put;	78	END put;
79		79
80		80
81	PROCEDURE create* (size: INTEGER): VECTOR;	81	PROCEDURE create* (size: INTEGER): VECTOR;
82	VAR vector: VECTOR;	82	VAR vector: VECTOR;
83	BEGIN	83	BEGIN
84	NEW(vector);	84	NEW(vector);
85	IF vector # NIL THEN	85	IF vector # NIL THEN
86	vector.data := K.malloc(4 * size);	86	vector.data := K.malloc(4 * size);
87	IF vector.data # 0 THEN	87	IF vector.data # 0 THEN
88	vector.size := size;	88	vector.size := size;
89	vector.count := 0	89	vector.count := 0
90	ELSE	90	ELSE
91	DISPOSE(vector)	91	DISPOSE(vector)
92	END	92	END
93	END	93	END
94	RETURN vector	94	RETURN vector
95	END create;	95	END create;
96		96
97		97
98	PROCEDURE def_destructor (VAR any: ANYPTR);	98	PROCEDURE def_destructor (VAR any: ANYPTR);
99	BEGIN	99	BEGIN
100	DISPOSE(any)	100	DISPOSE(any)
101	END def_destructor;	101	END def_destructor;
102		102
103		103
104	PROCEDURE destroy* (VAR vector: VECTOR; destructor: DESTRUCTOR);	104	PROCEDURE destroy* (VAR vector: VECTOR; destructor: DESTRUCTOR);
105	VAR i: INTEGER;	105	VAR i: INTEGER;
106	any: ANYPTR;	106	any: ANYPTR;
107	BEGIN	107	BEGIN
108	ASSERT(vector # NIL);	108	ASSERT(vector # NIL);
109	IF destructor = NIL THEN	109	IF destructor = NIL THEN
110	destructor := def_destructor	110	destructor := def_destructor
111	END;	111	END;
112	FOR i := 0 TO vector.count - 1 DO	112	FOR i := 0 TO vector.count - 1 DO
113	any := get(vector, i);	113	any := get(vector, i);
114	destructor(any)	114	destructor(any)
115	END;	115	END;
116	vector.data := K.free(vector.data);	116	vector.data := K.free(vector.data);
117	DISPOSE(vector)	117	DISPOSE(vector)
118	END destroy;	118	END destroy;
119		119
120		120
121	END Vector.	121	END Vector.

Subversion Repositories Kolibri OS

(root)/programs/develop/oberon07/Lib/KolibriOS/Vector.ob07 – Rev 6755 → 7693