X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Flisp.h;h=82accacaaa4ce80cc3b40b1bafb3bfa3ae576447;hb=98f1518a09e923a4f8b14b6a637cc283f02719bd;hp=f179c5997ca098d5f9d53840b9d594d43a0ad4af;hpb=5483e97d616f1d057edccd2683b499bcf75c402a;p=chise%2Fxemacs-chise.git- diff --git a/src/lisp.h b/src/lisp.h index f179c59..82accac 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -216,13 +216,10 @@ typedef union "Types must be declared in declarations, not in expressions." */ # define ALIGNOF(type) offsetof (struct { char c; type member; }, member) # else -/* The following should be completely portable, but might give values - that are larger than necessary. But never larger than the maximum - possible alignment. */ -# define ALIGNOF(type) \ -((sizeof (type) % sizeof (max_align_t)) == 0 ? \ - sizeof (max_align_t) : \ - (sizeof (type) % sizeof (max_align_t))) +/* C++ is annoying, but it has a big bag of tricks. + The following doesn't have the "inside out" declaration bug C does. */ +template struct alignment_trick { char c; T member; }; +# define ALIGNOF(type) offsetof (alignment_trick, member) # endif #endif /* ALIGNOF */ @@ -1203,14 +1200,28 @@ void set_string_char (Lisp_String *s, Charcount i, Emchar c); #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 --------------------------------*/ @@ -1892,7 +1903,7 @@ extern EMACS_INT consing_since_gc; /* threshold for doing another gc */ -extern EMACS_INT gc_cons_threshold; +extern Fixnum gc_cons_threshold; /* Structure for recording stack slots that need marking */ @@ -2139,20 +2150,40 @@ 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 *); @@ -2262,10 +2293,6 @@ typedef unsigned long uintptr_t; void release_breathing_space (void); Lisp_Object noseeum_cons (Lisp_Object, Lisp_Object); Lisp_Object make_vector (size_t, Lisp_Object); -#ifdef HAVE_GGC -Lisp_Object make_older_vector (size_t, Lisp_Object); -void make_vector_newer (Lisp_Object); -#endif Lisp_Object vector1 (Lisp_Object); Lisp_Object vector2 (Lisp_Object, Lisp_Object); Lisp_Object vector3 (Lisp_Object, Lisp_Object, Lisp_Object); @@ -2419,7 +2446,7 @@ Lisp_Object decode_path (const char *); 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; @@ -2912,6 +2939,7 @@ EXFUN (Fcar, 1); EXFUN (Fcar_safe, 1); EXFUN (Fcdr, 1); EXFUN (Fchar_after, 2); +EXFUN (Fchar_ref_p, 1); EXFUN (Fchar_to_string, 1); EXFUN (Fcheck_valid_plist, 1); EXFUN (Fvalid_plist_p, 1); @@ -3106,6 +3134,7 @@ EXFUN (Fspecifier_spec_list, 4); EXFUN (Fstring_equal, 2); EXFUN (Fstring_lessp, 2); EXFUN (Fstring_match, 4); +EXFUN (Fstring_to_number, 2); EXFUN (Fsub1, 1); EXFUN (Fsubr_max_args, 1); EXFUN (Fsubr_min_args, 1); @@ -3216,6 +3245,9 @@ extern Lisp_Object Qtext_image_instance_p; extern Lisp_Object Qtop_level; extern Lisp_Object Qtrue_list_p; extern Lisp_Object Qunbound, Qunderflow_error; +#ifdef UTF2000 +extern Lisp_Object Qunloaded; +#endif extern Lisp_Object Qunderline, Quser_files_and_directories; extern Lisp_Object Qvalues; extern Lisp_Object Qvariable_documentation, Qvariable_domain;