1 /* Utility definitions for C code of SXEmacs
3 Copyright (C) 1985-1987, 1992-1995 Free Software Foundation, Inc.
4 Copyright (C) 1993-1996 Richard Mlynarik.
5 Copyright (C) 1995, 1996, 2000 Ben Wing.
6 Copyright (C) 2004 Steve Youngs.
7 Copyright (C) 2011 Nelson Ferreira.
9 This file is part of SXEmacs
11 SXEmacs is free software: you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation, either version 3 of the License, or
14 (at your option) any later version.
16 SXEmacs is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 /* NOT synched with FSF */
25 #ifndef INCLUDED_sxe_utils_h_
26 #define INCLUDED_sxe_utils_h_
28 /* ------------------------ include files ------------------- */
30 /* We include the following generally useful header files so that you
31 don't have to worry about prototypes when using the standard C
32 library functions and macros. These files shouldn't be excessively
33 large so they shouldn't cause that much of a slowdown. */
36 #include <string.h> /* primarily for memcpy, etc. */
37 #include <stdio.h> /* NULL, etc. */
40 #include <stddef.h> /* offsetof */
41 #include <sys/types.h>
43 #if defined HAVE_STDBOOL_H
50 #elif defined(__GNUC__)
51 # define SXE_UNUSED(x) UNUSED_ ## x __attribute__((unused))
52 #elif defined(__LCLINT__)
53 # define SXE_UNUSED(x) /*@unused@*/ x
55 # define SXE_UNUSED(x) x
59 #define UNUSED(x) SXE_UNUSED(x)
63 #elif defined(__GNUC__)
64 # define WEAK_EXTERN extern __attribute__((weak))
66 # error "Grrr, bloody 'ell, can't figure out how to create weak symbols"
70 #elif defined(__GNUC__)
71 # define WEAK __attribute__((weak))
73 # error "Grrr, bloody 'ell, can't figure out how to create weak symbols"
79 #define LIKELY(_x) __builtin_expect(!!(_x), 1)
83 #define UNLIKELY(_x) __builtin_expect(!!(_x), 0)
87 #define extern_inline static inline
89 #ifdef ALL_DEBUG_FLAGS
91 #define SXE_DEBUG_FLAG
94 #define __SXE_DEBUG__(args...) fprintf(stderr, "SXE " args)
95 #ifndef SXE_DEBUG_FLAG
96 #define SXE_DEBUG(args...)
98 #define SXE_DEBUG(args...) __SXE_DEBUG__(args)
100 #define SXE_DEBUG_PT(args...) SXE_DEBUG("[pthread]: " args)
101 #define SXE_CRITICAL(args...) __SXE_DEBUG__("CRITICAL: " args)
105 /* We define assert iff USE_ASSERTIONS or DEBUG_SXEMACS is defined.
106 Otherwise we define it to be empty. Quantify has shown that the
107 time the assert checks take is measurable so let's not include them
108 in production binaries. */
110 #ifdef USE_ASSERTIONS
111 /* Highly dubious kludge */
112 /* (thanks, Jamie, I feel better now -- ben) */
113 void assert_failed(const char *, int, const char *);
114 # define abort() (assert_failed (__FILE__, __LINE__, "abort()"))
115 # define assert(x) ((x) ? (void) 0 : assert_failed (__FILE__, __LINE__, #x))
117 # ifdef DEBUG_SXEMACS
118 # define assert(x) ((x) ? (void) 0 : (void) abort ())
125 #ifndef BITS_PER_CHAR
126 #define BITS_PER_CHAR 8
128 #define SXE_SHORTBITS (SIZEOF_SHORT * BITS_PER_CHAR)
129 #define SXE_INTBITS (SIZEOF_INT * BITS_PER_CHAR)
130 #define SXE_LONGBITS (SIZEOF_LONG * BITS_PER_CHAR)
131 #define SXE_LONG_LONG_BITS (SIZEOF_LONG_LONG_INT * BITS_PER_CHAR)
132 #define SXE_VOID_P_BITS (SIZEOF_VOID_P * BITS_PER_CHAR)
134 /* Also define min() and max(). (Some compilers put them in strange
135 places that won't be referenced by the above include files, such
136 as 'macros.h' under Solaris.) */
139 #define min(a,b) (((a) <= (b)) ? (a) : (b))
142 #define max(a,b) (((a) > (b)) ? (a) : (b))
146 /* generally useful */
147 #define countof(x) ((int) (sizeof(x)/sizeof((x)[0])))
148 #define xnew(type) ((type *) xmalloc (sizeof (type)))
149 #define xnew_atomic(type) ((type *) xmalloc_atomic (sizeof (type)))
150 #define xnew_array(type, len) ((type *) xmalloc ((len) * sizeof (type)))
151 #define xnew_atomic_array(type, len) \
152 ((type*)xmalloc_atomic((len) * sizeof(type)))
153 #define xnew_and_zero(type) ((type *) xmalloc_and_zero (sizeof (type)))
154 #define xzero(lvalue) ((void) memset (&(lvalue), '\0', sizeof (lvalue)))
155 #define xnew_array_and_zero(type, len) \
156 ((type*)xmalloc_and_zero ((len) * sizeof (type)))
157 #define xrealloc_array(ptr, type, len) \
158 ((void) (ptr = (type *) xrealloc (ptr, (len) * sizeof (type))))
159 #define XREALLOC_ARRAY xrealloc_array
160 #define alloca_array(type, len) ((type *) alloca ((len) * sizeof (type)))
162 #if !defined HAVE_DECL_STRDUP
163 extern char *strdup(const char *s);
164 #endif /* HAVE_DECL_STRDUP */
168 # if defined (__GNUC__) && (__GNUC__ >= 2)
169 # define PRINTF_ARGS(string_index,first_to_check) \
170 __attribute__ ((format (printf, string_index, first_to_check)))
172 # define PRINTF_ARGS(string_index,first_to_check)
176 #ifndef DOESNT_RETURN
177 # if defined __GNUC__
178 # if ((__GNUC__ > 2) || (__GNUC__ == 2) && (__GNUC_MINOR__ >= 5))
179 # define DOESNT_RETURN void
180 # define DECLARE_DOESNT_RETURN(decl) \
181 extern void decl __attribute__ ((noreturn))
182 # define DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS(decl,str,idx) \
183 /* Should be able to state multiple independent __attribute__s, but \
184 the losing syntax doesn't work that way, and screws losing cpp */ \
186 __attribute__ ((noreturn, format (printf, str, idx)))
188 # define DOESNT_RETURN void volatile
189 # define DECLARE_DOESNT_RETURN(decl) extern void volatile decl
190 # define DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS(decl,str,idx) \
191 extern void volatile decl PRINTF_ARGS(str,idx)
192 # endif /* GNUC 2.5 */
194 # define DOESNT_RETURN void
195 # define DECLARE_DOESNT_RETURN(decl) extern void decl
196 # define DECLARE_DOESNT_RETURN_GCC_ATTRIBUTE_SYNTAX_SUCKS(decl,str,idx) \
197 extern void decl PRINTF_ARGS(str,idx)
202 /* No type has a greater alignment requirement than max_align_t.
203 (except perhaps for types we don't use, like long double) */
220 # if defined (__GNUC__) && (__GNUC__ >= 2)
221 /* gcc has an extension that gives us exactly what we want. */
222 # define ALIGNOF(type) __alignof__ (type)
223 # elif ! defined (__cplusplus)
224 /* The following is mostly portable, except that:
225 - it doesn't work for inside out declarations like void (*) (void).
226 (so just call ALIGNOF with a typedef'ed name)
227 - it doesn't work with C++. The C++ committee has decided,
228 in its infinite wisdom, that:
229 "Types must be declared in declarations, not in expressions." */
230 # define ALIGNOF(type) offsetof (struct { char c; type member; }, member)
232 /* C++ is annoying, but it has a big bag of tricks.
233 The following doesn't have the "inside out" declaration bug C does. */
234 template < typename T > struct alignment_trick {
238 # define ALIGNOF(type) offsetof (alignment_trick<type>, member)
242 #define ALIGN_SIZE(len, unit) \
243 ((((len) + (unit) - 1) / (unit)) * (unit))
245 /* #### Yuck, this is kind of evil */
246 #define ALIGN_PTR(ptr, unit) \
247 ((void *) ALIGN_SIZE ((size_t) (ptr), unit))
250 #define DO_NOTHING do {} while (0)
253 #ifndef DECLARE_NOTHING
254 #define DECLARE_NOTHING struct nosuchstruct
258 /************************************************************************/
260 /************************************************************************/
262 #ifdef ALL_DEBUG_FLAGS
264 #define GC_DEBUG_FLAG
267 #if !defined GC_DEBUG_FLAG
268 # define SXE_DEBUG_GC(args...)
270 # define SXE_DEBUG_GC(args...) __SXE_DEBUG__("[gc] " args)
272 #define SXE_DEBUG_GC_PT(args...) SXE_DEBUG_GC("[pthread]: " args)
273 #define SXE_CRITICAL_GC(args...) __SXE_DEBUG__("[gc] CRITICAL: " args)
275 void malloc_warning(const char *);
277 #if defined HAVE_BDWGC && defined EF_USE_BDWGC
278 # if defined HAVE_THREADS
279 # if !defined GC_PTHREADS
280 # define GC_PTHREADS 1
281 # endif /* !GC_PTHREADS */
282 # if !defined GC_THREADS
283 # define GC_THREADS 1
284 # endif /* !GC_THREADS */
285 # endif /* HAVE_THREADS */
288 # if defined GC_DEBUG_FLAG
290 # endif /* GC_DEBUG_FLAG */
291 # if defined HAVE_GC_GC_H
293 # elif defined HAVE_GC_H
296 # error "Take less of those pills!"
299 # if defined GC_DEBUG_FLAG
300 # define zmalloc GC_MALLOC_IGNORE_OFF_PAGE
301 # define zcalloc(n, m) GC_MALLOC((n)*(m))
302 # define zmalloc_atomic GC_MALLOC_ATOMIC_IGNORE_OFF_PAGE
303 # define zmalloc_and_zero GC_MALLOC
304 # define zrealloc GC_REALLOC
305 # define zstrdup GC_STRDUP
307 # define zfree(x) GC_FREE(x)
308 # else /* !GC_DEBUG_FLAG */
309 # define zmalloc GC_malloc_ignore_off_page
310 # define zcalloc(n, m) GC_malloc((n)*(m))
311 # define zmalloc_atomic GC_malloc_atomic_ignore_off_page
312 # define zmalloc_and_zero GC_malloc
313 # define zrealloc GC_realloc
314 # define zstrdup GC_strdup
317 # endif /* GC_DEBUG_FLAG */
322 #define zmalloc_atomic F&^!
323 #define zmalloc_and_zero F&^!
324 #define zrealloc F&^!
325 #define zstrdrup F&^!
328 /* also define libc mem funs */
329 #define ymalloc malloc
330 #define ycalloc(n, m) calloc(n, m)
331 #define ymalloc_atomic(n) ycalloc(1, n)
332 #define ymalloc_and_zero(x) ycalloc(1, x)
333 #define yrealloc realloc
334 #define ystrdup strdup
335 #define yfree(x) free(x)
336 /* and their convenience companions */
337 #define ynew(type) ((type*)ymalloc(sizeof(type)))
338 #define ynew_array(type, len) ((type*)ymalloc((len) * sizeof(type)))
339 #define ynew_and_zero(type) ((type*)ymalloc_and_zero(sizeof(type)))
340 #define ynew_array_and_zero(type, len) \
341 ((type*)ymalloc_and_zero((len) * sizeof(type)))
342 #define YREALLOC_ARRAY(ptr, type, len) \
343 ((void)(ptr = (type *)yrealloc(ptr, (len) * sizeof (type))))
345 #if defined HAVE_BDWGC && defined EF_USE_BDWGC
346 /* and now the x* series */
347 # define xmalloc zmalloc
348 # define xcalloc zcalloc
349 # define xmalloc_atomic zmalloc_atomic
350 # define xmalloc_and_zero zmalloc_and_zero
351 # define xrealloc zrealloc
352 # define xstrdup zstrdup
353 # if defined ERROR_CHECK_MALLOC
354 # define xfree(args...) zfree(args)
355 # else /* !ERROR_CHECK_MALLOC */
356 # define xfree(args...)
357 # endif /* ERROR_CHECK_MALLOC */
360 void *xmalloc(size_t size);
361 void *xmalloc_atomic(size_t size);
362 void *xmalloc_and_zero(size_t size);
363 void *xrealloc(void *, size_t size);
364 char *xstrdup(const char *);
365 # if defined ERROR_CHECK_MALLOC
366 # if SIZEOF_VOID_P == 4
367 # define xfree(lvalue) \
369 void *volatile *xfree_ptr = \
371 ((volatile void*)&(lvalue)); \
372 assert(*xfree_ptr != (void*)0xB00BB4BE); \
374 *xfree_ptr = (void*)0xB00BB4BE; \
376 # elif SIZEOF_VOID_P == 8
377 # define xfree(lvalue) \
379 void *volatile *xfree_ptr = \
381 ((volatile void*)&(lvalue)); \
382 assert(*xfree_ptr != (void*)0xCAFEBABEDEADBEEF); \
384 *xfree_ptr = (void*)0xCAFEBABEDEADBEEF; \
387 # error "Strange-arse system detected. Watch a movie, it\'s more fun!"
389 # else /* !ERROR_CHECK_MALLOC */
390 # define xfree(args...) yfree(args)
391 # endif /* ERROR_CHECK_MALLOC */