Mercurial > hg > xemacs-beta

comparison src/lisp.h @ 647:b39c14581166

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[xemacs-hg @ 2001-08-13 04:45:47 by ben] removal of unsigned, size_t, etc.
author ben
date Mon, 13 Aug 2001 04:46:48 +0000
parents af57a77cbc92
children fdefd0186b75
comparison
equal deleted inserted replaced
646:00c54252fe4f 647:b39c14581166
42 #include <ctype.h> 42 #include <ctype.h>
43 #include <stdarg.h> 43 #include <stdarg.h>
44 #include <stddef.h> /* offsetof */ 44 #include <stddef.h> /* offsetof */
45 #include <sys/types.h> 45 #include <sys/types.h>
46 #include <limits.h> 46 #include <limits.h>
47
48 /* ------------------------ definition of EMACS_INT ------------------- */
49
50 /* EMACS_INT is the underlying integral type into which a Lisp_Object must fit.
51 In particular, it must be large enough to contain a pointer.
52 config.h can override this, e.g. to use `long long' for bigger lisp ints.
53
54 #### In point of fact, it would NOT be a good idea for config.h to mess
55 with EMACS_INT. A lot of code makes the basic assumption that EMACS_INT
56 is the size of a pointer. */
57
58 #ifndef SIZEOF_EMACS_INT
59 # define SIZEOF_EMACS_INT SIZEOF_VOID_P
60 #endif
61
62 #ifndef EMACS_INT
63 # if SIZEOF_EMACS_INT == SIZEOF_LONG
64 # define EMACS_INT long
65 # elif SIZEOF_EMACS_INT == SIZEOF_INT
66 # define EMACS_INT int
67 # elif SIZEOF_EMACS_INT == SIZEOF_LONG_LONG
68 # define EMACS_INT long long
69 # else
70 # error Unable to determine suitable type for EMACS_INT
71 # endif
72 #endif
73
74 #ifndef EMACS_UINT
75 # define EMACS_UINT unsigned EMACS_INT
76 #endif
77
78 #define BITS_PER_EMACS_INT (SIZEOF_EMACS_INT * BITS_PER_CHAR)
79
80 /* ------------------------ basic char/int typedefs ------------------- */
81
82 /* The definitions we put here use typedefs to attribute specific meaning
83 to types that by themselves are pretty general. Stuff pointed to by a
84 char * or unsigned char * will nearly always be one of four types:
85 a) pointer to internally-formatted text; b) pointer to text in some
86 external format, which can be defined as all formats other than the
87 internal one; c) pure ASCII text; d) binary data that is not meant to
88 be interpreted as text. [A fifth possible type "e) a general pointer
89 to memory" should be replaced with void *.] Using these more specific
90 types rather than the general ones helps avoid the confusions that
91 occur when the semantics of a char * argument being studied are unclear.
92
93 Note that these typedefs are purely for documentation purposes; from
94 the C code's perspective, they are exactly equivalent to `char *',
95 `unsigned char *', etc., so you can freely use them with library
96 functions declared as such. */
97
98 /* The data representing the text in a buffer is logically a set
99 of Bufbytes, declared as follows. */
100
101 typedef unsigned char Bufbyte;
102
103 /* The following should be used when you are working with internal data
104 but for whatever reason need to have it declared a "char *". Examples
105 are function arguments whose values are most commonly literal strings,
106 or where you have to apply a stdlib string function to internal data.
107
108 In general, you should avoid this where possible and use Bufbyte instead,
109 for consistency. For example, the new Mule workspace contains
110 Bufbyte versions of the stdlib string functions. */
111
112 typedef char CBufbyte;
113
114 /* The data representing a string in "external" format (binary or any
115 external encoding) is logically a set of Extbytes, declared as
116 follows. Extbyte is guaranteed to be just a char, so for example
117 strlen (Extbyte *) is OK. Extbyte is only a documentation device
118 for referring to external text. */
119
120 typedef char Extbyte;
121
122 /* A byte in a string in binary format: */
123 typedef char Char_Binary;
124 typedef signed char SChar_Binary;
125 typedef unsigned char UChar_Binary;
126
127 /* A byte in a string in entirely US-ASCII format: (Nothing outside
128 the range 00 - 7F) */
129
130 typedef char Char_ASCII;
131 typedef unsigned char UChar_ASCII;
132
133
134 /* To the user, a buffer is made up of characters, declared as follows.
135 In the non-Mule world, characters and Bufbytes are equivalent.
136 In the Mule world, a character requires (typically) 1 to 4
137 Bufbytes for its representation in a buffer. */
138
139 typedef int Emchar;
140
141 /* Different ways of referring to a position in a buffer. We use
142 the typedefs in preference to 'EMACS_INT' to make it clearer what
143 sort of position is being used. See extents.c for a description
144 of the different positions. We put them here instead of in
145 buffer.h (where they rightfully belong) to avoid syntax errors
146 in function prototypes. */
147
148 typedef EMACS_INT Bufpos;
149 typedef EMACS_INT Bytind;
150 typedef EMACS_INT Memind;
151
152 /* Counts of bytes or chars */
153
154 typedef EMACS_INT Bytecount;
155 typedef EMACS_INT Charcount;
156
157 /* Length in bytes of a string in external format */
158 typedef EMACS_INT Extcount;
159
160 /* General counts of bytes or elements */
161 typedef EMACS_INT Memory_Count;
162 typedef EMACS_INT Element_Count;
163
164 typedef unsigned long Hash_Code;
47 165
48 /* ------------------------ dynamic arrays ------------------- */ 166 /* ------------------------ dynamic arrays ------------------- */
49 167
50 #define Dynarr_declare(type) \ 168 #define Dynarr_declare(type) \
51 type *base; \ 169 type *base; \
96 #define Dynarr_increment(d) ((d)->cur++) 214 #define Dynarr_increment(d) ((d)->cur++)
97 #define Dynarr_set_size(d, n) ((d)->cur = n) 215 #define Dynarr_set_size(d, n) ((d)->cur = n)
98 216
99 #ifdef MEMORY_USAGE_STATS 217 #ifdef MEMORY_USAGE_STATS
100 struct overhead_stats; 218 struct overhead_stats;
101 size_t Dynarr_memory_usage (void *d, struct overhead_stats *stats); 219 Memory_Count Dynarr_memory_usage (void *d, struct overhead_stats *stats);
102 #endif 220 #endif
103 221
104 /* Also define min() and max(). (Some compilers put them in strange 222 /* Also define min() and max(). (Some compilers put them in strange
105 places that won't be referenced by the above include files, such 223 places that won't be referenced by the above include files, such
106 as 'macros.h' under Solaris.) */ 224 as 'macros.h' under Solaris.) */
112 #define max(a,b) (((a) > (b)) ? (a) : (b)) 230 #define max(a,b) (((a) > (b)) ? (a) : (b))
113 #endif 231 #endif
114 232
115 /* Memory allocation */ 233 /* Memory allocation */
116 void malloc_warning (const char *); 234 void malloc_warning (const char *);
117 void *xmalloc (size_t size); 235 void *xmalloc (Memory_Count size);
118 void *xmalloc_and_zero (size_t size); 236 void *xmalloc_and_zero (Memory_Count size);
119 void *xrealloc (void *, size_t size); 237 void *xrealloc (void *, Memory_Count size);
120 char *xstrdup (const char *); 238 char *xstrdup (const char *);
121 /* generally useful */ 239 /* generally useful */
122 #define countof(x) ((int) (sizeof(x)/sizeof((x)[0]))) 240 #define countof(x) ((int) (sizeof(x)/sizeof((x)[0])))
123 #define xnew(type) ((type *) xmalloc (sizeof (type))) 241 #define xnew(type) ((type *) xmalloc (sizeof (type)))
124 #define xnew_array(type, len) ((type *) xmalloc ((len) * sizeof (type))) 242 #define xnew_array(type, len) ((type *) xmalloc ((len) * sizeof (type)))
134 if SIZEVAR is 0), with the total size stored in SIZEVAR. This 252 if SIZEVAR is 0), with the total size stored in SIZEVAR. This
135 macro will realloc BASEVAR as necessary so that it can hold at 253 macro will realloc BASEVAR as necessary so that it can hold at
136 least NEEDED_SIZE objects. The reallocing is done by doubling, 254 least NEEDED_SIZE objects. The reallocing is done by doubling,
137 which ensures constant amortized time per element. */ 255 which ensures constant amortized time per element. */
138 #define DO_REALLOC(basevar, sizevar, needed_size, type) do { \ 256 #define DO_REALLOC(basevar, sizevar, needed_size, type) do { \
139 size_t do_realloc_needed_size = (needed_size); \ 257 Memory_Count do_realloc_needed_size = (needed_size); \
140 if ((sizevar) < do_realloc_needed_size) \ 258 if ((sizevar) < do_realloc_needed_size) \
141 { \ 259 { \
142 if ((sizevar) < 32) \ 260 if ((sizevar) < 32) \
143 (sizevar) = 32; \ 261 (sizevar) = 32; \
144 while ((sizevar) < do_realloc_needed_size) \ 262 while ((sizevar) < do_realloc_needed_size) \
263 /*#else*/ 381 /*#else*/
264 /*#define REGISTER register*/ 382 /*#define REGISTER register*/
265 /*#endif*/ 383 /*#endif*/
266 384
267 385
268 /* EMACS_INT is the underlying integral type into which a Lisp_Object must fit.
269 In particular, it must be large enough to contain a pointer.
270 config.h can override this, e.g. to use `long long' for bigger lisp ints.
271
272 #### In point of fact, it would NOT be a good idea for config.h to mess
273 with EMACS_INT. A lot of code makes the basic assumption that EMACS_INT
274 is the size of a pointer. */
275
276 #ifndef SIZEOF_EMACS_INT
277 # define SIZEOF_EMACS_INT SIZEOF_VOID_P
278 #endif
279
280 #ifndef EMACS_INT
281 # if SIZEOF_EMACS_INT == SIZEOF_LONG
282 # define EMACS_INT long
283 # elif SIZEOF_EMACS_INT == SIZEOF_INT
284 # define EMACS_INT int
285 # elif SIZEOF_EMACS_INT == SIZEOF_LONG_LONG
286 # define EMACS_INT long long
287 # else
288 # error Unable to determine suitable type for EMACS_INT
289 # endif
290 #endif
291
292 #ifndef EMACS_UINT
293 # define EMACS_UINT unsigned EMACS_INT
294 #endif
295
296 #define BITS_PER_EMACS_INT (SIZEOF_EMACS_INT * BITS_PER_CHAR)
297
298 386
299 /************************************************************************/ 387 /************************************************************************/
300 /* typedefs */ 388 /* typedefs */
301 /************************************************************************/ 389 /************************************************************************/
302 390
391 /* Note that the simplest typedefs are near the top of this file. */
392
303 /* We put typedefs here so that prototype declarations don't choke. 393 /* We put typedefs here so that prototype declarations don't choke.
304 Note that we don't actually declare the structures here (except 394 Note that we don't actually declare the structures here (except
305 maybe for simple structures like Dynarrs); that keeps them private 395 maybe for simple structures like Dynarrs); that keeps them private
306 to the routines that actually use them. */ 396 to the routines that actually use them. */
307 397
308 /* ------------------------------- */
309 /* basic char/int typedefs */
310 /* ------------------------------- */
311
312 /* The definitions we put here use typedefs to attribute specific meaning
313 to types that by themselves are pretty general. Stuff pointed to by a
314 char * or unsigned char * will nearly always be one of four types:
315 a) pointer to internally-formatted text; b) pointer to text in some
316 external format, which can be defined as all formats other than the
317 internal one; c) pure ASCII text; d) binary data that is not meant to
318 be interpreted as text. [A fifth possible type "e) a general pointer
319 to memory" should be replaced with void *.] Using these more specific
320 types rather than the general ones helps avoid the confusions that
321 occur when the semantics of a char * argument being studied are unclear.
322
323 Note that these typedefs are purely for documentation purposes; from
324 the C code's perspective, they are exactly equivalent to `char *',
325 `unsigned char *', etc., so you can freely use them with library
326 functions declared as such. */
327
328 /* The data representing the text in a buffer is logically a set
329 of Bufbytes, declared as follows. */
330
331 typedef unsigned char Bufbyte;
332
333 /* The following should be used when you are working with internal data
334 but for whatever reason need to have it declared a "char *". Examples
335 are function arguments whose values are most commonly literal strings,
336 or where you have to apply a stdlib string function to internal data.
337
338 In general, you should avoid this where possible and use Bufbyte instead,
339 for consistency. For example, the new Mule workspace contains
340 Bufbyte versions of the stdlib string functions. */
341
342 typedef char CBufbyte;
343
344 /* The data representing a string in "external" format (binary or any
345 external encoding) is logically a set of Extbytes, declared as
346 follows. Extbyte is guaranteed to be just a char, so for example
347 strlen (Extbyte *) is OK. Extbyte is only a documentation device
348 for referring to external text. */
349
350 typedef char Extbyte;
351
352 /* A byte in a string in binary format: */
353 typedef char Char_Binary;
354 typedef signed char SChar_Binary;
355 typedef unsigned char UChar_Binary;
356
357 /* A byte in a string in entirely US-ASCII format: (Nothing outside
358 the range 00 - 7F) */
359
360 typedef char Char_ASCII;
361 typedef unsigned char UChar_ASCII;
362
363
364 /* To the user, a buffer is made up of characters, declared as follows.
365 In the non-Mule world, characters and Bufbytes are equivalent.
366 In the Mule world, a character requires (typically) 1 to 4
367 Bufbytes for its representation in a buffer. */
368
369 typedef int Emchar;
370
371 /* Different ways of referring to a position in a buffer. We use
372 the typedefs in preference to 'EMACS_INT' to make it clearer what
373 sort of position is being used. See extents.c for a description
374 of the different positions. We put them here instead of in
375 buffer.h (where they rightfully belong) to avoid syntax errors
376 in function prototypes. */
377
378 typedef EMACS_INT Bufpos;
379 typedef EMACS_INT Bytind;
380 typedef EMACS_INT Memind;
381
382 /* Counts of bytes or chars */
383
384 typedef EMACS_INT Bytecount;
385 typedef EMACS_INT Charcount;
386
387 /* Length in bytes of a string in external format */
388 typedef EMACS_INT Extcount;
389
390 /* ------------------------------- */
391 /* structure/other typedefs */
392 /* ------------------------------- */
393
394 typedef struct lstream Lstream; 398 typedef struct lstream Lstream;
395 399
396 typedef unsigned int face_index; 400 typedef int face_index;
397 401
398 typedef struct 402 typedef struct
399 { 403 {
400 Dynarr_declare (struct face_cachel); 404 Dynarr_declare (struct face_cachel);
401 } face_cachel_dynarr; 405 } face_cachel_dynarr;
402 406
403 typedef unsigned int glyph_index; 407 typedef int glyph_index;
404 408
405 /* This is shared by process.h, events.h and others in future. 409 /* This is shared by process.h, events.h and others in future.
406 See events.h for description */ 410 See events.h for description */
407 typedef unsigned int USID; 411 typedef unsigned int USID;
408 412
1285 1289
1286 struct Lisp_Bit_Vector 1290 struct Lisp_Bit_Vector
1287 { 1291 {
1288 struct lrecord_header lheader; 1292 struct lrecord_header lheader;
1289 Lisp_Object next; 1293 Lisp_Object next;
1290 size_t size; 1294 Element_Count size;
1291 unsigned long bits[1]; 1295 unsigned long bits[1];
1292 }; 1296 };
1293 typedef struct Lisp_Bit_Vector Lisp_Bit_Vector; 1297 typedef struct Lisp_Bit_Vector Lisp_Bit_Vector;
1294 1298
1295 DECLARE_LRECORD (bit_vector, Lisp_Bit_Vector); 1299 DECLARE_LRECORD (bit_vector, Lisp_Bit_Vector);
1313 } while (0) 1317 } while (0)
1314 1318
1315 #define bit_vector_length(v) ((v)->size) 1319 #define bit_vector_length(v) ((v)->size)
1316 #define bit_vector_next(v) ((v)->next) 1320 #define bit_vector_next(v) ((v)->next)
1317 1321
1318 INLINE_HEADER int bit_vector_bit (Lisp_Bit_Vector *v, size_t n); 1322 INLINE_HEADER int bit_vector_bit (Lisp_Bit_Vector *v, Element_Count n);
1319 INLINE_HEADER int 1323 INLINE_HEADER int
1320 bit_vector_bit (Lisp_Bit_Vector *v, size_t n) 1324 bit_vector_bit (Lisp_Bit_Vector *v, Element_Count n)
1321 { 1325 {
1322 return ((v->bits[n >> LONGBITS_LOG2] >> (n & (LONGBITS_POWER_OF_2 - 1))) 1326 return ((v->bits[n >> LONGBITS_LOG2] >> (n & (LONGBITS_POWER_OF_2 - 1)))
1323 & 1); 1327 & 1);
1324 } 1328 }
1325 1329
1326 INLINE_HEADER void set_bit_vector_bit (Lisp_Bit_Vector *v, size_t n, int value); 1330 INLINE_HEADER void set_bit_vector_bit (Lisp_Bit_Vector *v, Element_Count n, int value);
1327 INLINE_HEADER void 1331 INLINE_HEADER void
1328 set_bit_vector_bit (Lisp_Bit_Vector *v, size_t n, int value) 1332 set_bit_vector_bit (Lisp_Bit_Vector *v, Element_Count n, int value)
1329 { 1333 {
1330 if (value) 1334 if (value)
1331 v->bits[n >> LONGBITS_LOG2] |= (1UL << (n & (LONGBITS_POWER_OF_2 - 1))); 1335 v->bits[n >> LONGBITS_LOG2] |= (1UL << (n & (LONGBITS_POWER_OF_2 - 1)));
1332 else 1336 else
1333 v->bits[n >> LONGBITS_LOG2] &= ~(1UL << (n & (LONGBITS_POWER_OF_2 - 1))); 1337 v->bits[n >> LONGBITS_LOG2] &= ~(1UL << (n & (LONGBITS_POWER_OF_2 - 1)));
1689 1693
1690 struct lcrecord_list 1694 struct lcrecord_list
1691 { 1695 {
1692 struct lcrecord_header header; 1696 struct lcrecord_header header;
1693 Lisp_Object free; 1697 Lisp_Object free;
1694 size_t size; 1698 Element_Count size;
1695 const struct lrecord_implementation *implementation; 1699 const struct lrecord_implementation *implementation;
1696 }; 1700 };
1697 1701
1698 DECLARE_LRECORD (lcrecord_list, struct lcrecord_list); 1702 DECLARE_LRECORD (lcrecord_list, struct lcrecord_list);
1699 #define XLCRECORD_LIST(x) XRECORD (x, lcrecord_list, struct lcrecord_list) 1703 #define XLCRECORD_LIST(x) XRECORD (x, lcrecord_list, struct lcrecord_list)
1702 #define LCRECORD_LISTP(x) RECORDP (x, lcrecord_list) 1706 #define LCRECORD_LISTP(x) RECORDP (x, lcrecord_list)
1703 /* #define CHECK_LCRECORD_LIST(x) CHECK_RECORD (x, lcrecord_list) 1707 /* #define CHECK_LCRECORD_LIST(x) CHECK_RECORD (x, lcrecord_list)
1704 Lcrecord lists should never escape to the Lisp level, so 1708 Lcrecord lists should never escape to the Lisp level, so
1705 functions should not be doing this. */ 1709 functions should not be doing this. */
1706 1710
1707 Lisp_Object make_lcrecord_list (size_t size, 1711 Lisp_Object make_lcrecord_list (Element_Count size,
1708 const struct lrecord_implementation 1712 const struct lrecord_implementation
1709 *implementation); 1713 *implementation);
1710 Lisp_Object allocate_managed_lcrecord (Lisp_Object lcrecord_list); 1714 Lisp_Object allocate_managed_lcrecord (Lisp_Object lcrecord_list);
1711 void free_managed_lcrecord (Lisp_Object lcrecord_list, Lisp_Object lcrecord); 1715 void free_managed_lcrecord (Lisp_Object lcrecord_list, Lisp_Object lcrecord);
1712 1716
1883 #define HASH8(a,b,c,d,e,f,g,h) (GOOD_HASH * HASH7 (a,b,c,d,e,f,g) + (h)) 1887 #define HASH8(a,b,c,d,e,f,g,h) (GOOD_HASH * HASH7 (a,b,c,d,e,f,g) + (h))
1884 #define HASH9(a,b,c,d,e,f,g,h,i) (GOOD_HASH * HASH8 (a,b,c,d,e,f,g,h) + (i)) 1888 #define HASH9(a,b,c,d,e,f,g,h,i) (GOOD_HASH * HASH8 (a,b,c,d,e,f,g,h) + (i))
1885 1889
1886 #define LISP_HASH(obj) ((unsigned long) LISP_TO_VOID (obj)) 1890 #define LISP_HASH(obj) ((unsigned long) LISP_TO_VOID (obj))
1887 unsigned long string_hash (const char *xv); 1891 unsigned long string_hash (const char *xv);
1888 unsigned long memory_hash (const void *xv, size_t size); 1892 unsigned long memory_hash (const void *xv, Memory_Count size);
1889 unsigned long internal_hash (Lisp_Object obj, int depth); 1893 unsigned long internal_hash (Lisp_Object obj, int depth);
1890 unsigned long internal_array_hash (Lisp_Object *arr, int size, int depth); 1894 unsigned long internal_array_hash (Lisp_Object *arr, int size, int depth);
1891 1895
1892 1896
1893 /************************************************************************/ 1897 /************************************************************************/
2184 #define dump_add_root_struct_ptr(varaddr,descaddr) DO_NOTHING 2188 #define dump_add_root_struct_ptr(varaddr,descaddr) DO_NOTHING
2185 #endif 2189 #endif
2186 2190
2187 /* dump_add_opaque (&var, size) dumps the opaque static structure `var'. */ 2191 /* dump_add_opaque (&var, size) dumps the opaque static structure `var'. */
2188 #ifdef PDUMP 2192 #ifdef PDUMP
2189 void dump_add_opaque (const void *, size_t); 2193 void dump_add_opaque (const void *, Memory_Count);
2190 #else 2194 #else
2191 #define dump_add_opaque(varaddr,size) DO_NOTHING 2195 #define dump_add_opaque(varaddr,size) DO_NOTHING
2192 #endif 2196 #endif
2193 2197
2194 /* Call dump_add_opaque_int (&int_var) to dump `int_var', of type `int'. */ 2198 /* Call dump_add_opaque_int (&int_var) to dump `int_var', of type `int'. */
2252 the fields to 0, and add any existing values to whatever was there 2256 the fields to 0, and add any existing values to whatever was there
2253 before; this way, you can get a cumulative effect. */ 2257 before; this way, you can get a cumulative effect. */
2254 2258
2255 struct overhead_stats 2259 struct overhead_stats
2256 { 2260 {
2257 int was_requested; 2261 Memory_Count was_requested;
2258 int malloc_overhead; 2262 Memory_Count malloc_overhead;
2259 int dynarr_overhead; 2263 Memory_Count dynarr_overhead;
2260 int gap_overhead; 2264 Memory_Count gap_overhead;
2261 }; 2265 };
2262 2266
2263 #endif /* MEMORY_USAGE_STATS */ 2267 #endif /* MEMORY_USAGE_STATS */
2264 2268
2265 #ifndef DIRECTORY_SEP 2269 #ifndef DIRECTORY_SEP
2317 #include "symsinit.h" 2321 #include "symsinit.h"
2318 2322
2319 /* Defined in alloc.c */ 2323 /* Defined in alloc.c */
2320 void release_breathing_space (void); 2324 void release_breathing_space (void);
2321 Lisp_Object noseeum_cons (Lisp_Object, Lisp_Object); 2325 Lisp_Object noseeum_cons (Lisp_Object, Lisp_Object);
2322 Lisp_Object make_vector (size_t, Lisp_Object); 2326 Lisp_Object make_vector (Element_Count, Lisp_Object);
2323 Lisp_Object vector1 (Lisp_Object); 2327 Lisp_Object vector1 (Lisp_Object);
2324 Lisp_Object vector2 (Lisp_Object, Lisp_Object); 2328 Lisp_Object vector2 (Lisp_Object, Lisp_Object);
2325 Lisp_Object vector3 (Lisp_Object, Lisp_Object, Lisp_Object); 2329 Lisp_Object vector3 (Lisp_Object, Lisp_Object, Lisp_Object);
2326 Lisp_Object make_bit_vector (size_t, Lisp_Object); 2330 Lisp_Object make_bit_vector (Element_Count, Lisp_Object);
2327 Lisp_Object make_bit_vector_from_byte_vector (unsigned char *, size_t); 2331 Lisp_Object make_bit_vector_from_byte_vector (unsigned char *, Element_Count);
2328 Lisp_Object noseeum_make_marker (void); 2332 Lisp_Object noseeum_make_marker (void);
2329 void garbage_collect_1 (void); 2333 void garbage_collect_1 (void);
2330 Lisp_Object acons (Lisp_Object, Lisp_Object, Lisp_Object); 2334 Lisp_Object acons (Lisp_Object, Lisp_Object, Lisp_Object);
2331 Lisp_Object cons3 (Lisp_Object, Lisp_Object, Lisp_Object); 2335 Lisp_Object cons3 (Lisp_Object, Lisp_Object, Lisp_Object);
2332 Lisp_Object list1 (Lisp_Object); 2336 Lisp_Object list1 (Lisp_Object);
2361 int object_dead_p (Lisp_Object); 2365 int object_dead_p (Lisp_Object);
2362 void mark_object (Lisp_Object obj); 2366 void mark_object (Lisp_Object obj);
2363 int marked_p (Lisp_Object obj); 2367 int marked_p (Lisp_Object obj);
2364 2368
2365 #ifdef MEMORY_USAGE_STATS 2369 #ifdef MEMORY_USAGE_STATS
2366 size_t malloced_storage_size (void *, size_t, struct overhead_stats *); 2370 Memory_Count malloced_storage_size (void *, Memory_Count, struct overhead_stats *);
2367 size_t fixed_type_block_overhead (size_t); 2371 Memory_Count fixed_type_block_overhead (Memory_Count);
2368 #endif 2372 #endif
2369 #ifdef PDUMP 2373 #ifdef PDUMP
2370 void pdump (void); 2374 void pdump (void);
2371 int pdump_load (const char *); 2375 int pdump_load (const char *);
2372 2376
2700 const CBufbyte *string, 2704 const CBufbyte *string,
2701 Lisp_Object data)); 2705 Lisp_Object data));
2702 DECLARE_DOESNT_RETURN (report_file_error (const CBufbyte *, Lisp_Object)); 2706 DECLARE_DOESNT_RETURN (report_file_error (const CBufbyte *, Lisp_Object));
2703 Lisp_Object lisp_strerror (int); 2707 Lisp_Object lisp_strerror (int);
2704 Lisp_Object expand_and_dir_to_file (Lisp_Object, Lisp_Object); 2708 Lisp_Object expand_and_dir_to_file (Lisp_Object, Lisp_Object);
2705 ssize_t read_allowing_quit (int, void *, size_t); 2709 Memory_Count read_allowing_quit (int fildes, void *buf, Memory_Count size);
2706 ssize_t write_allowing_quit (int, const void *, size_t); 2710 Memory_Count write_allowing_quit (int fildes, const void *buf,
2711 Memory_Count size);
2707 int internal_delete_file (Lisp_Object); 2712 int internal_delete_file (Lisp_Object);
2708 2713
2709 /* Defined in filelock.c */ 2714 /* Defined in filelock.c */
2710 void lock_file (Lisp_Object); 2715 void lock_file (Lisp_Object);
2711 void unlock_file (Lisp_Object); 2716 void unlock_file (Lisp_Object);