xemacs-beta: src/buffer.h comparison

comparison src/buffer.h @ 380:8626e4521993 r21-2-5

Import from CVS: tag r21-2-5

author	cvs
date	Mon, 13 Aug 2007 11:07:10 +0200
parents	6240c7796c7a
children	4af0ddfb7c5b

comparison

equal deleted inserted replaced

-:76b7d63099ad
+:8626e4521993
 CONCHECK_BUFFER (x);					\
 if (!BUFFER_LIVE_P (XBUFFER (x)))			\
 x = wrong_type_argument (Qbuffer_live_p, (x));	\
 } while (0)
 #define BUFFER_BASE_BUFFER(b) ((b)->base_buffer ? (b)->base_buffer : (b))
 /* Map over buffers sharing the same text as MPS_BUF.  MPS_BUFVAR is a
 variable that gets the buffer values (beginning with the base
 buffer, then the children), and MPS_BUFCONS should be a temporary
 	  && (mps_bufvar = XBUFFER (XCAR (mps_bufcons)), 1)			\
 	  && (mps_bufcons = XCDR (mps_bufcons), 1));				\
 )
+/************************************************************************/
+/*									*/
+/*		   working with raw internal-format data		*/
+/*									*/
+/************************************************************************/
 /* NOTE: In all the following macros, we follow these rules concerning
 multiple evaluation of the arguments:
 1) Anything that's an lvalue can be evaluated more than once.
 2) Anything that's a Lisp Object can be evaluated more than once.
 5) An exception to (4) is that there are some macros below that
 may evaluate their arguments more than once.  They are all
 denoted with the word "unsafe" in their name and are generally
 meant to be called only by other macros that have already
 stored the calling values in temporary variables.
-*/
-/************************************************************************/
+Use the following functions/macros on contiguous strings of data.
-/*									*/
+If the text you're operating on is known to come from a buffer, use
-/*		   working with raw internal-format data		*/
+the buffer-level functions below -- they know about the gap and may
-/*									*/
+be more efficient.
-/************************************************************************/
-/* Use these on contiguous strings of data.  If the text you're
+(A) For working with charptr's (pointers to internally-formatted text):
-operating on is known to come from a buffer, use the buffer-level
+-----------------------------------------------------------------------
-functions below -- they know about the gap and may be more
-efficient. */
+VALID_CHARPTR_P (ptr):
-/* Functions are as follows:
-(A) For working with charptr's (pointers to internally-formatted text):
------------------------------------------------------------------------
-VALID_CHARPTR_P(ptr):
 	Given a charptr, does it point to the beginning of a character?
-ASSERT_VALID_CHARPTR(ptr):
+ASSERT_VALID_CHARPTR (ptr):
 	If error-checking is enabled, assert that the given charptr
-	points to the beginning of a character.  Otherwise, do nothing.
+	points to the beginning of a character.	 Otherwise, do nothing.
-INC_CHARPTR(ptr):
+INC_CHARPTR (ptr):
 	Given a charptr (assumed to point at the beginning of a character),
 	modify that pointer so it points to the beginning of the next
 	character.
-DEC_CHARPTR(ptr):
+DEC_CHARPTR (ptr):
 	Given a charptr (assumed to point at the beginning of a
 	character or at the very end of the text), modify that pointer
 	so it points to the beginning of the previous character.
-VALIDATE_CHARPTR_BACKWARD(ptr):
+VALIDATE_CHARPTR_BACKWARD (ptr):
 	Make sure that PTR is pointing to the beginning of a character.
-	If not, back up until this is the case.   Note that there are not
+	If not, back up until this is the case.	  Note that there are not
 	too many places where it is legitimate to do this sort of thing.
 	It's an error if you're passed an "invalid" char * pointer.
 	NOTE: PTR *must* be pointing to a valid part of the string (i.e.
 	not the very end, unless the string is zero-terminated or
 	something) in order for this function to not cause crashes.
-VALIDATE_CHARPTR_FORWARD(ptr):
+VALIDATE_CHARPTR_FORWARD (ptr):
 	Make sure that PTR is pointing to the beginning of a character.
 	If not, move forward until this is the case.  Note that there
 	are not too many places where it is legitimate to do this sort
 	of thing.  It's an error if you're passed an "invalid" char *
 	pointer.
 (B) For working with the length (in bytes and characters) of a
 section of internally-formatted text:
 --------------------------------------------------------------
-bytecount_to_charcount(ptr, nbi):
+bytecount_to_charcount (ptr, nbi):
 	Given a pointer to a text string and a length in bytes,
 	return the equivalent length in characters.
-charcount_to_bytecount(ptr, nch):
+charcount_to_bytecount (ptr, nch):
 	Given a pointer to a text string and a length in characters,
 	return the equivalent length in bytes.
-charptr_n_addr(ptr, n):
+charptr_n_addr (ptr, n):
 	Return a pointer to the beginning of the character offset N
 	(in characters) from PTR.
-charptr_length(ptr):
-	Given a zero-terminated pointer to Emacs characters,
-	return the number of Emacs characters contained within.
 (C) For retrieving or changing the character pointed to by a charptr:
 ---------------------------------------------------------------------
-charptr_emchar(ptr):
+charptr_emchar (ptr):
 	Retrieve the character pointed to by PTR as an Emchar.
-charptr_emchar_n(ptr, n):
+charptr_emchar_n (ptr, n):
 	Retrieve the character at offset N (in characters) from PTR,
 	as an Emchar.
-set_charptr_emchar(ptr, ch):
+set_charptr_emchar (ptr, ch):
 	Store the character CH (an Emchar) as internally-formatted
 	text starting at PTR.  Return the number of bytes stored.
-charptr_copy_char(ptr, ptr2):
+charptr_copy_char (ptr, ptr2):
 	Retrieve the character pointed to by PTR and store it as
 	internally-formatted text in PTR2.
 (D) For working with Emchars:
 [Note that there are other functions/macros for working with Emchars
 in mule-charset.h, for retrieving the charset of an Emchar
 and such.  These are only valid when MULE is defined.]
-valid_char_p(ch):
+valid_char_p (ch):
 	Return whether the given Emchar is valid.
-CHARP(ch):
+CHARP (ch):
-Return whether the given Lisp_Object is a valid character.
+	Return whether the given Lisp_Object is a character.
-	This is approximately the same as saying the Lisp_Object is
-	an int whose value is a valid Emchar. (But not exactly
+CHECK_CHAR_COERCE_INT (ch):
-	because when MULE is not defined, we allow arbitrary values
+	Signal an error if CH is not a valid character or integer Lisp_Object.
-	in all but the lowest 8 bits and mask them off, for backward
+	If CH is an integer Lisp_Object, convert it to a character Lisp_Object,
-	compatibility.)
+	but merely by repackaging, without performing tests for char validity.
-CHECK_CHAR_COERCE_INT(ch):
-	Signal an error if CH is not a valid character as per CHARP().
-	Also canonicalize the value into a valid Emchar, as necessary.
-	(This only means anything when MULE is not defined.)
-COERCE_CHAR(ch):
-	Coerce an object that is known to satisfy CHARP() into a
-	valid Emchar.
 MAX_EMCHAR_LEN:
 	Maximum number of buffer bytes per Emacs character.
 */
 trick of looking for a valid first byte because it might run off
 the end of the string.  DEC_CHARPTR() can't use the INC_CHARPTR()
 method because it doesn't have easy access to the first byte of
 the character it's moving over. */
-#define real_inc_charptr_fun(ptr) \
+#define REAL_INC_CHARPTR(ptr) \
-((ptr) += REP_BYTES_BY_FIRST_BYTE (* (unsigned char *) (ptr)))
+((void) ((ptr) += REP_BYTES_BY_FIRST_BYTE (* (unsigned char *) (ptr))))
+#define REAL_DEC_CHARPTR(ptr) do {	\
+(ptr)--;				\
+} while (!VALID_CHARPTR_P (ptr))
 #ifdef ERROR_CHECK_BUFPOS
-#define inc_charptr_fun(ptr) (ASSERT_VALID_CHARPTR (ptr), \
-			      real_inc_charptr_fun (ptr))
-#else
-#define inc_charptr_fun(ptr) real_inc_charptr_fun (ptr)
-#endif
-#define REAL_INC_CHARPTR(ptr) ((void) (real_inc_charptr_fun (ptr)))
 #define INC_CHARPTR(ptr) do {		\
 ASSERT_VALID_CHARPTR (ptr);		\
 REAL_INC_CHARPTR (ptr);		\
 } while (0)
-#define REAL_DEC_CHARPTR(ptr) do {	\
+#define DEC_CHARPTR(ptr) do {			\
-(ptr)--;				\
+CONST Bufbyte *dc_ptr1 = (ptr);		\
-} while (!VALID_CHARPTR_P (ptr))
+CONST Bufbyte *dc_ptr2 = dc_ptr1;		\
+REAL_DEC_CHARPTR (dc_ptr2);			\
-#ifdef ERROR_CHECK_BUFPOS
+assert (dc_ptr1 - dc_ptr2 ==			\
-#define DEC_CHARPTR(ptr) do {			  \
+	  REP_BYTES_BY_FIRST_BYTE (*dc_ptr2));	\
-CONST Bufbyte *__dcptr__ = (ptr);		  \
+(ptr) = dc_ptr2;				\
-CONST Bufbyte *__dcptr2__ = __dcptr__;	  \
+} while (0)
-REAL_DEC_CHARPTR (__dcptr2__);		  \
-assert (__dcptr__ - __dcptr2__ ==		  \
+#else /* ! ERROR_CHECK_BUFPOS */
-	  REP_BYTES_BY_FIRST_BYTE (*__dcptr2__)); \
+#define INC_CHARPTR(ptr) REAL_INC_CHARPTR (ptr)
-(ptr) = __dcptr2__;				  \
-} while (0)
-#else
 #define DEC_CHARPTR(ptr) REAL_DEC_CHARPTR (ptr)
-#endif
+#endif /* ! ERROR_CHECK_BUFPOS */
 #ifdef MULE
 #define VALIDATE_CHARPTR_BACKWARD(ptr) do {	\
 while (!VALID_CHARPTR_P (ptr)) ptr--;		\
 /* This needs to be trickier to avoid the possibility of running off
 the end of the string. */
 #define VALIDATE_CHARPTR_FORWARD(ptr) do {	\
-Bufbyte *__vcfptr__ = (ptr);			\
+Bufbyte *vcf_ptr = (ptr);			\
-VALIDATE_CHARPTR_BACKWARD (__vcfptr__);	\
+VALIDATE_CHARPTR_BACKWARD (vcf_ptr);		\
-if (__vcfptr__ != (ptr))			\
+if (vcf_ptr != (ptr))				\
 {						\
-(ptr) = __vcfptr__;			\
+(ptr) = vcf_ptr;				\
 INC_CHARPTR (ptr);			\
 }						\
 } while (0)
 #else /* not MULE */
 charptr_n_addr (CONST Bufbyte *ptr, Charcount offset)
 {
 return ptr + charcount_to_bytecount (ptr, offset);
 }
-INLINE Charcount charptr_length (CONST Bufbyte *ptr);
-INLINE Charcount
-charptr_length (CONST Bufbyte *ptr)
-{
-return bytecount_to_charcount (ptr, strlen ((CONST char *) ptr));
-}
 /* -------------------------------------------------------------------- */
 /* (C) For retrieving or changing the character pointed to by a charptr */
 /* -------------------------------------------------------------------- */
 #define simple_charptr_emchar(ptr)		((Emchar) (ptr)[0])
 INLINE int valid_char_p (Emchar ch);
 INLINE int
 valid_char_p (Emchar ch)
 {
-return (ch >= 0 && ch <= 255) || non_ascii_valid_char_p (ch);
+return ((unsigned int) (ch) <= 0xff) || non_ascii_valid_char_p (ch);
 }
 #else /* not MULE */
-#define valid_char_p(ch) ((unsigned int) (ch) <= 255)
+#define valid_char_p(ch) ((unsigned int) (ch) <= 0xff)
 #endif /* not MULE */
 #define CHAR_INTP(x) (INTP (x) && valid_char_p (XINT (x)))
 as well (it should reduce down to nothing), we provide a separate
 version to avoid compilation warnings and possible non-optimal
 results with stupid compilers. */
 #ifdef MULE
-# define VALIDATE_BYTIND_BACKWARD(buf, x) do		\
+# define VALIDATE_BYTIND_BACKWARD(buf, x) do {		\
-{							\
+Bufbyte *VBB_ptr = BI_BUF_BYTE_ADDRESS (buf, x);	\
-Bufbyte *__ibptr = BI_BUF_BYTE_ADDRESS (buf, x);	\
+while (!BUFBYTE_FIRST_BYTE_P (*VBB_ptr))		\
-while (!BUFBYTE_FIRST_BYTE_P (*__ibptr))		\
+VBB_ptr--, (x)--;					\
-__ibptr--, (x)--;					\
 } while (0)
 #else
 # define VALIDATE_BYTIND_BACKWARD(buf, x)
 #endif
 as well (it should reduce down to nothing), we provide a separate
 version to avoid compilation warnings and possible non-optimal
 results with stupid compilers. */
 #ifdef MULE
-# define VALIDATE_BYTIND_FORWARD(buf, x) do		\
+# define VALIDATE_BYTIND_FORWARD(buf, x) do {		\
-{							\
+Bufbyte *VBF_ptr = BI_BUF_BYTE_ADDRESS (buf, x);	\
-Bufbyte *__ibptr = BI_BUF_BYTE_ADDRESS (buf, x);	\
+while (!BUFBYTE_FIRST_BYTE_P (*VBF_ptr))		\
-while (!BUFBYTE_FIRST_BYTE_P (*__ibptr))		\
+VBF_ptr++, (x)++;					\
-__ibptr++, (x)++;					\
 } while (0)
 #else
 # define VALIDATE_BYTIND_FORWARD(buf, x)
 #endif
 {									\
 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;				\
-(len_out) = (Extcount) gceda_len_in;				\
 }									\
 else									\
 {									\
 (ptr_out) = (Extbyte *) alloca (1 + gceda_len_out);		\
 memcpy ((void *) ptr_out, gceda_ptr_out, 1 + gceda_len_out);	\
-(len_out) = (Extcount) gceda_len_out;				\
 }									\
+(len_out) = gceda_len_out;						\
 } while (0)
 #else /* ! MULE */
 #define GET_CHARPTR_EXT_DATA_ALLOCA(ptr, len, fmt, ptr_out, len_out) do	\
 #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);					\
+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;				\
-(len_out) = (Bytecount) gcida_len_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;					\
 }									\
+(len_out) = gcida_len_out;						\
 } while (0)
 #else /* ! MULE */
 #define GET_CHARPTR_INT_DATA_ALLOCA(ptr, len, fmt, ptr_out, len_out) do \
 #define R_ALLOC_DECLARE(var,data) r_alloc_declare (&(var), data)
 #else /* !REL_ALLOC */
 #define BUFFER_ALLOC(data,size)\
-	((void) (data = xnew_array (Bufbyte, size)))
+	(data = xnew_array (Bufbyte, size))
 #define BUFFER_REALLOC(data,size)\
 	((Bufbyte *) xrealloc (data, (size) * sizeof(Bufbyte)))
 /* Avoid excess parentheses, or syntax errors may rear their heads. */
 #define BUFFER_FREE(data) xfree (data)
 #define R_ALLOC_DECLARE(var,data)
 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);
-int convert_bufbyte_string_into_emchar_string (CONST Bufbyte *str,
+Charcount convert_bufbyte_string_into_emchar_string (CONST Bufbyte *str,
-					       Bytecount len,
+						     Bytecount len,
-					       Emchar *arr);
+						     Emchar *arr);
 void convert_emchar_string_into_bufbyte_dynarr (Emchar *arr, int nels,
 						Bufbyte_dynarr *dyn);
 Bufbyte *convert_emchar_string_into_malloced_string (Emchar *arr, int nels,
 						    Bytecount *len_out);
 /* from marker.c */
 /* A "trt" table is a mapping from characters to other characters,
 typically used to convert between uppercase and lowercase.  For
 compatibility reasons, trt tables are currently in the form of
 a Lisp string of 256 characters, specifying the conversion for each
-of the first 256 Emacs characters (i.e. the 256 extended-ASCII
+of the first 256 Emacs characters (i.e. the 256 Latin-1 characters).
-characters).  This should be generalized at some point to support
+This should be generalized at some point to support conversions for
-conversions for all of the allowable Mule characters.
+all of the allowable Mule characters.
 */
 /* The _1 macros are named as such because they assume that you have
 already guaranteed that the character values are all in the range
 0 - 255.  Bad lossage will happen otherwise. */
 UPCASE (struct buffer *buf, Emchar ch)
 {
 return (DOWNCASE_TABLE_OF (buf, ch) == ch) ? UPCASE_TABLE_OF (buf, ch) : ch;
 }
-/* Upcase a character known to be not upper case.  */
+/* Upcase a character known to be not upper case.  Unused. */
 #define UPCASE1(buf, ch) UPCASE_TABLE_OF (buf, ch)
 /* Downcase a character, or make no change if that cannot be done. */

Mercurial > hg > xemacs-beta

comparison src/buffer.h @ 380:8626e4521993 r21-2-5