--- a/src/buffer.h	Mon Aug 13 11:19:22 2007 +0200
+++ b/src/buffer.h	Mon Aug 13 11:20:41 2007 +0200
@@ -29,8 +29,8 @@
    Ben Wing: almost completely rewritten for Mule, 19.12.
  */
 
-#ifndef INCLUDED_buffer_h_
-#define INCLUDED_buffer_h_
+#ifndef _XEMACS_BUFFER_H_
+#define _XEMACS_BUFFER_H_
 
 #ifdef MULE
 #include "mule-charset.h"
@@ -166,7 +166,7 @@
   /* The markers that refer to this buffer.  This is actually a single
      marker -- successive elements in its marker `chain' are the other
      markers referring to this buffer */
-  Lisp_Marker *markers;
+  struct Lisp_Marker *markers;
 
   /* The buffer's extent info.  This is its own type, an extent-info
      object (done this way for ease in marking / finalizing). */
@@ -198,7 +198,7 @@
   int modtime;
 
   /* the value of text->modiff at the last auto-save.  */
-  long auto_save_modified;
+  int auto_save_modified;
 
   /* The time at which we detected a failure to auto-save,
      Or -1 if we didn't have a failure.  */
@@ -219,6 +219,7 @@
 #define XBUFFER(x) XRECORD (x, buffer, struct buffer)
 #define XSETBUFFER(x, p) XSETRECORD (x, p, buffer)
 #define BUFFERP(x) RECORDP (x, buffer)
+#define GC_BUFFERP(x) GC_RECORDP (x, buffer)
 #define CHECK_BUFFER(x) CHECK_RECORD (x, buffer)
 #define CONCHECK_BUFFER(x) CONCHECK_RECORD (x, buffer)
 
@@ -408,9 +409,6 @@
 #define REAL_INC_CHARPTR(ptr) \
   ((void) ((ptr) += REP_BYTES_BY_FIRST_BYTE (* (unsigned char *) (ptr))))
 
-#define REAL_INC_CHARBYTIND(ptr,pos) \
-  (pos += REP_BYTES_BY_FIRST_BYTE (* (unsigned char *) (ptr)))
-
 #define REAL_DEC_CHARPTR(ptr) do {	\
   (ptr)--;				\
 } while (!VALID_CHARPTR_P (ptr))
@@ -421,14 +419,9 @@
   REAL_INC_CHARPTR (ptr);		\
 } while (0)
 
-#define INC_CHARBYTIND(ptr,pos) do {		\
-  ASSERT_VALID_CHARPTR (ptr);		\
-  REAL_INC_CHARBYTIND (ptr,pos);		\
-} while (0)
-
 #define DEC_CHARPTR(ptr) do {			\
-  const Bufbyte *dc_ptr1 = (ptr);		\
-  const Bufbyte *dc_ptr2 = dc_ptr1;		\
+  CONST Bufbyte *dc_ptr1 = (ptr);		\
+  CONST Bufbyte *dc_ptr2 = dc_ptr1;		\
   REAL_DEC_CHARPTR (dc_ptr2);			\
   assert (dc_ptr1 - dc_ptr2 ==			\
 	  REP_BYTES_BY_FIRST_BYTE (*dc_ptr2));	\
@@ -436,7 +429,6 @@
 } while (0)
 
 #else /* ! ERROR_CHECK_BUFPOS */
-#define INC_CHARBYTIND(ptr,pos) REAL_INC_CHARBYTIND (ptr,pos)
 #define INC_CHARPTR(ptr) REAL_INC_CHARPTR (ptr)
 #define DEC_CHARPTR(ptr) REAL_DEC_CHARPTR (ptr)
 #endif /* ! ERROR_CHECK_BUFPOS */
@@ -470,10 +462,9 @@
 /*     section of internally-formatted text 			  */
 /* -------------------------------------------------------------- */
 
-INLINE_HEADER const Bufbyte *
-charptr_n_addr (const Bufbyte *ptr, Charcount offset);
-INLINE_HEADER const Bufbyte *
-charptr_n_addr (const Bufbyte *ptr, Charcount offset)
+INLINE CONST Bufbyte *charptr_n_addr (CONST Bufbyte *ptr, Charcount offset);
+INLINE CONST Bufbyte *
+charptr_n_addr (CONST Bufbyte *ptr, Charcount offset)
 {
   return ptr + charcount_to_bytecount (ptr, offset);
 }
@@ -488,21 +479,21 @@
 
 #ifdef MULE
 
-Emchar non_ascii_charptr_emchar (const Bufbyte *ptr);
+Emchar non_ascii_charptr_emchar (CONST Bufbyte *ptr);
 Bytecount non_ascii_set_charptr_emchar (Bufbyte *ptr, Emchar c);
-Bytecount non_ascii_charptr_copy_char (const Bufbyte *ptr, Bufbyte *ptr2);
+Bytecount non_ascii_charptr_copy_char (CONST Bufbyte *ptr, Bufbyte *ptr2);
 
-INLINE_HEADER Emchar charptr_emchar (const Bufbyte *ptr);
-INLINE_HEADER Emchar
-charptr_emchar (const Bufbyte *ptr)
+INLINE Emchar charptr_emchar (CONST Bufbyte *ptr);
+INLINE Emchar
+charptr_emchar (CONST Bufbyte *ptr)
 {
   return BYTE_ASCII_P (*ptr) ?
     simple_charptr_emchar (ptr) :
     non_ascii_charptr_emchar (ptr);
 }
 
-INLINE_HEADER Bytecount set_charptr_emchar (Bufbyte *ptr, Emchar x);
-INLINE_HEADER Bytecount
+INLINE Bytecount set_charptr_emchar (Bufbyte *ptr, Emchar x);
+INLINE Bytecount
 set_charptr_emchar (Bufbyte *ptr, Emchar x)
 {
   return !CHAR_MULTIBYTE_P (x) ?
@@ -510,10 +501,9 @@
     non_ascii_set_charptr_emchar (ptr, x);
 }
 
-INLINE_HEADER Bytecount
-charptr_copy_char (const Bufbyte *ptr, Bufbyte *ptr2);
-INLINE_HEADER Bytecount
-charptr_copy_char (const Bufbyte *ptr, Bufbyte *ptr2)
+INLINE Bytecount charptr_copy_char (CONST Bufbyte *ptr, Bufbyte *ptr2);
+INLINE Bytecount
+charptr_copy_char (CONST Bufbyte *ptr, Bufbyte *ptr2)
 {
   return BYTE_ASCII_P (*ptr) ?
     simple_charptr_copy_char (ptr, ptr2) :
@@ -540,8 +530,8 @@
 
 int non_ascii_valid_char_p (Emchar ch);
 
-INLINE_HEADER int valid_char_p (Emchar ch);
-INLINE_HEADER int
+INLINE int valid_char_p (Emchar ch);
+INLINE int
 valid_char_p (Emchar ch)
 {
   return ((unsigned int) (ch) <= 0xff) || non_ascii_valid_char_p (ch);
@@ -559,8 +549,8 @@
 
 #ifdef ERROR_CHECK_TYPECHECK
 
-INLINE_HEADER Emchar XCHAR_OR_CHAR_INT (Lisp_Object obj);
-INLINE_HEADER Emchar
+INLINE Emchar XCHAR_OR_CHAR_INT (Lisp_Object obj);
+INLINE Emchar
 XCHAR_OR_CHAR_INT (Lisp_Object obj)
 {
   assert (CHAR_OR_CHAR_INTP (obj));
@@ -569,7 +559,7 @@
 
 #else
 
-#define XCHAR_OR_CHAR_INT(obj) (CHARP (obj) ? XCHAR (obj) : XINT (obj))
+#define XCHAR_OR_CHAR_INT(obj) (CHARP ((obj)) ? XCHAR ((obj)) : XINT ((obj)))
 
 #endif
 
@@ -624,25 +614,25 @@
 /*----------------------------------------------------------------------*/
 
 /* Convert the address of a byte in the buffer into a position.  */
-INLINE_HEADER Bytind BI_BUF_PTR_BYTE_POS (struct buffer *buf, Bufbyte *ptr);
-INLINE_HEADER Bytind
+INLINE Bytind BI_BUF_PTR_BYTE_POS (struct buffer *buf, Bufbyte *ptr);
+INLINE Bytind
 BI_BUF_PTR_BYTE_POS (struct buffer *buf, Bufbyte *ptr)
 {
-  return (ptr - buf->text->beg + 1
-	  - ((ptr - buf->text->beg + 1) > buf->text->gpt
-	     ? buf->text->gap_size : 0));
+  return ((ptr) - (buf)->text->beg + 1
+	  - ((ptr - (buf)->text->beg + 1) > (buf)->text->gpt
+	     ? (buf)->text->gap_size : 0));
 }
 
 #define BUF_PTR_BYTE_POS(buf, ptr) \
   bytind_to_bufpos (buf, BI_BUF_PTR_BYTE_POS (buf, ptr))
 
 /* Address of byte at position POS in buffer. */
-INLINE_HEADER Bufbyte * BI_BUF_BYTE_ADDRESS (struct buffer *buf, Bytind pos);
-INLINE_HEADER Bufbyte *
+INLINE Bufbyte * BI_BUF_BYTE_ADDRESS (struct buffer *buf, Bytind pos);
+INLINE Bufbyte *
 BI_BUF_BYTE_ADDRESS (struct buffer *buf, Bytind pos)
 {
-  return (buf->text->beg +
-	  ((pos >= buf->text->gpt ? (pos + buf->text->gap_size) : pos)
+  return ((buf)->text->beg +
+	  ((pos >= (buf)->text->gpt ? (pos + (buf)->text->gap_size) : pos)
 	   - 1));
 }
 
@@ -650,12 +640,12 @@
   BI_BUF_BYTE_ADDRESS (buf, bufpos_to_bytind (buf, pos))
 
 /* Address of byte before position POS in buffer. */
-INLINE_HEADER Bufbyte * BI_BUF_BYTE_ADDRESS_BEFORE (struct buffer *buf, Bytind pos);
-INLINE_HEADER Bufbyte *
+INLINE Bufbyte * BI_BUF_BYTE_ADDRESS_BEFORE (struct buffer *buf, Bytind pos);
+INLINE Bufbyte *
 BI_BUF_BYTE_ADDRESS_BEFORE (struct buffer *buf, Bytind pos)
 {
-  return (buf->text->beg +
-	  ((pos > buf->text->gpt ? (pos + buf->text->gap_size) : pos)
+  return ((buf)->text->beg +
+	  ((pos > (buf)->text->gpt ? (pos + (buf)->text->gap_size) : pos)
 	   - 2));
 }
 
@@ -666,32 +656,32 @@
 /*	    Converting between byte indices and memory indices		*/
 /*----------------------------------------------------------------------*/
 
-INLINE_HEADER int valid_memind_p (struct buffer *buf, Memind x);
-INLINE_HEADER int
+INLINE int valid_memind_p (struct buffer *buf, Memind x);
+INLINE int
 valid_memind_p (struct buffer *buf, Memind x)
 {
-  return ((x >= 1 && x <= (Memind) buf->text->gpt) ||
-	  (x  > (Memind) (buf->text->gpt + buf->text->gap_size) &&
-	   x <= (Memind) (buf->text->z   + buf->text->gap_size)));
+  return ((x >= 1 && x <= (Memind) (buf)->text->gpt) ||
+	  (x  > (Memind) ((buf)->text->gpt + (buf)->text->gap_size) &&
+	   x <= (Memind) ((buf)->text->z   + (buf)->text->gap_size)));
 }
 
-INLINE_HEADER Memind bytind_to_memind (struct buffer *buf, Bytind x);
-INLINE_HEADER Memind
+INLINE Memind bytind_to_memind (struct buffer *buf, Bytind x);
+INLINE Memind
 bytind_to_memind (struct buffer *buf, Bytind x)
 {
-  return (Memind) ((x > buf->text->gpt) ? (x + buf->text->gap_size) : x);
+  return (Memind) ((x > (buf)->text->gpt) ? (x + (buf)->text->gap_size) : x);
 }
 
 
-INLINE_HEADER Bytind memind_to_bytind (struct buffer *buf, Memind x);
-INLINE_HEADER Bytind
+INLINE Bytind memind_to_bytind (struct buffer *buf, Memind x);
+INLINE Bytind
 memind_to_bytind (struct buffer *buf, Memind x)
 {
 #ifdef ERROR_CHECK_BUFPOS
   assert (valid_memind_p (buf, x));
 #endif
-  return (Bytind) ((x > (Memind) buf->text->gpt) ?
-		   x - buf->text->gap_size :
+  return (Bytind) ((x > (Memind) (buf)->text->gpt) ?
+		   x - (buf)->text->gap_size :
 		   x);
 }
 
@@ -904,16 +894,16 @@
   VALIDATE_BYTIND_BACKWARD (buf, x);			\
 } while (0)
 
-INLINE_HEADER Bytind prev_bytind (struct buffer *buf, Bytind x);
-INLINE_HEADER Bytind
+INLINE Bytind prev_bytind (struct buffer *buf, Bytind x);
+INLINE Bytind
 prev_bytind (struct buffer *buf, Bytind x)
 {
   DEC_BYTIND (buf, x);
   return x;
 }
 
-INLINE_HEADER Bytind next_bytind (struct buffer *buf, Bytind x);
-INLINE_HEADER Bytind
+INLINE Bytind next_bytind (struct buffer *buf, Bytind x);
+INLINE Bytind
 next_bytind (struct buffer *buf, Bytind x)
 {
   INC_BYTIND (buf, x);
@@ -975,8 +965,8 @@
 
 extern short three_to_one_table[];
 
-INLINE_HEADER int real_bufpos_to_bytind (struct buffer *buf, Bufpos x);
-INLINE_HEADER int
+INLINE int real_bufpos_to_bytind (struct buffer *buf, Bufpos x);
+INLINE int
 real_bufpos_to_bytind (struct buffer *buf, Bufpos x)
 {
   if (x >= buf->text->mule_bufmin && x <= buf->text->mule_bufmax)
@@ -987,8 +977,8 @@
     return bufpos_to_bytind_func (buf, x);
 }
 
-INLINE_HEADER int real_bytind_to_bufpos (struct buffer *buf, Bytind x);
-INLINE_HEADER int
+INLINE int real_bytind_to_bufpos (struct buffer *buf, Bytind x);
+INLINE int
 real_bytind_to_bufpos (struct buffer *buf, Bytind x)
 {
   if (x >= buf->text->mule_bytmin && x <= buf->text->mule_bytmax)
@@ -1040,277 +1030,305 @@
 #define BUF_CHARPTR_COPY_CHAR(buf, pos, str) \
   BI_BUF_CHARPTR_COPY_CHAR (buf, bufpos_to_bytind (buf, pos), str)
 
+
+
 
 /************************************************************************/
-/*                                                                      */
-/*         Converting between internal and external format              */
-/*                                                                      */
+/*									*/
+/*		    working with externally-formatted data		*/
+/*									*/
 /************************************************************************/
-/*
-  All client code should use only the two macros
-
-  TO_EXTERNAL_FORMAT (source_type, source, sink_type, sink, coding_system)
-  TO_INTERNAL_FORMAT (source_type, source, sink_type, sink, coding_system)
-
-  Typical use is
-
-  TO_EXTERNAL_FORMAT (DATA, (ptr, len),
-                      LISP_BUFFER, buffer,
-		      Qfile_name);
-
-  The source or sink can be specified in one of these ways:
-
-  DATA,   (ptr, len),    // input data is a fixed buffer of size len
-  ALLOCA, (ptr, len),    // output data is in a alloca()ed buffer of size len
-  MALLOC, (ptr, len),    // output data is in a malloc()ed buffer of size len
-  C_STRING_ALLOCA, ptr,  // equivalent to ALLOCA (ptr, len_ignored) on output.
-  C_STRING_MALLOC, ptr,  // equivalent to MALLOC (ptr, len_ignored) on output.
-  C_STRING,     ptr,     // equivalent to DATA, (ptr, strlen (ptr) + 1) on input
-  LISP_STRING,  string,  // input or output is a Lisp_Object of type string
-  LISP_BUFFER,  buffer,  // output is written to (point) in lisp buffer
-  LISP_LSTREAM, lstream, // input or output is a Lisp_Object of type lstream
-  LISP_OPAQUE,  object,  // input or output is a Lisp_Object of type opaque
-
-  When specifying the sink, use lvalues, since the macro will assign to them,
-  except when the sink is an lstream or a lisp buffer.
-
-  The macros accept the kinds of sources and sinks appropriate for
-  internal and external data representation.  See the type_checking_assert
-  macros below for the actual allowed types.
-
-  Since some sources and sinks use one argument (a Lisp_Object) to
-  specify them, while others take a (pointer, length) pair, we use
-  some C preprocessor trickery to allow pair arguments to be specified
-  by parenthesizing them, as in the examples above.
-
-  Anything prefixed by dfc_ (`data format conversion') is private.
-  They are only used to implement these macros.
-
-  Using C_STRING* is appropriate for using with external APIs that take
-  null-terminated strings.  For internal data, we should try to be
-  '\0'-clean - i.e. allow arbitrary data to contain embedded '\0'.
-
-  Sometime in the future we might allow output to C_STRING_ALLOCA or
-  C_STRING_MALLOC _only_ with TO_EXTERNAL_FORMAT(), not
-  TO_INTERNAL_FORMAT().  */
 
-#define TO_EXTERNAL_FORMAT(source_type, source, sink_type, sink, coding_system)	\
-do {										\
-  dfc_conversion_type dfc_simplified_source_type;				\
-  dfc_conversion_type dfc_simplified_sink_type;					\
-  dfc_conversion_data dfc_source;						\
-  dfc_conversion_data dfc_sink;							\
-										\
-  type_checking_assert								\
-    ((DFC_TYPE_##source_type == DFC_TYPE_DATA ||				\
-      DFC_TYPE_##source_type == DFC_TYPE_C_STRING ||				\
-      DFC_TYPE_##source_type == DFC_TYPE_LISP_STRING ||				\
-      DFC_TYPE_##source_type == DFC_TYPE_LISP_OPAQUE ||				\
-      DFC_TYPE_##source_type == DFC_TYPE_LISP_LSTREAM)				\
-    &&										\
-     (DFC_TYPE_##sink_type == DFC_TYPE_ALLOCA ||				\
-      DFC_TYPE_##sink_type == DFC_TYPE_MALLOC ||				\
-      DFC_TYPE_##sink_type == DFC_TYPE_C_STRING_ALLOCA ||			\
-      DFC_TYPE_##sink_type == DFC_TYPE_C_STRING_MALLOC ||			\
-      DFC_TYPE_##sink_type == DFC_TYPE_LISP_LSTREAM ||				\
-      DFC_TYPE_##sink_type == DFC_TYPE_LISP_OPAQUE));				\
-										\
-  DFC_SOURCE_##source_type##_TO_ARGS (source);					\
-  DFC_SINK_##sink_type##_TO_ARGS     (sink);					\
-										\
-  DFC_CONVERT_TO_EXTERNAL_FORMAT (dfc_simplified_source_type, &dfc_source,	\
-				  coding_system,				\
-				  dfc_simplified_sink_type,   &dfc_sink);	\
-										\
-  DFC_##sink_type##_USE_CONVERTED_DATA (sink);					\
-} while (0)
-
-#define TO_INTERNAL_FORMAT(source_type, source, sink_type, sink, coding_system)	\
-do {										\
-  dfc_conversion_type dfc_simplified_source_type;				\
-  dfc_conversion_type dfc_simplified_sink_type;					\
-  dfc_conversion_data dfc_source;						\
-  dfc_conversion_data dfc_sink;							\
-										\
-  type_checking_assert								\
-    ((DFC_TYPE_##source_type == DFC_TYPE_DATA ||				\
-      DFC_TYPE_##source_type == DFC_TYPE_C_STRING ||				\
-      DFC_TYPE_##source_type == DFC_TYPE_LISP_OPAQUE ||				\
-      DFC_TYPE_##source_type == DFC_TYPE_LISP_LSTREAM)				\
-     &&										\
-     (DFC_TYPE_##sink_type == DFC_TYPE_ALLOCA ||				\
-      DFC_TYPE_##sink_type == DFC_TYPE_MALLOC ||				\
-      DFC_TYPE_##sink_type == DFC_TYPE_C_STRING_ALLOCA ||			\
-      DFC_TYPE_##sink_type == DFC_TYPE_C_STRING_MALLOC ||			\
-      DFC_TYPE_##sink_type == DFC_TYPE_LISP_STRING ||				\
-      DFC_TYPE_##sink_type == DFC_TYPE_LISP_LSTREAM ||				\
-      DFC_TYPE_##sink_type == DFC_TYPE_LISP_BUFFER));				\
-										\
-  DFC_SOURCE_##source_type##_TO_ARGS (source);					\
-  DFC_SINK_##sink_type##_TO_ARGS     (sink);					\
-										\
-  DFC_CONVERT_TO_INTERNAL_FORMAT (dfc_simplified_source_type, &dfc_source,	\
-				  coding_system,				\
-				  dfc_simplified_sink_type,   &dfc_sink);	\
-										\
-  DFC_##sink_type##_USE_CONVERTED_DATA (sink);					\
-} while (0)
+/* Sometimes strings need to be converted into one or another
+   external format, for passing to a library function. (Note
+   that we encapsulate and automatically convert the arguments
+   of some functions, but not others.) At times this conversion
+   also has to go the other way -- i.e. when we get external-
+   format strings back from a library function.
+*/
 
 #ifdef FILE_CODING
-#define DFC_CONVERT_TO_EXTERNAL_FORMAT dfc_convert_to_external_format
-#define DFC_CONVERT_TO_INTERNAL_FORMAT dfc_convert_to_internal_format
-#else
-/* ignore coding_system argument */
-#define DFC_CONVERT_TO_EXTERNAL_FORMAT(a, b, coding_system, c, d) \
- dfc_convert_to_external_format (a, b, c, d)
-#define DFC_CONVERT_TO_INTERNAL_FORMAT(a, b, coding_system, c, d) \
- dfc_convert_to_internal_format (a, b, c, d)
-#endif
-
-typedef union
-{
-  struct { const void *ptr; size_t len; } data;
-  Lisp_Object lisp_object;
-} dfc_conversion_data;
-
-enum dfc_conversion_type
-{
-  DFC_TYPE_DATA,
-  DFC_TYPE_ALLOCA,
-  DFC_TYPE_MALLOC,
-  DFC_TYPE_C_STRING,
-  DFC_TYPE_C_STRING_ALLOCA,
-  DFC_TYPE_C_STRING_MALLOC,
-  DFC_TYPE_LISP_STRING,
-  DFC_TYPE_LISP_LSTREAM,
-  DFC_TYPE_LISP_OPAQUE,
-  DFC_TYPE_LISP_BUFFER
-};
-typedef enum dfc_conversion_type dfc_conversion_type;
 
 /* WARNING: These use a static buffer.  This can lead to disaster if
-   these functions are not used *very* carefully.  Another reason to only use
-   TO_EXTERNAL_FORMATf() and TO_INTERNAL_FORMAT(). */
-void
-dfc_convert_to_external_format (dfc_conversion_type source_type,
-				dfc_conversion_data *source,
-#ifdef FILE_CODING
-				Lisp_Object coding_system,
-#endif
-				dfc_conversion_type sink_type,
-				dfc_conversion_data *sink);
-void
-dfc_convert_to_internal_format (dfc_conversion_type source_type,
-				dfc_conversion_data *source,
-#ifdef FILE_CODING
-				Lisp_Object coding_system,
-#endif
-				dfc_conversion_type sink_type,
-				dfc_conversion_data *sink);
-/* CPP Trickery */
-#define DFC_CPP_CAR(x,y) (x)
-#define DFC_CPP_CDR(x,y) (y)
+   these functions are not used *very* carefully.  Under normal
+   circumstances, do not call these functions; call the front ends
+   below. */
+
+Extbyte *convert_to_external_format (CONST Bufbyte *ptr,
+				     Bytecount len,
+				     Extcount *len_out,
+				     enum external_data_format fmt);
+Bufbyte *convert_from_external_format (CONST Extbyte *ptr,
+				       Extcount len,
+				       Bytecount *len_out,
+				       enum external_data_format fmt);
+
+#else /* ! MULE */
+
+#define convert_to_external_format(ptr, len, len_out, fmt) \
+     (*(len_out) = (int) (len), (Extbyte *) (ptr))
+#define convert_from_external_format(ptr, len, len_out, fmt) \
+     (*(len_out) = (Bytecount) (len), (Bufbyte *) (ptr))
+
+#endif /* ! MULE */
+
+/* In all of the following macros we use the following general principles:
+
+   -- Functions that work with charptr's accept two sorts of charptr's:
+
+      a) Pointers to memory with a length specified.  The pointer will be
+         fundamentally of type `unsigned char *' (although labelled
+	 as `Bufbyte *' for internal-format data and `Extbyte *' for
+	 external-format data) and the length will be fundamentally of
+	 type `int' (although labelled as `Bytecount' for internal-format
+	 data and `Extcount' for external-format data).  The length is
+	 always a count in bytes.
+      b) Zero-terminated pointers; no length specified.  The pointer
+         is of type `char *', whether the data pointed to is internal-format
+	 or external-format.  These sorts of pointers are available for
+	 convenience in working with C library functions and literal
+	 strings.  In general you should use these sorts of pointers only
+	 to interface to library routines and not for general manipulation,
+	 as you are liable to lose embedded nulls and such.  This could
+	 be a big problem for routines that want Unicode-formatted data,
+	 which is likely to have lots of embedded nulls in it.
+	 (In the real world, though, external Unicode data will be UTF-8,
+	 which will not have embedded nulls and is ASCII-compatible - martin)
+
+   -- Functions that work with Lisp strings accept strings as Lisp Objects
+      (as opposed to the `struct Lisp_String *' for some of the other
+      string accessors).  This is for convenience in working with the
+      functions, as otherwise you will almost always have to call
+      XSTRING() on the object.
+
+   -- Functions that work with charptr's are not guaranteed to copy
+      their data into alloca()ed space.  Functions that work with
+      Lisp strings are, however.  The reason is that Lisp strings can
+      be relocated any time a GC happens, and it could happen at some
+      rather unexpected times.  The internal-external conversion is
+      rarely done in time-critical functions, and so the slight
+      extra time required for alloca() and copy is well-worth the
+      safety of knowing your string data won't be relocated out from
+      under you.
+      */
+
 
-/* Convert `source' to args for dfc_convert_to_*_format() */
-#define DFC_SOURCE_DATA_TO_ARGS(val) do {		\
-  dfc_source.data.ptr = DFC_CPP_CAR val;		\
-  dfc_source.data.len = DFC_CPP_CDR val;		\
-  dfc_simplified_source_type = DFC_TYPE_DATA;		\
-} while (0)
-#define DFC_SOURCE_C_STRING_TO_ARGS(val) do {		\
-  dfc_source.data.len =					\
-    strlen ((char *) (dfc_source.data.ptr = (val)));	\
-  dfc_simplified_source_type = DFC_TYPE_DATA;		\
+/* Maybe convert charptr's data into ext-format and store the result in
+   alloca()'ed space.
+
+   You may wonder why this is written in this fashion and not as a
+   function call.  With a little trickery it could certainly be
+   written this way, but it won't work because of those DAMN GCC WANKERS
+   who couldn't be bothered to handle alloca() properly on the x86
+   architecture. (If you put a call to alloca() in the argument to
+   a function call, the stack space gets allocated right in the
+   middle of the arguments to the function call and you are unbelievably
+   hosed.) */
+
+#ifdef MULE
+
+#define GET_CHARPTR_EXT_DATA_ALLOCA(ptr, len, fmt, ptr_out, len_out) do	\
+{									\
+  Bytecount gceda_len_in = (Bytecount) (len);				\
+  Extcount  gceda_len_out;						\
+  CONST Bufbyte *gceda_ptr_in = (ptr);					\
+  Extbyte *gceda_ptr_out =						\
+    convert_to_external_format (gceda_ptr_in, gceda_len_in,		\
+				&gceda_len_out, fmt);			\
+  /* If the new string is identical to the old (will be the case most	\
+     of the time), just return the same string back.  This saves	\
+     on alloca()ing, which can be useful on C alloca() machines and	\
+     on stack-space-challenged environments. */				\
+									\
+  if (gceda_len_in == gceda_len_out &&					\
+      !memcmp (gceda_ptr_in, gceda_ptr_out, gceda_len_out))		\
+    {									\
+      (ptr_out) = (Extbyte *) gceda_ptr_in;				\
+    }									\
+  else									\
+    {									\
+      (ptr_out) = (Extbyte *) alloca (1 + gceda_len_out);		\
+      memcpy ((void *) ptr_out, gceda_ptr_out, 1 + gceda_len_out);	\
+    }									\
+  (len_out) = gceda_len_out;						\
 } while (0)
-#define DFC_SOURCE_LISP_STRING_TO_ARGS(val) do {	\
-  Lisp_Object dfc_slsta = (val);			\
-  type_checking_assert (STRINGP (dfc_slsta));		\
-  dfc_source.lisp_object = dfc_slsta;			\
-  dfc_simplified_source_type = DFC_TYPE_LISP_STRING;	\
+
+#else /* ! MULE */
+
+#define GET_CHARPTR_EXT_DATA_ALLOCA(ptr, len, fmt, ptr_out, len_out) do	\
+{					\
+  (ptr_out) = (Extbyte *) (ptr);	\
+  (len_out) = (Extcount) (len);		\
 } while (0)
-#define DFC_SOURCE_LISP_LSTREAM_TO_ARGS(val) do {	\
-  Lisp_Object dfc_sllta = (val);			\
-  type_checking_assert (LSTREAMP (dfc_sllta));		\
-  dfc_source.lisp_object = dfc_sllta;			\
-  dfc_simplified_source_type = DFC_TYPE_LISP_LSTREAM;	\
-} while (0)
-#define DFC_SOURCE_LISP_OPAQUE_TO_ARGS(val) do {	\
-  Lisp_Opaque *dfc_slota = XOPAQUE (val);		\
-  dfc_source.data.ptr = OPAQUE_DATA (dfc_slota);	\
-  dfc_source.data.len = OPAQUE_SIZE (dfc_slota);	\
-  dfc_simplified_source_type = DFC_TYPE_DATA;		\
+
+#endif /* ! MULE */
+
+#define GET_C_CHARPTR_EXT_DATA_ALLOCA(ptr, fmt, ptr_out) do	\
+{								\
+  Extcount gcceda_ignored_len;					\
+  CONST Bufbyte *gcceda_ptr_in = (CONST Bufbyte *) (ptr);	\
+  Extbyte *gcceda_ptr_out;					\
+								\
+  GET_CHARPTR_EXT_DATA_ALLOCA (gcceda_ptr_in,			\
+			       strlen ((char *) gcceda_ptr_in),	\
+			       fmt,				\
+			       gcceda_ptr_out,			\
+			       gcceda_ignored_len);		\
+  (ptr_out) = (char *) gcceda_ptr_out;				\
 } while (0)
 
-/* Convert `sink' to args for dfc_convert_to_*_format() */
-#define DFC_SINK_ALLOCA_TO_ARGS(val)		\
-  dfc_simplified_sink_type = DFC_TYPE_DATA
-#define DFC_SINK_C_STRING_ALLOCA_TO_ARGS(val)	\
-  dfc_simplified_sink_type = DFC_TYPE_DATA
-#define DFC_SINK_MALLOC_TO_ARGS(val)		\
-  dfc_simplified_sink_type = DFC_TYPE_DATA
-#define DFC_SINK_C_STRING_MALLOC_TO_ARGS(val)	\
-  dfc_simplified_sink_type = DFC_TYPE_DATA
-#define DFC_SINK_LISP_STRING_TO_ARGS(val)	\
-  dfc_simplified_sink_type = DFC_TYPE_DATA
-#define DFC_SINK_LISP_OPAQUE_TO_ARGS(val)	\
-  dfc_simplified_sink_type = DFC_TYPE_DATA
-#define DFC_SINK_LISP_LSTREAM_TO_ARGS(val) do {		\
-  Lisp_Object dfc_sllta = (val);			\
-  type_checking_assert (LSTREAMP (dfc_sllta));		\
-  dfc_sink.lisp_object = dfc_sllta;			\
-  dfc_simplified_sink_type = DFC_TYPE_LISP_LSTREAM;	\
+#define GET_C_CHARPTR_EXT_BINARY_DATA_ALLOCA(ptr, ptr_out) \
+  GET_C_CHARPTR_EXT_DATA_ALLOCA (ptr, FORMAT_BINARY, ptr_out)
+#define GET_CHARPTR_EXT_BINARY_DATA_ALLOCA(ptr, len, ptr_out, len_out) \
+  GET_CHARPTR_EXT_DATA_ALLOCA (ptr, len, FORMAT_BINARY, ptr_out, len_out)
+
+#define GET_C_CHARPTR_EXT_FILENAME_DATA_ALLOCA(ptr, ptr_out) \
+  GET_C_CHARPTR_EXT_DATA_ALLOCA (ptr, FORMAT_FILENAME, ptr_out)
+#define GET_CHARPTR_EXT_FILENAME_DATA_ALLOCA(ptr, len, ptr_out, len_out) \
+  GET_CHARPTR_EXT_DATA_ALLOCA (ptr, len, FORMAT_FILENAME, ptr_out, len_out)
+
+#define GET_C_CHARPTR_EXT_CTEXT_DATA_ALLOCA(ptr, ptr_out) \
+  GET_C_CHARPTR_EXT_DATA_ALLOCA (ptr, FORMAT_CTEXT, ptr_out)
+#define GET_CHARPTR_EXT_CTEXT_DATA_ALLOCA(ptr, len, ptr_out, len_out) \
+  GET_CHARPTR_EXT_DATA_ALLOCA (ptr, len, FORMAT_CTEXT, ptr_out, len_out)
+
+/* Maybe convert external charptr's data into internal format and store
+   the result in alloca()'ed space.
+
+   You may wonder why this is written in this fashion and not as a
+   function call.  With a little trickery it could certainly be
+   written this way, but it won't work because of those DAMN GCC WANKERS
+   who couldn't be bothered to handle alloca() properly on the x86
+   architecture. (If you put a call to alloca() in the argument to
+   a function call, the stack space gets allocated right in the
+   middle of the arguments to the function call and you are unbelievably
+   hosed.) */
+
+#ifdef MULE
+
+#define GET_CHARPTR_INT_DATA_ALLOCA(ptr, len, fmt, ptr_out, len_out) do	\
+{									\
+  Extcount gcida_len_in = (Extcount) (len);				\
+  Bytecount gcida_len_out;						\
+  CONST Extbyte *gcida_ptr_in = (ptr);					\
+  Bufbyte *gcida_ptr_out =						\
+    convert_from_external_format (gcida_ptr_in, gcida_len_in,		\
+				  &gcida_len_out, fmt);			\
+  /* If the new string is identical to the old (will be the case most	\
+     of the time), just return the same string back.  This saves	\
+     on alloca()ing, which can be useful on C alloca() machines and	\
+     on stack-space-challenged environments. */				\
+									\
+  if (gcida_len_in == gcida_len_out &&					\
+      !memcmp (gcida_ptr_in, gcida_ptr_out, gcida_len_out))		\
+    {									\
+      (ptr_out) = (Bufbyte *) gcida_ptr_in;				\
+    }									\
+  else									\
+    {									\
+      (ptr_out) = (Extbyte *) alloca (1 + gcida_len_out);		\
+      memcpy ((void *) ptr_out, gcida_ptr_out, 1 + gcida_len_out);	\
+    }									\
+  (len_out) = gcida_len_out;						\
 } while (0)
-#define DFC_SINK_LISP_BUFFER_TO_ARGS(val) do {		\
-  struct buffer *dfc_slbta = XBUFFER (val);		\
-  dfc_sink.lisp_object =				\
-    make_lisp_buffer_output_stream			\
-    (dfc_slbta, BUF_PT (dfc_slbta), 0);			\
-  dfc_simplified_sink_type = DFC_TYPE_LISP_LSTREAM;	\
+
+#else /* ! MULE */
+
+#define GET_CHARPTR_INT_DATA_ALLOCA(ptr, len, fmt, ptr_out, len_out) do \
+{					\
+  (ptr_out) = (Bufbyte *) (ptr);	\
+  (len_out) = (Bytecount) (len);	\
 } while (0)
 
-/* Assign to the `sink' lvalue(s) using the converted data. */
-typedef union { char c; void *p; } *dfc_aliasing_voidpp;
-#define DFC_ALLOCA_USE_CONVERTED_DATA(sink) do {			\
-  void * dfc_sink_ret = alloca (dfc_sink.data.len + 1);			\
-  memcpy (dfc_sink_ret, dfc_sink.data.ptr, dfc_sink.data.len + 1);	\
-  ((dfc_aliasing_voidpp) &(DFC_CPP_CAR sink))->p = dfc_sink_ret;	\
-  (DFC_CPP_CDR sink) = dfc_sink.data.len;				\
-} while (0)
-#define DFC_MALLOC_USE_CONVERTED_DATA(sink) do {			\
-  void * dfc_sink_ret = xmalloc (dfc_sink.data.len + 1);		\
-  memcpy (dfc_sink_ret, dfc_sink.data.ptr, dfc_sink.data.len + 1);	\
-  ((dfc_aliasing_voidpp) &(DFC_CPP_CAR sink))->p = dfc_sink_ret;	\
-  (DFC_CPP_CDR sink) = dfc_sink.data.len;				\
-} while (0)
-#define DFC_C_STRING_ALLOCA_USE_CONVERTED_DATA(sink) do {		\
-  void * dfc_sink_ret = alloca (dfc_sink.data.len + 1);			\
-  memcpy (dfc_sink_ret, dfc_sink.data.ptr, dfc_sink.data.len + 1);	\
-  (sink) = (char *) dfc_sink_ret;					\
+#endif /* ! MULE */
+
+#define GET_C_CHARPTR_INT_DATA_ALLOCA(ptr, fmt, ptr_out) do	\
+{								\
+  Bytecount gccida_ignored_len;					\
+  CONST Extbyte *gccida_ptr_in = (CONST Extbyte *) (ptr);	\
+  Bufbyte *gccida_ptr_out;					\
+								\
+  GET_CHARPTR_INT_DATA_ALLOCA (gccida_ptr_in,			\
+			       strlen ((char *) gccida_ptr_in),	\
+			       fmt,				\
+			       gccida_ptr_out,			\
+			       gccida_ignored_len);		\
+  (ptr_out) = gccida_ptr_out;					\
 } while (0)
-#define DFC_C_STRING_MALLOC_USE_CONVERTED_DATA(sink) do {		\
-  void * dfc_sink_ret = xmalloc (dfc_sink.data.len + 1);		\
-  memcpy (dfc_sink_ret, dfc_sink.data.ptr, dfc_sink.data.len + 1);	\
-  (sink) = (char *) dfc_sink_ret;					\
+
+#define GET_C_CHARPTR_INT_BINARY_DATA_ALLOCA(ptr, ptr_out)	\
+  GET_C_CHARPTR_INT_DATA_ALLOCA (ptr, FORMAT_BINARY, ptr_out)
+#define GET_CHARPTR_INT_BINARY_DATA_ALLOCA(ptr, len, ptr_out, len_out) \
+  GET_CHARPTR_INT_DATA_ALLOCA (ptr, len, FORMAT_BINARY, ptr_out, len_out)
+
+#define GET_C_CHARPTR_INT_FILENAME_DATA_ALLOCA(ptr, ptr_out)	\
+  GET_C_CHARPTR_INT_DATA_ALLOCA (ptr, FORMAT_FILENAME, ptr_out)
+#define GET_CHARPTR_INT_FILENAME_DATA_ALLOCA(ptr, len, ptr_out, len_out) \
+  GET_CHARPTR_INT_DATA_ALLOCA (ptr, len, FORMAT_FILENAME, ptr_out, len_out)
+
+#define GET_C_CHARPTR_INT_CTEXT_DATA_ALLOCA(ptr, ptr_out)	\
+  GET_C_CHARPTR_INT_DATA_ALLOCA (ptr, FORMAT_CTEXT, ptr_out)
+#define GET_CHARPTR_INT_CTEXT_DATA_ALLOCA(ptr, len, ptr_out, len_out) \
+  GET_CHARPTR_INT_DATA_ALLOCA (ptr, len, FORMAT_CTEXT, ptr_out, len_out)
+
+
+/* Maybe convert Lisp string's data into ext-format and store the result in
+   alloca()'ed space.
+
+   You may wonder why this is written in this fashion and not as a
+   function call.  With a little trickery it could certainly be
+   written this way, but it won't work because of those DAMN GCC WANKERS
+   who couldn't be bothered to handle alloca() properly on the x86
+   architecture. (If you put a call to alloca() in the argument to
+   a function call, the stack space gets allocated right in the
+   middle of the arguments to the function call and you are unbelievably
+   hosed.) */
+
+#define GET_STRING_EXT_DATA_ALLOCA(s, fmt, ptr_out, len_out) do	\
+{								\
+  Extcount gseda_len_out;					\
+  struct Lisp_String *gseda_s = XSTRING (s);			\
+  Extbyte * gseda_ptr_out =					\
+    convert_to_external_format (string_data (gseda_s),		\
+				string_length (gseda_s),	\
+				&gseda_len_out, fmt);		\
+  (ptr_out) = (Extbyte *) alloca (1 + gseda_len_out);		\
+  memcpy ((void *) ptr_out, gseda_ptr_out, 1 + gseda_len_out);	\
+  (len_out) = gseda_len_out;					\
 } while (0)
-#define DFC_LISP_STRING_USE_CONVERTED_DATA(sink) \
-  sink = make_string ((Bufbyte *) dfc_sink.data.ptr, dfc_sink.data.len)
-#define DFC_LISP_OPAQUE_USE_CONVERTED_DATA(sink) \
-  sink = make_opaque (dfc_sink.data.ptr, dfc_sink.data.len)
-#define DFC_LISP_LSTREAM_USE_CONVERTED_DATA(sink) /* data already used */
-#define DFC_LISP_BUFFER_USE_CONVERTED_DATA(sink) \
-  Lstream_delete (XLSTREAM (dfc_sink.lisp_object))
+
+
+#define GET_C_STRING_EXT_DATA_ALLOCA(s, fmt, ptr_out) do	\
+{								\
+  Extcount gcseda_ignored_len;					\
+  Extbyte *gcseda_ptr_out;					\
+								\
+  GET_STRING_EXT_DATA_ALLOCA (s, fmt, gcseda_ptr_out,		\
+			      gcseda_ignored_len);		\
+  (ptr_out) = (char *) gcseda_ptr_out;				\
+} while (0)
+
+#define GET_STRING_BINARY_DATA_ALLOCA(s, ptr_out, len_out)	\
+  GET_STRING_EXT_DATA_ALLOCA (s, FORMAT_BINARY, ptr_out, len_out)
+#define GET_C_STRING_BINARY_DATA_ALLOCA(s, ptr_out)		\
+  GET_C_STRING_EXT_DATA_ALLOCA (s, FORMAT_BINARY, ptr_out)
 
-/* Someday we might want to distinguish between Qnative and Qfile_name
-   by using coding-system aliases, but for now it suffices to have
-   these be identical.  Qnative can be used as the coding_system
-   argument to TO_EXTERNAL_FORMAT() and TO_INTERNAL_FORMAT(). */
-#define Qnative Qfile_name
+#define GET_STRING_FILENAME_DATA_ALLOCA(s, ptr_out, len_out)	\
+  GET_STRING_EXT_DATA_ALLOCA (s, FORMAT_FILENAME, ptr_out, len_out)
+#define GET_C_STRING_FILENAME_DATA_ALLOCA(s, ptr_out)		\
+  GET_C_STRING_EXT_DATA_ALLOCA (s, FORMAT_FILENAME, ptr_out)
 
-#ifdef HAVE_MS_WINDOWS
-/* #### kludge!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-   Remove this as soon as my Mule code is integrated. */
-#define Qmswindows_tstr Qnative
-#endif
+#define GET_STRING_OS_DATA_ALLOCA(s, ptr_out, len_out)		\
+  GET_STRING_EXT_DATA_ALLOCA (s, FORMAT_OS, ptr_out, len_out)
+#define GET_C_STRING_OS_DATA_ALLOCA(s, ptr_out)			\
+  GET_C_STRING_EXT_DATA_ALLOCA (s, FORMAT_OS, ptr_out)
+
+#define GET_STRING_CTEXT_DATA_ALLOCA(s, ptr_out, len_out)	\
+  GET_STRING_EXT_DATA_ALLOCA (s, FORMAT_CTEXT, ptr_out, len_out)
+#define GET_C_STRING_CTEXT_DATA_ALLOCA(s, ptr_out)		\
+  GET_C_STRING_EXT_DATA_ALLOCA (s, FORMAT_CTEXT, ptr_out)
+
+
 
 /************************************************************************/
 /*                                                                      */
@@ -1415,7 +1433,7 @@
 
 #define POINT_MARKER_P(marker) \
    (XMARKER (marker)->buffer != 0 && \
-    EQ (marker, XMARKER (marker)->buffer->point_marker))
+    EQ ((marker), XMARKER (marker)->buffer->point_marker))
 
 #define BUF_MARKERS(buf) ((buf)->markers)
 
@@ -1542,8 +1560,8 @@
 
 #ifdef REL_ALLOC
 
-char *r_alloc (unsigned char **, size_t);
-char *r_re_alloc (unsigned char **, size_t);
+char *r_alloc (unsigned char **, unsigned long);
+char *r_re_alloc (unsigned char **, unsigned long);
 void r_alloc_free (unsigned char **);
 
 #define BUFFER_ALLOC(data, size) \
@@ -1576,17 +1594,17 @@
 /* from insdel.c */
 void set_buffer_point (struct buffer *buf, Bufpos pos, Bytind bipos);
 void find_charsets_in_bufbyte_string (unsigned char *charsets,
-				      const Bufbyte *str,
+				      CONST Bufbyte *str,
 				      Bytecount len);
 void find_charsets_in_emchar_string (unsigned char *charsets,
-				     const Emchar *str,
+				     CONST Emchar *str,
 				     Charcount len);
-int bufbyte_string_displayed_columns (const Bufbyte *str, Bytecount len);
-int emchar_string_displayed_columns (const Emchar *str, Charcount len);
-void convert_bufbyte_string_into_emchar_dynarr (const Bufbyte *str,
+int bufbyte_string_displayed_columns (CONST Bufbyte *str, Bytecount len);
+int emchar_string_displayed_columns (CONST Emchar *str, Charcount len);
+void convert_bufbyte_string_into_emchar_dynarr (CONST Bufbyte *str,
 						Bytecount len,
 						Emchar_dynarr *dyn);
-Charcount convert_bufbyte_string_into_emchar_string (const Bufbyte *str,
+Charcount convert_bufbyte_string_into_emchar_string (CONST Bufbyte *str,
 						     Bytecount len,
 						     Emchar *arr);
 void convert_emchar_string_into_bufbyte_dynarr (Emchar *arr, int nels,
@@ -1682,7 +1700,7 @@
   set_string_char (XSTRING (table), (Charcount) ch1, ch2)
 
 #ifdef MULE
-# define MAKE_MIRROR_TRT_TABLE() make_opaque (OPAQUE_CLEAR, 256)
+# define MAKE_MIRROR_TRT_TABLE() make_opaque (256, 0)
 # define MIRROR_TRT_TABLE_AS_STRING(table) ((Bufbyte *) XOPAQUE_DATA (table))
 # define MIRROR_TRT_TABLE_CHAR_1(table, ch) \
   ((Emchar) (MIRROR_TRT_TABLE_AS_STRING (table)[ch]))
@@ -1712,8 +1730,8 @@
   TRT_TABLE_AS_STRING (buf->case_eqv_table)
 #endif
 
-INLINE_HEADER Emchar TRT_TABLE_OF (Lisp_Object trt, Emchar c);
-INLINE_HEADER Emchar
+INLINE Emchar TRT_TABLE_OF (Lisp_Object trt, Emchar c);
+INLINE Emchar
 TRT_TABLE_OF (Lisp_Object trt, Emchar c)
 {
   return IN_TRT_TABLE_DOMAIN (c) ? TRT_TABLE_CHAR_1 (trt, c) : c;
@@ -1725,8 +1743,8 @@
 
 /* 1 if CH is upper case.  */
 
-INLINE_HEADER int UPPERCASEP (struct buffer *buf, Emchar ch);
-INLINE_HEADER int
+INLINE int UPPERCASEP (struct buffer *buf, Emchar ch);
+INLINE int
 UPPERCASEP (struct buffer *buf, Emchar ch)
 {
   return DOWNCASE_TABLE_OF (buf, ch) != ch;
@@ -1734,8 +1752,8 @@
 
 /* 1 if CH is lower case.  */
 
-INLINE_HEADER int LOWERCASEP (struct buffer *buf, Emchar ch);
-INLINE_HEADER int
+INLINE int LOWERCASEP (struct buffer *buf, Emchar ch);
+INLINE int
 LOWERCASEP (struct buffer *buf, Emchar ch)
 {
   return (UPCASE_TABLE_OF   (buf, ch) != ch &&
@@ -1744,8 +1762,8 @@
 
 /* 1 if CH is neither upper nor lower case.  */
 
-INLINE_HEADER int NOCASEP (struct buffer *buf, Emchar ch);
-INLINE_HEADER int
+INLINE int NOCASEP (struct buffer *buf, Emchar ch);
+INLINE int
 NOCASEP (struct buffer *buf, Emchar ch)
 {
   return UPCASE_TABLE_OF (buf, ch) == ch;
@@ -1753,8 +1771,8 @@
 
 /* Upcase a character, or make no change if that cannot be done.  */
 
-INLINE_HEADER Emchar UPCASE (struct buffer *buf, Emchar ch);
-INLINE_HEADER Emchar
+INLINE Emchar UPCASE (struct buffer *buf, Emchar ch);
+INLINE Emchar
 UPCASE (struct buffer *buf, Emchar ch)
 {
   return (DOWNCASE_TABLE_OF (buf, ch) == ch) ? UPCASE_TABLE_OF (buf, ch) : ch;
@@ -1768,4 +1786,4 @@
 
 #define DOWNCASE(buf, ch) DOWNCASE_TABLE_OF (buf, ch)
 
-#endif /* INCLUDED_buffer_h_ */
+#endif /* _XEMACS_BUFFER_H_ */