![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to obstack.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb|
Return to obstack.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb |
1.1 root 1: /* obstack.c - subroutines used implicitly by object stack macros
2: Copyright (C) 1988 Free Software Foundation, Inc.
3:
4: NO WARRANTY
5:
6: BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
7: NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT
8: WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
9: RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS"
10: WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
11: BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
12: FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY
13: AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
14: DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
15: CORRECTION.
16:
17: IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
18: STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
19: WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE
20: LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR
21: OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
22: USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR
23: DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR
24: A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS
25: PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
26: DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.
27:
28: GENERAL PUBLIC LICENSE TO COPY
29:
30: 1. You may copy and distribute verbatim copies of this source file
31: as you receive it, in any medium, provided that you conspicuously and
32: appropriately publish on each copy a valid copyright notice "Copyright
33: (C) 1988 Free Software Foundation, Inc."; and include following the
34: copyright notice a verbatim copy of the above disclaimer of warranty
35: and of this License. You may charge a distribution fee for the
36: physical act of transferring a copy.
37:
38: 2. You may modify your copy or copies of this source file or
39: any portion of it, and copy and distribute such modifications under
40: the terms of Paragraph 1 above, provided that you also do the following:
41:
42: a) cause the modified files to carry prominent notices stating
43: that you changed the files and the date of any change; and
44:
45: b) cause the whole of any work that you distribute or publish,
46: that in whole or in part contains or is a derivative of this
47: program or any part thereof, to be licensed at no charge to all
48: third parties on terms identical to those contained in this
49: License Agreement (except that you may choose to grant more extensive
50: warranty protection to some or all third parties, at your option).
51:
52: c) You may charge a distribution fee for the physical act of
53: transferring a copy, and you may at your option offer warranty
54: protection in exchange for a fee.
55:
56: Mere aggregation of another unrelated program with this program (or its
57: derivative) on a volume of a storage or distribution medium does not bring
58: the other program under the scope of these terms.
59:
60: 3. You may copy and distribute this program or any portion of it in
61: compiled, executable or object code form under the terms of Paragraphs
62: 1 and 2 above provided that you do the following:
63:
64: a) accompany it with the complete corresponding machine-readable
65: source code, which must be distributed under the terms of
66: Paragraphs 1 and 2 above; or,
67:
68: b) accompany it with a written offer, valid for at least three
69: years, to give any third party free (except for a nominal
70: shipping charge) a complete machine-readable copy of the
71: corresponding source code, to be distributed under the terms of
72: Paragraphs 1 and 2 above; or,
73:
74: c) accompany it with the information you received as to where the
75: corresponding source code may be obtained. (This alternative is
76: allowed only for noncommercial distribution and only if you
77: received the program in object code or executable form alone.)
78:
79: For an executable file, complete source code means all the source code for
80: all modules it contains; but, as a special exception, it need not include
81: source code for modules which are standard libraries that accompany the
82: operating system on which the executable file runs.
83:
84: 4. You may not copy, sublicense, distribute or transfer this program
85: except as expressly provided under this License Agreement. Any attempt
86: otherwise to copy, sublicense, distribute or transfer this program is void and
87: your rights to use the program under this License agreement shall be
88: automatically terminated. However, parties who have received computer
89: software programs from you with this License Agreement will not have
90: their licenses terminated so long as such parties remain in full compliance.
91:
92: 5. If you wish to incorporate parts of this program into other free
93: programs whose distribution conditions are different, write to the Free
94: Software Foundation at 675 Mass Ave, Cambridge, MA 02139. We have not yet
95: worked out a simple rule that can be stated here, but we will often permit
96: this. We will be guided by the two goals of preserving the free status of
97: all derivatives our free software and of promoting the sharing and reuse of
98: software.
99:
100:
101: In other words, you are welcome to use, share and improve this program.
102: You are forbidden to forbid anyone else to use, share and improve
103: what you give them. Help stamp out software-hoarding! */
104:
105:
106: #include "obstack.h"
107:
108: #ifdef __STDC__
109: #define POINTER void *
110: #else
111: #define POINTER char *
112: #endif
113:
114: /* Determine default alignment. */
115: struct fooalign {char x; double d;};
116: #define DEFAULT_ALIGNMENT ((char *)&((struct fooalign *) 0)->d - (char *)0)
117: /* If malloc were really smart, it would round addresses to DEFAULT_ALIGNMENT.
118: But in fact it might be less smart and round addresses to as much as
119: DEFAULT_ROUNDING. So we prepare for it to do that. */
120: union fooround {long x; double d;};
121: #define DEFAULT_ROUNDING (sizeof (union fooround))
122:
123: /* When we copy a long block of data, this is the unit to do it with.
124: On some machines, copying successive ints does not work;
125: in such a case, redefine COPYING_UNIT to `long' (if that works)
126: or `char' as a last resort. */
127: #ifndef COPYING_UNIT
128: #define COPYING_UNIT int
129: #endif
130:
131: /* The non-GNU-C macros copy the obstack into this global variable
132: to avoid multiple evaluation. */
133:
134: struct obstack *_obstack;
135:
136: /* Initialize an obstack H for use. Specify chunk size SIZE (0 means default).
137: Objects start on multiples of ALIGNMENT (0 means use default).
138: CHUNKFUN is the function to use to allocate chunks,
139: and FREEFUN the function to free them. */
140:
141: void
142: _obstack_begin (h, size, alignment, chunkfun, freefun)
143: struct obstack *h;
144: int size;
145: int alignment;
146: POINTER (*chunkfun) ();
147: void (*freefun) ();
148: {
149: register struct _obstack_chunk* chunk; /* points to new chunk */
150:
151: if (alignment == 0)
152: alignment = DEFAULT_ALIGNMENT;
153: if (size == 0)
154: /* Default size is what GNU malloc can fit in a 4096-byte block.
155: Pick a number small enough that when rounded up to DEFAULT_ROUNDING
156: it is still smaller than 4096 - 4. */
157: {
158: int extra = 4;
159: if (extra < DEFAULT_ROUNDING)
160: extra = DEFAULT_ROUNDING;
161: size = 4096 - extra;
162: }
163:
164: h->chunkfun = (struct _obstack_chunk * (*)()) chunkfun;
165: h->freefun = freefun;
166: h->chunk_size = size;
167: h->alignment_mask = alignment - 1;
168:
169: chunk = h->chunk = (*h->chunkfun) (h->chunk_size);
170: h->next_free = h->object_base = chunk->contents;
171: h->chunk_limit = chunk->limit
172: = (char *) chunk + h->chunk_size;
173: chunk->prev = 0;
174: }
175:
176: /* Allocate a new current chunk for the obstack *H
177: on the assumption that LENGTH bytes need to be added
178: to the current object, or a new object of length LENGTH allocated.
179: Copies any partial object from the end of the old chunk
180: to the beginning of the new one. */
181:
182: void
183: _obstack_newchunk (h, length)
184: struct obstack *h;
185: int length;
186: {
187: register struct _obstack_chunk* old_chunk = h->chunk;
188: register struct _obstack_chunk* new_chunk;
189: register long new_size;
190: register int obj_size = h->next_free - h->object_base;
191: register int i;
192:
193: /* Compute size for new chunk. */
194: new_size = (obj_size + length) << 1;
195: if (new_size < h->chunk_size)
196: new_size = h->chunk_size;
197:
198: /* Allocate and initialize the new chunk. */
199: new_chunk = h->chunk = (*h->chunkfun) (new_size);
200: new_chunk->prev = old_chunk;
201: new_chunk->limit = h->chunk_limit = (char *) new_chunk + new_size;
202:
203: /* Move the existing object to the new chunk.
204: Word at a time is fast and is safe because these
205: structures are aligned at least that much. */
206: for (i = (obj_size + sizeof (COPYING_UNIT) - 1) / sizeof (COPYING_UNIT) - 1;
207: i >= 0; i--)
208: ((COPYING_UNIT *)new_chunk->contents)[i]
209: = ((COPYING_UNIT *)h->object_base)[i];
210:
211: h->object_base = new_chunk->contents;
212: h->next_free = h->object_base + obj_size;
213: }
214:
215: /* Free objects in obstack H, including OBJ and everything allocate
216: more recently than OBJ. If OBJ is zero, free everything in H. */
217:
218: void
219: #ifdef __STDC__
220: #undef obstack_free
221: obstack_free (h, obj)
222:
223: #else
224: _obstack_free (h, obj)
225: #endif
226: struct obstack *h;
227: POINTER obj;
228: {
229: register struct _obstack_chunk* lp; /* below addr of any objects in this chunk */
230: register struct _obstack_chunk* plp; /* point to previous chunk if any */
231:
232: lp = (h)->chunk;
233: while (lp != 0 && ((POINTER)lp > obj || (POINTER)(lp)->limit < obj))
234: {
235: plp = lp -> prev;
236: (*h->freefun) (lp);
237: lp = plp;
238: }
239: if (lp)
240: {
241: (h)->object_base = (h)->next_free = (char *)(obj);
242: (h)->chunk_limit = lp->limit;
243: (h)->chunk = lp;
244: }
245: else if (obj != 0)
246: /* obj is not in any of the chunks! */
247: abort ();
248: }
249:
250: #if 0
251: /* These are now turned off because the applications do not use it
252: and it uses bcopy via obstack_grow, which causes trouble on sysV. */
253:
254: /* Now define the functional versions of the obstack macros.
255: Define them to simply use the corresponding macros to do the job. */
256:
257: #ifdef __STDC__
258: /* These function definitions do not work with non-ANSI preprocessors;
259: they won't pass through the macro names in parentheses. */
260:
261: /* The function names appear in parentheses in order to prevent
262: the macro-definitions of the names from being expanded there. */
263:
264: POINTER (obstack_base) (obstack)
265: struct obstack *obstack;
266: {
267: return obstack_base (obstack);
268: }
269:
270: POINTER (obstack_next_free) (obstack)
271: struct obstack *obstack;
272: {
273: return obstack_next_free (obstack);
274: }
275:
276: int (obstack_object_size) (obstack)
277: struct obstack *obstack;
278: {
279: return obstack_object_size (obstack);
280: }
281:
282: int (obstack_room) (obstack)
283: struct obstack *obstack;
284: {
285: return obstack_room (obstack);
286: }
287:
288: void (obstack_grow) (obstack, pointer, length)
289: struct obstack *obstack;
290: POINTER pointer;
291: int length;
292: {
293: obstack_grow (obstack, pointer, length);
294: }
295:
296: void (obstack_grow0) (obstack, pointer, length)
297: struct obstack *obstack;
298: POINTER pointer;
299: int length;
300: {
301: obstack_grow0 (obstack, pointer, length);
302: }
303:
304: void (obstack_1grow) (obstack, character)
305: struct obstack *obstack;
306: int character;
307: {
308: obstack_1grow (obstack, character);
309: }
310:
311: void (obstack_blank) (obstack, length)
312: struct obstack *obstack;
313: int length;
314: {
315: obstack_blank (obstack, length);
316: }
317:
318: void (obstack_1grow_fast) (obstack, character)
319: struct obstack *obstack;
320: int character;
321: {
322: obstack_1grow_fast (obstack, character);
323: }
324:
325: void (obstack_blank_fast) (obstack, length)
326: struct obstack *obstack;
327: int length;
328: {
329: obstack_blank_fast (obstack, length);
330: }
331:
332: POINTER (obstack_finish) (obstack)
333: struct obstack *obstack;
334: {
335: return obstack_finish (obstack);
336: }
337:
338: POINTER (obstack_alloc) (obstack, length)
339: struct obstack *obstack;
340: int length;
341: {
342: return obstack_alloc (obstack, length);
343: }
344:
345: POINTER (obstack_copy) (obstack, pointer, length)
346: struct obstack *obstack;
347: POINTER pointer;
348: int length;
349: {
350: return obstack_copy (obstack, pointer, length);
351: }
352:
353: POINTER (obstack_copy0) (obstack, pointer, length)
354: struct obstack *obstack;
355: POINTER pointer;
356: int length;
357: {
358: return obstack_copy0 (obstack, pointer, length);
359: }
360:
361: #endif /* __STDC__ */
362:
363: #endif /* 0 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.