]> git.zerfleddert.de Git - micropolis/blame_incremental - src/tk/tkpresrv.c
src/sim/makefile: Micropolis build fixes for recent macOS
[micropolis] / src / tk / tkpresrv.c
... / ...
CommitLineData
1/*
2 * tkPreserve.c --
3 *
4 * This file contains a collection of procedures that are used
5 * to make sure that widget records and other data structures
6 * aren't reallocated when there are nested procedures that
7 * depend on their existence.
8 *
9 * Copyright 1991 Regents of the University of California
10 * Permission to use, copy, modify, and distribute this
11 * software and its documentation for any purpose and without
12 * fee is hereby granted, provided that this copyright
13 * notice appears in all copies. The University of California
14 * makes no representations about the suitability of this
15 * software for any purpose. It is provided "as is" without
16 * express or implied warranty.
17 */
18
19#ifndef lint
20static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkPreserve.c,v 1.6 92/06/15 13:44:51 ouster Exp $ SPRITE (Berkeley)";
21#endif /* not lint */
22
23#include "tkconfig.h"
24#include "tk.h"
25
26/*
27 * The following data structure is used to keep track of all the
28 * Tk_Preserve calls that are still in effect. It grows as needed
29 * to accommodate any number of calls in effect.
30 */
31
32typedef struct {
33 ClientData clientData; /* Address of preserved block. */
34 int refCount; /* Number of Tk_Preserve calls in effect
35 * for block. */
36 int mustFree; /* Non-zero means Tk_EventuallyFree was
37 * called while a Tk_Preserve call was in
38 * effect, so the structure must be freed
39 * when refCount becomes zero. */
40 Tk_FreeProc *freeProc; /* Procedure to call to free. */
41} Reference;
42
43static Reference *refArray; /* First in array of references. */
44static int spaceAvl = 0; /* Total number of structures available
45 * at *firstRefPtr. */
46static int inUse = 0; /* Count of structures currently in use
47 * in refArray. */
48#define INITIAL_SIZE 2
49\f
50/*
51 *----------------------------------------------------------------------
52 *
53 * Tk_Preserve --
54 *
55 * This procedure is used by a procedure to declare its interest
56 * in a particular block of memory, so that the block will not be
57 * reallocated until a matching call to Tk_Release has been made.
58 *
59 * Results:
60 * None.
61 *
62 * Side effects:
63 * Information is retained so that the block of memory will
64 * not be freed until at least the matching call to Tk_Release.
65 *
66 *----------------------------------------------------------------------
67 */
68
69void
70Tk_Preserve(clientData)
71 ClientData clientData; /* Pointer to malloc'ed block of memory. */
72{
73 register Reference *refPtr;
74 int i;
75
76 /*
77 * See if there is already a reference for this pointer. If so,
78 * just increment its reference count.
79 */
80
81 for (i = 0, refPtr = refArray; i < inUse; i++, refPtr++) {
82 if (refPtr->clientData == clientData) {
83 refPtr->refCount++;
84 return;
85 }
86 }
87
88 /*
89 * Make a reference array if it doesn't already exist, or make it
90 * bigger if it is full.
91 */
92
93 if (inUse == spaceAvl) {
94 if (spaceAvl == 0) {
95 refArray = (Reference *) ckalloc((unsigned)
96 (INITIAL_SIZE*sizeof(Reference)));
97 spaceAvl = INITIAL_SIZE;
98 } else {
99 Reference *new;
100
101 new = (Reference *) ckalloc((unsigned)
102 (2*spaceAvl*sizeof(Reference)));
103 memcpy((VOID *) new, (VOID *) refArray, spaceAvl*sizeof(Reference));
104 ckfree((char *) refArray);
105 refArray = new;
106 spaceAvl *= 2;
107 }
108 }
109
110 /*
111 * Make a new entry for the new reference.
112 */
113
114 refPtr = &refArray[inUse];
115 refPtr->clientData = clientData;
116 refPtr->refCount = 1;
117 refPtr->mustFree = 0;
118 inUse += 1;
119}
120\f
121/*
122 *----------------------------------------------------------------------
123 *
124 * Tk_Release --
125 *
126 * This procedure is called to cancel a previous call to
127 * Tk_Preserve, thereby allowing a block of memory to be
128 * freed (if no one else cares about it).
129 *
130 * Results:
131 * None.
132 *
133 * Side effects:
134 * If Tk_EventuallyFree has been called for clientData, and if
135 * no other call to Tk_Preserve is still in effect, the block of
136 * memory is freed.
137 *
138 *----------------------------------------------------------------------
139 */
140
141void
142Tk_Release(clientData)
143 ClientData clientData; /* Pointer to malloc'ed block of memory. */
144{
145 register Reference *refPtr;
146 int i;
147
148 for (i = 0, refPtr = refArray; i < inUse; i++, refPtr++) {
149 if (refPtr->clientData != clientData) {
150 continue;
151 }
152 refPtr->refCount--;
153 if (refPtr->refCount == 0) {
154 if (refPtr->mustFree) {
155 if (refPtr->freeProc == (Tk_FreeProc *) free) {
156 ckfree((char *) refPtr->clientData);
157 } else {
158 (*refPtr->freeProc)(refPtr->clientData);
159 }
160 }
161
162 /*
163 * Copy down all of the trailing reference in the array
164 * to cover up the hole left by the unused reference.
165 */
166
167 inUse--;
168 if (i != inUse) {
169 memcpy((VOID *) &refArray[i], (VOID *) &refArray[i+1],
170 (inUse-i)*sizeof(Reference));
171 }
172 }
173 return;
174 }
175
176 /*
177 * Reference not found. This is a bug in the caller.
178 */
179
180 panic("Tk_Release couldn't find reference for 0x%x", clientData);
181}
182\f
183/*
184 *----------------------------------------------------------------------
185 *
186 * Tk_EventuallyFree --
187 *
188 * Free up a block of memory, unless a call to Tk_Preserve is in
189 * effect for that block. In this case, defer the free until all
190 * calls to Tk_Preserve have been undone by matching calls to
191 * Tk_Release.
192 *
193 * Results:
194 * None.
195 *
196 * Side effects:
197 * Ptr may be released by calling free().
198 *
199 *----------------------------------------------------------------------
200 */
201
202void
203Tk_EventuallyFree(clientData, freeProc)
204 ClientData clientData; /* Pointer to malloc'ed block of memory. */
205 Tk_FreeProc *freeProc; /* Procedure to actually do free. */
206{
207 register Reference *refPtr;
208 int i;
209
210 /*
211 * See if there is a reference for this pointer. If so, set its
212 * "mustFree" flag (the flag had better not be set already!).
213 */
214
215 for (i = 0, refPtr = refArray; i < inUse; i++, refPtr++) {
216 if (refPtr->clientData != clientData) {
217 continue;
218 }
219 if (refPtr->mustFree) {
220 panic("Tk_EventuallyFree called twice for 0x%x\n", clientData);
221 }
222 refPtr->mustFree = 1;
223 refPtr->freeProc = freeProc;
224 return;
225 }
226
227 /*
228 * No reference for this block. Free it now.
229 */
230
231 if (freeProc == (Tk_FreeProc *) free) {
232 ckfree((char *) clientData);
233 } else {
234 (*freeProc)(clientData);
235 }
236}
Impressum, Datenschutz