Add an EXFUN for `Ffind_char'.

[chise/xemacs-chise.git-] / src / lisp.h

diff --git a/src/lisp.h b/src/lisp.h
index f179c59..a57ed02 100644 (file)
--- 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<typename T> struct alignment_trick { char c; T member; };
+#  define ALIGNOF(type) offsetof (alignment_trick<type>, 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;
 
@@ -3106,6 +3133,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 +3244,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;