Mercurial > emacs
annotate src/alloca.c @ 33935:0134e496cf07
*** empty log message ***
author | Miles Bader <miles@gnu.org> |
---|---|
date | Tue, 28 Nov 2000 05:11:20 +0000 |
parents | fa7ad139efa1 |
children | 8fa658f7a17a |
rev | line source |
---|---|
2746 | 1 /* alloca.c -- allocate automatically reclaimed memory |
2 (Mostly) portable public-domain implementation -- D A Gwyn | |
3 | |
4 This implementation of the PWB library alloca function, | |
5 which is used to allocate space off the run-time stack so | |
6 that it is automatically reclaimed upon procedure exit, | |
7 was inspired by discussions with J. Q. Johnson of Cornell. | |
8 J.Otto Tennant <jot@cray.com> contributed the Cray support. | |
9 | |
10 There are some preprocessor constants that can | |
11 be defined when compiling for your specific system, for | |
12 improved efficiency; however, the defaults should be okay. | |
13 | |
14 The general concept of this implementation is to keep | |
15 track of all alloca-allocated blocks, and reclaim any | |
16 that are found to be deeper in the stack than the current | |
17 invocation. This heuristic does not reclaim storage as | |
18 soon as it becomes invalid, but it will do so eventually. | |
19 | |
20 As a special case, alloca(0) reclaims storage without | |
21 allocating any. It is a good idea to use alloca(0) in | |
22 your main control loop, etc. to force garbage collection. */ | |
23 | |
24 #ifdef HAVE_CONFIG_H | |
4686 | 25 #include <config.h> |
2746 | 26 #endif |
27 | |
14844
885968b5998e
[HAVE_STRING_H]: Include string.h.
Roland McGrath <roland@gnu.org>
parents:
14050
diff
changeset
|
28 #ifdef HAVE_STRING_H |
885968b5998e
[HAVE_STRING_H]: Include string.h.
Roland McGrath <roland@gnu.org>
parents:
14050
diff
changeset
|
29 #include <string.h> |
885968b5998e
[HAVE_STRING_H]: Include string.h.
Roland McGrath <roland@gnu.org>
parents:
14050
diff
changeset
|
30 #endif |
885968b5998e
[HAVE_STRING_H]: Include string.h.
Roland McGrath <roland@gnu.org>
parents:
14050
diff
changeset
|
31 #ifdef HAVE_STDLIB_H |
885968b5998e
[HAVE_STRING_H]: Include string.h.
Roland McGrath <roland@gnu.org>
parents:
14050
diff
changeset
|
32 #include <stdlib.h> |
885968b5998e
[HAVE_STRING_H]: Include string.h.
Roland McGrath <roland@gnu.org>
parents:
14050
diff
changeset
|
33 #endif |
885968b5998e
[HAVE_STRING_H]: Include string.h.
Roland McGrath <roland@gnu.org>
parents:
14050
diff
changeset
|
34 |
7767
5be3332469e7
[emacs]: Block input around the garbage reclamation.
Richard M. Stallman <rms@gnu.org>
parents:
4753
diff
changeset
|
35 #ifdef emacs |
30032
53eb5de09ac4
[emacs]: Include lisp.h (needed by atimer.h included
Andrew Innes <andrewi@gnu.org>
parents:
15593
diff
changeset
|
36 #include "lisp.h" |
7767
5be3332469e7
[emacs]: Block input around the garbage reclamation.
Richard M. Stallman <rms@gnu.org>
parents:
4753
diff
changeset
|
37 #include "blockinput.h" |
5be3332469e7
[emacs]: Block input around the garbage reclamation.
Richard M. Stallman <rms@gnu.org>
parents:
4753
diff
changeset
|
38 #endif |
5be3332469e7
[emacs]: Block input around the garbage reclamation.
Richard M. Stallman <rms@gnu.org>
parents:
4753
diff
changeset
|
39 |
4557 | 40 /* If compiling with GCC 2, this file's not needed. */ |
4646 | 41 #if !defined (__GNUC__) || __GNUC__ < 2 |
42 | |
4557 | 43 /* If someone has defined alloca as a macro, |
44 there must be some other way alloca is supposed to work. */ | |
2746 | 45 #ifndef alloca |
46 | |
47 #ifdef emacs | |
48 #ifdef static | |
49 /* actually, only want this if static is defined as "" | |
50 -- this is for usg, in which emacs must undefine static | |
51 in order to make unexec workable | |
52 */ | |
53 #ifndef STACK_DIRECTION | |
30913 | 54 #error "Must know STACK_DIRECTION at compile-time" |
2746 | 55 #endif /* STACK_DIRECTION undefined */ |
56 #endif /* static */ | |
57 #endif /* emacs */ | |
58 | |
59 /* If your stack is a linked list of frames, you have to | |
60 provide an "address metric" ADDRESS_FUNCTION macro. */ | |
61 | |
4073 | 62 #if defined (CRAY) && defined (CRAY_STACKSEG_END) |
2746 | 63 long i00afunc (); |
64 #define ADDRESS_FUNCTION(arg) (char *) i00afunc (&(arg)) | |
65 #else | |
66 #define ADDRESS_FUNCTION(arg) &(arg) | |
67 #endif | |
68 | |
30913 | 69 #ifdef POINTER_TYPE |
70 typedef POINTER_TYPE *pointer; | |
71 #else | |
2746 | 72 #if __STDC__ |
73 typedef void *pointer; | |
74 #else | |
75 typedef char *pointer; | |
30913 | 76 #endif /*__STDC__*/ |
77 #endif /*POINTER_TYPE*/ | |
78 | |
2746 | 79 |
14845
fce6bf9ce9b0
(NULL): Define only if not already defined.
Roland McGrath <roland@gnu.org>
parents:
14844
diff
changeset
|
80 #ifndef NULL |
2746 | 81 #define NULL 0 |
14845
fce6bf9ce9b0
(NULL): Define only if not already defined.
Roland McGrath <roland@gnu.org>
parents:
14844
diff
changeset
|
82 #endif |
2746 | 83 |
3019 | 84 /* Different portions of Emacs need to call different versions of |
85 malloc. The Emacs executable needs alloca to call xmalloc, because | |
86 ordinary malloc isn't protected from input signals. On the other | |
87 hand, the utilities in lib-src need alloca to call malloc; some of | |
88 them are very simple, and don't have an xmalloc routine. | |
89 | |
3044
81c1ecaafd88
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
3019
diff
changeset
|
90 Non-Emacs programs expect this to call use xmalloc. |
81c1ecaafd88
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
3019
diff
changeset
|
91 |
81c1ecaafd88
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
3019
diff
changeset
|
92 Callers below should use malloc. */ |
81c1ecaafd88
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
3019
diff
changeset
|
93 |
30233
1e2f2a050a93
(malloc) [emacs]: Define as xmalloc.
Gerd Moellmann <gerd@gnu.org>
parents:
30032
diff
changeset
|
94 #ifdef emacs |
3044
81c1ecaafd88
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
3019
diff
changeset
|
95 #define malloc xmalloc |
30289
60a78156cc87
(free) [emacs && EMACS_FREE]: Define as EMACS_FREE.
Gerd Moellmann <gerd@gnu.org>
parents:
30233
diff
changeset
|
96 #ifdef EMACS_FREE |
60a78156cc87
(free) [emacs && EMACS_FREE]: Define as EMACS_FREE.
Gerd Moellmann <gerd@gnu.org>
parents:
30233
diff
changeset
|
97 #define free EMACS_FREE |
60a78156cc87
(free) [emacs && EMACS_FREE]: Define as EMACS_FREE.
Gerd Moellmann <gerd@gnu.org>
parents:
30233
diff
changeset
|
98 #endif |
3019 | 99 #endif |
4541
8c4835a24aca
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
4073
diff
changeset
|
100 extern pointer malloc (); |
3019 | 101 |
2746 | 102 /* Define STACK_DIRECTION if you know the direction of stack |
103 growth for your system; otherwise it will be automatically | |
104 deduced at run-time. | |
105 | |
106 STACK_DIRECTION > 0 => grows toward higher addresses | |
107 STACK_DIRECTION < 0 => grows toward lower addresses | |
108 STACK_DIRECTION = 0 => direction of growth unknown */ | |
109 | |
110 #ifndef STACK_DIRECTION | |
111 #define STACK_DIRECTION 0 /* Direction unknown. */ | |
112 #endif | |
113 | |
114 #if STACK_DIRECTION != 0 | |
115 | |
116 #define STACK_DIR STACK_DIRECTION /* Known at compile-time. */ | |
117 | |
118 #else /* STACK_DIRECTION == 0; need run-time code. */ | |
119 | |
120 static int stack_dir; /* 1 or -1 once known. */ | |
121 #define STACK_DIR stack_dir | |
122 | |
123 static void | |
124 find_stack_direction () | |
125 { | |
126 static char *addr = NULL; /* Address of first `dummy', once known. */ | |
127 auto char dummy; /* To get stack address. */ | |
128 | |
129 if (addr == NULL) | |
130 { /* Initial entry. */ | |
131 addr = ADDRESS_FUNCTION (dummy); | |
132 | |
133 find_stack_direction (); /* Recurse once. */ | |
134 } | |
135 else | |
136 { | |
137 /* Second entry. */ | |
138 if (ADDRESS_FUNCTION (dummy) > addr) | |
139 stack_dir = 1; /* Stack grew upward. */ | |
140 else | |
141 stack_dir = -1; /* Stack grew downward. */ | |
142 } | |
143 } | |
144 | |
145 #endif /* STACK_DIRECTION == 0 */ | |
146 | |
147 /* An "alloca header" is used to: | |
148 (a) chain together all alloca'ed blocks; | |
149 (b) keep track of stack depth. | |
150 | |
151 It is very important that sizeof(header) agree with malloc | |
152 alignment chunk size. The following default should work okay. */ | |
153 | |
154 #ifndef ALIGN_SIZE | |
155 #define ALIGN_SIZE sizeof(double) | |
156 #endif | |
157 | |
158 typedef union hdr | |
159 { | |
160 char align[ALIGN_SIZE]; /* To force sizeof(header). */ | |
161 struct | |
162 { | |
163 union hdr *next; /* For chaining headers. */ | |
164 char *deep; /* For stack depth measure. */ | |
165 } h; | |
166 } header; | |
167 | |
168 static header *last_alloca_header = NULL; /* -> last alloca header. */ | |
169 | |
170 /* Return a pointer to at least SIZE bytes of storage, | |
171 which will be automatically reclaimed upon exit from | |
172 the procedure that called alloca. Originally, this space | |
173 was supposed to be taken from the current stack frame of the | |
174 caller, but that method cannot be made to work for some | |
175 implementations of C, for example under Gould's UTX/32. */ | |
176 | |
177 pointer | |
178 alloca (size) | |
179 unsigned size; | |
180 { | |
181 auto char probe; /* Probes stack depth: */ | |
182 register char *depth = ADDRESS_FUNCTION (probe); | |
183 | |
184 #if STACK_DIRECTION == 0 | |
185 if (STACK_DIR == 0) /* Unknown growth direction. */ | |
186 find_stack_direction (); | |
187 #endif | |
188 | |
189 /* Reclaim garbage, defined as all alloca'd storage that | |
15593 | 190 was allocated from deeper in the stack than currently. */ |
2746 | 191 |
192 { | |
193 register header *hp; /* Traverses linked list. */ | |
194 | |
7767
5be3332469e7
[emacs]: Block input around the garbage reclamation.
Richard M. Stallman <rms@gnu.org>
parents:
4753
diff
changeset
|
195 #ifdef emacs |
5be3332469e7
[emacs]: Block input around the garbage reclamation.
Richard M. Stallman <rms@gnu.org>
parents:
4753
diff
changeset
|
196 BLOCK_INPUT; |
5be3332469e7
[emacs]: Block input around the garbage reclamation.
Richard M. Stallman <rms@gnu.org>
parents:
4753
diff
changeset
|
197 #endif |
5be3332469e7
[emacs]: Block input around the garbage reclamation.
Richard M. Stallman <rms@gnu.org>
parents:
4753
diff
changeset
|
198 |
2746 | 199 for (hp = last_alloca_header; hp != NULL;) |
200 if ((STACK_DIR > 0 && hp->h.deep > depth) | |
201 || (STACK_DIR < 0 && hp->h.deep < depth)) | |
202 { | |
203 register header *np = hp->h.next; | |
204 | |
205 free ((pointer) hp); /* Collect garbage. */ | |
206 | |
207 hp = np; /* -> next header. */ | |
208 } | |
209 else | |
210 break; /* Rest are not deeper. */ | |
211 | |
212 last_alloca_header = hp; /* -> last valid storage. */ | |
7767
5be3332469e7
[emacs]: Block input around the garbage reclamation.
Richard M. Stallman <rms@gnu.org>
parents:
4753
diff
changeset
|
213 |
5be3332469e7
[emacs]: Block input around the garbage reclamation.
Richard M. Stallman <rms@gnu.org>
parents:
4753
diff
changeset
|
214 #ifdef emacs |
5be3332469e7
[emacs]: Block input around the garbage reclamation.
Richard M. Stallman <rms@gnu.org>
parents:
4753
diff
changeset
|
215 UNBLOCK_INPUT; |
5be3332469e7
[emacs]: Block input around the garbage reclamation.
Richard M. Stallman <rms@gnu.org>
parents:
4753
diff
changeset
|
216 #endif |
2746 | 217 } |
218 | |
219 if (size == 0) | |
220 return NULL; /* No allocation required. */ | |
221 | |
222 /* Allocate combined header + user data storage. */ | |
223 | |
224 { | |
2941 | 225 register pointer new = malloc (sizeof (header) + size); |
2746 | 226 /* Address of header. */ |
227 | |
14050
28df14e7a281
(alloca): If malloc fails, just abort.
Karl Heuer <kwzh@gnu.org>
parents:
9097
diff
changeset
|
228 if (new == 0) |
28df14e7a281
(alloca): If malloc fails, just abort.
Karl Heuer <kwzh@gnu.org>
parents:
9097
diff
changeset
|
229 abort(); |
28df14e7a281
(alloca): If malloc fails, just abort.
Karl Heuer <kwzh@gnu.org>
parents:
9097
diff
changeset
|
230 |
2746 | 231 ((header *) new)->h.next = last_alloca_header; |
232 ((header *) new)->h.deep = depth; | |
233 | |
234 last_alloca_header = (header *) new; | |
235 | |
236 /* User storage begins just after header. */ | |
237 | |
238 return (pointer) ((char *) new + sizeof (header)); | |
239 } | |
240 } | |
241 | |
4073 | 242 #if defined (CRAY) && defined (CRAY_STACKSEG_END) |
2746 | 243 |
244 #ifdef DEBUG_I00AFUNC | |
245 #include <stdio.h> | |
246 #endif | |
247 | |
248 #ifndef CRAY_STACK | |
249 #define CRAY_STACK | |
250 #ifndef CRAY2 | |
251 /* Stack structures for CRAY-1, CRAY X-MP, and CRAY Y-MP */ | |
252 struct stack_control_header | |
253 { | |
254 long shgrow:32; /* Number of times stack has grown. */ | |
255 long shaseg:32; /* Size of increments to stack. */ | |
256 long shhwm:32; /* High water mark of stack. */ | |
257 long shsize:32; /* Current size of stack (all segments). */ | |
258 }; | |
259 | |
260 /* The stack segment linkage control information occurs at | |
261 the high-address end of a stack segment. (The stack | |
262 grows from low addresses to high addresses.) The initial | |
263 part of the stack segment linkage control information is | |
264 0200 (octal) words. This provides for register storage | |
265 for the routine which overflows the stack. */ | |
266 | |
267 struct stack_segment_linkage | |
268 { | |
269 long ss[0200]; /* 0200 overflow words. */ | |
270 long sssize:32; /* Number of words in this segment. */ | |
271 long ssbase:32; /* Offset to stack base. */ | |
272 long:32; | |
273 long sspseg:32; /* Offset to linkage control of previous | |
274 segment of stack. */ | |
275 long:32; | |
276 long sstcpt:32; /* Pointer to task common address block. */ | |
277 long sscsnm; /* Private control structure number for | |
278 microtasking. */ | |
279 long ssusr1; /* Reserved for user. */ | |
280 long ssusr2; /* Reserved for user. */ | |
281 long sstpid; /* Process ID for pid based multi-tasking. */ | |
282 long ssgvup; /* Pointer to multitasking thread giveup. */ | |
283 long sscray[7]; /* Reserved for Cray Research. */ | |
284 long ssa0; | |
285 long ssa1; | |
286 long ssa2; | |
287 long ssa3; | |
288 long ssa4; | |
289 long ssa5; | |
290 long ssa6; | |
291 long ssa7; | |
292 long sss0; | |
293 long sss1; | |
294 long sss2; | |
295 long sss3; | |
296 long sss4; | |
297 long sss5; | |
298 long sss6; | |
299 long sss7; | |
300 }; | |
301 | |
302 #else /* CRAY2 */ | |
303 /* The following structure defines the vector of words | |
304 returned by the STKSTAT library routine. */ | |
305 struct stk_stat | |
306 { | |
307 long now; /* Current total stack size. */ | |
308 long maxc; /* Amount of contiguous space which would | |
309 be required to satisfy the maximum | |
310 stack demand to date. */ | |
311 long high_water; /* Stack high-water mark. */ | |
312 long overflows; /* Number of stack overflow ($STKOFEN) calls. */ | |
313 long hits; /* Number of internal buffer hits. */ | |
314 long extends; /* Number of block extensions. */ | |
315 long stko_mallocs; /* Block allocations by $STKOFEN. */ | |
316 long underflows; /* Number of stack underflow calls ($STKRETN). */ | |
317 long stko_free; /* Number of deallocations by $STKRETN. */ | |
318 long stkm_free; /* Number of deallocations by $STKMRET. */ | |
319 long segments; /* Current number of stack segments. */ | |
320 long maxs; /* Maximum number of stack segments so far. */ | |
321 long pad_size; /* Stack pad size. */ | |
322 long current_address; /* Current stack segment address. */ | |
323 long current_size; /* Current stack segment size. This | |
324 number is actually corrupted by STKSTAT to | |
325 include the fifteen word trailer area. */ | |
326 long initial_address; /* Address of initial segment. */ | |
327 long initial_size; /* Size of initial segment. */ | |
328 }; | |
329 | |
330 /* The following structure describes the data structure which trails | |
331 any stack segment. I think that the description in 'asdef' is | |
332 out of date. I only describe the parts that I am sure about. */ | |
333 | |
334 struct stk_trailer | |
335 { | |
336 long this_address; /* Address of this block. */ | |
337 long this_size; /* Size of this block (does not include | |
338 this trailer). */ | |
339 long unknown2; | |
340 long unknown3; | |
341 long link; /* Address of trailer block of previous | |
342 segment. */ | |
343 long unknown5; | |
344 long unknown6; | |
345 long unknown7; | |
346 long unknown8; | |
347 long unknown9; | |
348 long unknown10; | |
349 long unknown11; | |
350 long unknown12; | |
351 long unknown13; | |
352 long unknown14; | |
353 }; | |
354 | |
355 #endif /* CRAY2 */ | |
356 #endif /* not CRAY_STACK */ | |
357 | |
358 #ifdef CRAY2 | |
359 /* Determine a "stack measure" for an arbitrary ADDRESS. | |
15593 | 360 I doubt that "lint" will like this much. */ |
2746 | 361 |
362 static long | |
363 i00afunc (long *address) | |
364 { | |
365 struct stk_stat status; | |
366 struct stk_trailer *trailer; | |
367 long *block, size; | |
368 long result = 0; | |
369 | |
370 /* We want to iterate through all of the segments. The first | |
371 step is to get the stack status structure. We could do this | |
372 more quickly and more directly, perhaps, by referencing the | |
373 $LM00 common block, but I know that this works. */ | |
374 | |
375 STKSTAT (&status); | |
376 | |
377 /* Set up the iteration. */ | |
378 | |
379 trailer = (struct stk_trailer *) (status.current_address | |
380 + status.current_size | |
381 - 15); | |
382 | |
383 /* There must be at least one stack segment. Therefore it is | |
384 a fatal error if "trailer" is null. */ | |
385 | |
386 if (trailer == 0) | |
387 abort (); | |
388 | |
389 /* Discard segments that do not contain our argument address. */ | |
390 | |
391 while (trailer != 0) | |
392 { | |
393 block = (long *) trailer->this_address; | |
394 size = trailer->this_size; | |
395 if (block == 0 || size == 0) | |
396 abort (); | |
397 trailer = (struct stk_trailer *) trailer->link; | |
398 if ((block <= address) && (address < (block + size))) | |
399 break; | |
400 } | |
401 | |
402 /* Set the result to the offset in this segment and add the sizes | |
403 of all predecessor segments. */ | |
404 | |
405 result = address - block; | |
406 | |
407 if (trailer == 0) | |
408 { | |
409 return result; | |
410 } | |
411 | |
412 do | |
413 { | |
414 if (trailer->this_size <= 0) | |
415 abort (); | |
416 result += trailer->this_size; | |
417 trailer = (struct stk_trailer *) trailer->link; | |
418 } | |
419 while (trailer != 0); | |
420 | |
421 /* We are done. Note that if you present a bogus address (one | |
422 not in any segment), you will get a different number back, formed | |
423 from subtracting the address of the first block. This is probably | |
424 not what you want. */ | |
425 | |
426 return (result); | |
427 } | |
428 | |
429 #else /* not CRAY2 */ | |
430 /* Stack address function for a CRAY-1, CRAY X-MP, or CRAY Y-MP. | |
431 Determine the number of the cell within the stack, | |
432 given the address of the cell. The purpose of this | |
433 routine is to linearize, in some sense, stack addresses | |
434 for alloca. */ | |
435 | |
436 static long | |
437 i00afunc (long address) | |
438 { | |
439 long stkl = 0; | |
440 | |
441 long size, pseg, this_segment, stack; | |
442 long result = 0; | |
443 | |
444 struct stack_segment_linkage *ssptr; | |
445 | |
446 /* Register B67 contains the address of the end of the | |
447 current stack segment. If you (as a subprogram) store | |
448 your registers on the stack and find that you are past | |
449 the contents of B67, you have overflowed the segment. | |
450 | |
451 B67 also points to the stack segment linkage control | |
452 area, which is what we are really interested in. */ | |
453 | |
454 stkl = CRAY_STACKSEG_END (); | |
455 ssptr = (struct stack_segment_linkage *) stkl; | |
456 | |
457 /* If one subtracts 'size' from the end of the segment, | |
458 one has the address of the first word of the segment. | |
459 | |
460 If this is not the first segment, 'pseg' will be | |
461 nonzero. */ | |
462 | |
463 pseg = ssptr->sspseg; | |
464 size = ssptr->sssize; | |
465 | |
466 this_segment = stkl - size; | |
467 | |
468 /* It is possible that calling this routine itself caused | |
469 a stack overflow. Discard stack segments which do not | |
470 contain the target address. */ | |
471 | |
472 while (!(this_segment <= address && address <= stkl)) | |
473 { | |
474 #ifdef DEBUG_I00AFUNC | |
475 fprintf (stderr, "%011o %011o %011o\n", this_segment, address, stkl); | |
476 #endif | |
477 if (pseg == 0) | |
478 break; | |
479 stkl = stkl - pseg; | |
480 ssptr = (struct stack_segment_linkage *) stkl; | |
481 size = ssptr->sssize; | |
482 pseg = ssptr->sspseg; | |
483 this_segment = stkl - size; | |
484 } | |
485 | |
486 result = address - this_segment; | |
487 | |
488 /* If you subtract pseg from the current end of the stack, | |
489 you get the address of the previous stack segment's end. | |
490 This seems a little convoluted to me, but I'll bet you save | |
491 a cycle somewhere. */ | |
492 | |
493 while (pseg != 0) | |
494 { | |
495 #ifdef DEBUG_I00AFUNC | |
496 fprintf (stderr, "%011o %011o\n", pseg, size); | |
497 #endif | |
498 stkl = stkl - pseg; | |
499 ssptr = (struct stack_segment_linkage *) stkl; | |
500 size = ssptr->sssize; | |
501 pseg = ssptr->sspseg; | |
502 result += size; | |
503 } | |
504 return (result); | |
505 } | |
506 | |
507 #endif /* not CRAY2 */ | |
508 #endif /* CRAY */ | |
509 | |
510 #endif /* no alloca */ | |
4557 | 511 #endif /* not GCC version 2 */ |