# endif /* GNUC */
#endif
+/* No type has a greater alignment requirement than max_align_t.
+ (except perhaps for types we don't use, like long double) */
+typedef union
+{
+ struct { long l; } l;
+ struct { void *p; } p;
+ struct { void (*f)(void); } f;
+ struct { double d; } d;
+} max_align_t;
+
#ifndef ALIGNOF
# if defined (__GNUC__) && (__GNUC__ >= 2)
-# define ALIGNOF(x) __alignof__ (x)
+/* gcc has an extension that gives us exactly what we want. */
+# define ALIGNOF(type) __alignof__ (type)
+# elif ! defined (__cplusplus)
+/* The following is mostly portable, except that:
+ - it doesn't work for inside out declarations like void (*) (void).
+ (so just call ALIGNOF with a typedef'ed name)
+ - it doesn't work with C++. The C++ committee has decided,
+ in its infinite wisdom, that:
+ "Types must be declared in declarations, not in expressions." */
+# define ALIGNOF(type) offsetof (struct { char c; type member; }, member)
# else
-# define ALIGNOF(x) sizeof (x)
+/* C++ is annoying, but it has a big bag of tricks.
+ The following doesn't have the "inside out" declaration bug C does. */
+template<typename T> struct alignment_trick { char c; T member; };
+# define ALIGNOF(type) offsetof (alignment_trick<type>, member)
# endif
-#endif
+#endif /* ALIGNOF */
#define ALIGN_SIZE(len, unit) \
((((len) + (unit) - 1) / (unit)) * (unit))
/* #### Yuck, this is kind of evil */
#define ALIGN_PTR(ptr, unit) \
- ((void *) ALIGN_SIZE ((long) (ptr), unit))
+ ((void *) ALIGN_SIZE ((size_t) (ptr), unit))
#ifndef DO_NOTHING
#define DO_NOTHING do {} while (0)
/* EMACS_INT is the underlying integral type into which a Lisp_Object must fit.
In particular, it must be large enough to contain a pointer.
- config.h can override this, e.g. to use `long long' for bigger lisp ints. */
+ config.h can override this, e.g. to use `long long' for bigger lisp ints.
+
+ #### In point of fact, it would NOT be a good idea for config.h to mess
+ with EMACS_INT. A lot of code makes the basic assumption that EMACS_INT
+ is the size of a pointer. */
#ifndef SIZEOF_EMACS_INT
# define SIZEOF_EMACS_INT SIZEOF_VOID_P
typedef int Emchar;
/* Different ways of referring to a position in a buffer. We use
- the typedefs in preference to 'int' to make it clearer what
+ the typedefs in preference to 'EMACS_INT' to make it clearer what
sort of position is being used. See extents.c for a description
of the different positions. We put them here instead of in
buffer.h (where they rightfully belong) to avoid syntax errors
/* structure/other typedefs */
/* ------------------------------- */
+/* Counts of bytes or array elements */
+typedef EMACS_INT Memory_count;
+typedef EMACS_INT Element_count;
+
typedef struct lstream Lstream;
typedef unsigned int face_index;
#define INT_VALBITS (BITS_PER_EMACS_INT - INT_GCBITS)
#define VALBITS (BITS_PER_EMACS_INT - GCBITS)
-#define EMACS_INT_MAX ((EMACS_INT) ((1UL << INT_VALBITS) -1UL))
+#define EMACS_INT_MAX ((EMACS_INT) ((1UL << (INT_VALBITS - 1)) -1UL))
#define EMACS_INT_MIN (-(EMACS_INT_MAX) - 1)
#ifdef USE_UNION_TYPE
#endif /* not MULE */
-/* Return the true size of a struct with a variable-length array field. */
-#define FLEXIBLE_ARRAY_STRUCT_SIZEOF(flexible_array_structtype, \
- flexible_array_field, \
- flexible_array_length) \
- (offsetof (flexible_array_structtype, flexible_array_field) + \
- (offsetof (flexible_array_structtype, flexible_array_field[1]) - \
- offsetof (flexible_array_structtype, flexible_array_field[0])) * \
- (flexible_array_length))
+/* Return the true aligned size of a struct whose last member is a
+ variable-length array field. (this is known as the "struct hack") */
+/* Implementation: in practice, structtype and fieldtype usually have
+ the same alignment, but we can't be sure. We need to use
+ ALIGN_SIZE to be absolutely sure of getting the correct alignment.
+ To help the compiler's optimizer, we use a ternary expression that
+ only a very stupid compiler would fail to correctly simplify. */
+#define FLEXIBLE_ARRAY_STRUCT_SIZEOF(structtype, \
+ fieldtype, \
+ fieldname, \
+ array_length) \
+(ALIGNOF (structtype) == ALIGNOF (fieldtype) \
+ ? (offsetof (structtype, fieldname) + \
+ (offsetof (structtype, fieldname[1]) - \
+ offsetof (structtype, fieldname[0])) * \
+ (array_length)) \
+ : (ALIGN_SIZE \
+ ((offsetof (structtype, fieldname) + \
+ (offsetof (structtype, fieldname[1]) - \
+ offsetof (structtype, fieldname[0])) * \
+ (array_length)), \
+ ALIGNOF (structtype))))
/*------------------------------ vector --------------------------------*/
/* threshold for doing another gc */
-extern EMACS_INT gc_cons_threshold;
+extern Fixnum gc_cons_threshold;
/* Structure for recording stack slots that need marking */
extern Lisp_Object_ptr_dynarr *staticpros;
+void register_post_gc_action (void (*fun) (void *), void *arg);
+
/* Call staticpro (&var) to protect static variable `var'. */
void staticpro (Lisp_Object *);
/* var will not be saved at dump time */
void staticpro_nodump (Lisp_Object *);
-/* Call dump_add_root_struct_ptr (&var, &desc) to dump the structure pointed to by `var'. */
+/* dump_add_root_struct_ptr (&var, &desc) dumps the structure pointed to by `var'. */
#ifdef PDUMP
void dump_add_root_struct_ptr (void *, const struct struct_description *);
#else
#define dump_add_root_struct_ptr(varaddr,descaddr) DO_NOTHING
#endif
-/* Call dump_add_opaque (&var, size) to dump the opaque static structure `var'. */
+/* dump_add_opaque (&var, size) dumps the opaque static structure `var'. */
#ifdef PDUMP
void dump_add_opaque (void *, size_t);
#else
#define dump_add_opaque(varaddr,size) DO_NOTHING
#endif
+/* Call dump_add_opaque_int (&int_var) to dump `int_var', of type `int'. */
+#ifdef PDUMP
+#define dump_add_opaque_int(int_varaddr) do { \
+ int *dao_ = (int_varaddr); /* type check */ \
+ dump_add_opaque (dao_, sizeof (*dao_)); \
+} while (0)
+#else
+#define dump_add_opaque_int(int_varaddr) DO_NOTHING
+#endif
+
+/* Call dump_add_opaque_fixnum (&fixnum_var) to dump `fixnum_var', of type `Fixnum'. */
+#ifdef PDUMP
+#define dump_add_opaque_fixnum(fixnum_varaddr) do { \
+ Fixnum *dao_ = (fixnum_varaddr); /* type check */ \
+ dump_add_opaque (dao_, sizeof (*dao_)); \
+} while (0)
+#else
+#define dump_add_opaque_fixnum(fixnum_varaddr) DO_NOTHING
+#endif
+
/* Call dump_add_root_object (&var) to ensure that var is properly updated after pdump. */
#ifdef PDUMP
void dump_add_root_object (Lisp_Object *);
arith_grtr_or_equal };
Lisp_Object arithcompare (Lisp_Object, Lisp_Object, enum arith_comparison);
+/* Do NOT use word_to_lisp or wasteful_word_to_lisp to decode time_t's
+ unless you KNOW arg is non-negative. They cannot return negative
+ values! Use make_time. */
Lisp_Object word_to_lisp (unsigned int);
unsigned int lisp_to_word (Lisp_Object);
void buffer_insert1 (struct buffer *, Lisp_Object);
Lisp_Object make_string_from_buffer (struct buffer *, Bufpos, Charcount);
Lisp_Object make_string_from_buffer_no_extents (struct buffer *, Bufpos, Charcount);
+Lisp_Object make_time (time_t);
Lisp_Object save_excursion_save (void);
Lisp_Object save_restriction_save (void);
Lisp_Object save_excursion_restore (Lisp_Object);
extern int noninteractive, noninteractive1;
extern int fatal_error_in_progress;
extern int preparing_for_armageddon;
-extern int emacs_priority;
+extern Fixnum emacs_priority;
extern int running_asynch_code;
extern int suppress_early_error_handler_backtrace;
extern Lisp_Object Qvoid_function, Qvoid_variable;
extern Lisp_Object Qwindow_live_p, Qwrong_number_of_arguments;
extern Lisp_Object Qwrong_type_argument, Qyes_or_no_p;
+extern Lisp_Object Qgtk;
#define SYMBOL(fou) extern Lisp_Object fou
#define SYMBOL_KEYWORD(la_cle_est_fou) extern Lisp_Object la_cle_est_fou