xemacs-beta: src/redisplay.c comparison

comparison src/redisplay.c @ 867:804517e16990

[xemacs-hg @ 2002-06-05 09:54:39 by ben] Textual renaming: text/char names abbrev.c, alloc.c, buffer.c, buffer.h, bytecode.c, callint.c, casefiddle.c, casetab.c, charset.h, chartab.c, chartab.h, cmds.c, console-gtk.h, console-msw.c, console-msw.h, console-stream.c, console-tty.c, console-x.c, console-x.h, console.h, data.c, device-msw.c, device-x.c, dialog-msw.c, dired-msw.c, dired.c, doc.c, doprnt.c, editfns.c, eldap.c, emodules.c, eval.c, event-Xt.c, event-gtk.c, event-msw.c, event-stream.c, event-unixoid.c, events.c, events.h, file-coding.c, file-coding.h, fileio.c, filelock.c, fns.c, font-lock.c, frame-gtk.c, frame-msw.c, frame-x.c, frame.c, glyphs-eimage.c, glyphs-msw.c, glyphs-x.c, glyphs.c, glyphs.h, gpmevent.c, gui-x.c, gui-x.h, gui.c, gui.h, hpplay.c, indent.c, insdel.c, insdel.h, intl-win32.c, keymap.c, line-number.c, line-number.h, lisp-disunion.h, lisp-union.h, lisp.h, lread.c, lrecord.h, lstream.c, lstream.h, md5.c, menubar-msw.c, menubar-x.c, menubar.c, minibuf.c, mule-ccl.c, mule-charset.c, mule-coding.c, mule-wnnfns.c, ndir.h, nt.c, objects-gtk.c, objects-gtk.h, objects-msw.c, objects-tty.c, objects-x.c, objects.c, objects.h, postgresql.c, print.c, process-nt.c, process-unix.c, process.c, procimpl.h, realpath.c, redisplay-gtk.c, redisplay-msw.c, redisplay-output.c, redisplay-tty.c, redisplay-x.c, redisplay.c, redisplay.h, regex.c, search.c, select-common.h, select-gtk.c, select-x.c, sound.h, symbols.c, syntax.c, syntax.h, sysdep.c, sysdep.h, sysdir.h, sysfile.h, sysproc.h, syspwd.h, systime.h, syswindows.h, termcap.c, tests.c, text.c, text.h, toolbar-common.c, tooltalk.c, ui-gtk.c, unexnt.c, unicode.c, win32.c: Text/char naming rationalization. [a] distinguish between "charptr" when it refers to operations on the pointer itself and when it refers to operations on text; and [b] use consistent naming for everything referring to internal format, i.e. Itext == text in internal format Ibyte == a byte in such text Ichar == a char as represented in internal character format thus e.g. set_charptr_emchar -> set_itext_ichar The pre and post tags on either side of this change are: pre-internal-format-textual-renaming post-internal-format-textual-renaming See the Internals Manual for details of exactly how this was done, how to handle the change in your workspace, etc.

author	ben
date	Wed, 05 Jun 2002 09:58:45 +0000
parents	2b6fa2618f76
children	79c6ff3eef26

comparison

equal deleted inserted replaced

-:613552a02607
+:804517e16990
 #ifdef HAVE_TTY
 #include "console-tty.h"
 #endif /* HAVE_TTY */
 /* Note: We have to be careful throughout this code to properly handle
-and differentiate between Intbytes and Emchars.
+and differentiate between Ibytes and Ichars.
-Since strings are generally composed of Intbytes, I've taken the tack
+Since strings are generally composed of Ibytes, I've taken the tack
-that any contiguous set of Intbytes is called a "string", while
+that any contiguous set of Ibytes is called a "string", while
-any contiguous set of Emchars is called an "array". */
+any contiguous set of Ichars is called an "array". */
 /* Return value to indicate a failure by an add_*_rune routine to add
 a rune, but no propagation information needs to be returned. */
 #define ADD_FAILED (prop_block_dynarr *) 1
 handle to the string */
 Lisp_Object string;
 struct device *d;
 struct display_block *db;
 struct display_line *dl;
-Emchar ch;		/* Character that is to be added.  This is
+Ichar ch;		/* Character that is to be added.  This is
 			   used to communicate this information to
-			   add_emchar_rune(). */
+			   add_ichar_rune(). */
 Lisp_Object last_charset; /* The charset of the previous character.
 			       Used to optimize some lookups -- we
 			       only have to do some things when
 			       the charset changes. */
 face_index last_findex;   /* The face index of the previous character.
 			   to add_blank_rune().
 			   This is also used rather cheesily to
 			   communicate the width of the eol-cursor-size
 			   blank that exists at the end of the line.
-			   add_emchar_rune() is called cheesily with
+			   add_ichar_rune() is called cheesily with
 			   the non-printing char '\n', which is stuck
 			   in the output routines with its width being
 			   BLANK_WIDTH. */
 Bytexpos byte_cursor_charpos; /* This stores the buffer position of the
 				 cursor. */
 PROP_BLANK,
 PROP_GLYPH
 };
 /* Data that should be propagated to the next line.  Either a single
-Emchar, a string of Intbyte's or a glyph.
+Ichar, a string of Ibyte's or a glyph.
 The actual data that is propagated ends up as a Dynarr of these
 blocks.
 prop_blocks are used to indicate that data that was supposed to go
 wrapping then we need to display the propagation data before moving
 on. Its questionable whether we should wrap or clip glyphs in this
 instance. Most e-lisp relies on clipping so we preserve this
 behavior.
-#### It's unclean that both Emchars and Intbytes are here.
+#### It's unclean that both Ichars and Ibytes are here.
 */
 typedef struct prop_block prop_block;
 struct prop_block
 {
 union data
 {
 struct
 {
-Intbyte *str;
+Ibyte *str;
 Bytecount len; /* length of the string. */
 } p_string;
 struct
 {
-Emchar ch;
+Ichar ch;
 Bytebpos byte_cursor_charpos; /* NOTE: is in Bytebpos's */
 unsigned int cursor_type :3;
 } p_char;
 struct
 				     struct display_line *dl,
 				     int overlay_width);
 static void create_right_glyph_block (struct window *w,
 				      struct display_line *dl);
 static void redisplay_windows (Lisp_Object window, int skip_selected);
-static void decode_mode_spec (struct window *w, Emchar spec, int type);
+static void decode_mode_spec (struct window *w, Ichar spec, int type);
 static void free_display_line (struct display_line *dl);
 static void update_line_start_cache (struct window *w, Charbpos from,
 				     Charbpos to, Charbpos point,
 				     int no_regen);
 static int point_visible (struct window *w, Charbpos point, int type);
 /* #### probably temporary */
 Fixnum cache_adjustment;
 /* This holds a string representing the text corresponding to a single
 modeline % spec. */
-static Intbyte_dynarr *mode_spec_intbyte_string;
+static Ibyte_dynarr *mode_spec_ibyte_string;
 int in_display;		/* 1 if in redisplay.  */
 int disable_preemption;	/* Used for debugging redisplay and for
 			   force-redisplay. */
 /*              low-level interfaces onto device routines                  */
 /*									   */
 /***************************************************************************/
 static int
-redisplay_text_width_emchar_string (struct window *w, int findex,
+redisplay_text_width_ichar_string (struct window *w, int findex,
-				    Emchar *str, Charcount len)
+				    Ichar *str, Charcount len)
 {
 unsigned char charsets[NUM_LEADING_BYTES];
 Lisp_Object window;
-find_charsets_in_emchar_string (charsets, str, len);
+find_charsets_in_ichar_string (charsets, str, len);
 window = wrap_window (w);
 ensure_face_cachel_complete (WINDOW_FACE_CACHEL (w, findex), window,
 			       charsets);
 return DEVMETH (XDEVICE (FRAME_DEVICE (XFRAME (WINDOW_FRAME (w)))),
 		  text_width, (XFRAME (WINDOW_FRAME (w)),
 			       WINDOW_FACE_CACHEL (w, findex), str, len));
 }
-static Emchar_dynarr *rtw_emchar_dynarr;
+static Ichar_dynarr *rtw_ichar_dynarr;
 int
 redisplay_text_width_string (struct window *w, int findex,
-			     Intbyte *nonreloc, Lisp_Object reloc,
+			     Ibyte *nonreloc, Lisp_Object reloc,
 			     Bytecount offset, Bytecount len)
 {
-if (!rtw_emchar_dynarr)
+if (!rtw_ichar_dynarr)
-rtw_emchar_dynarr = Dynarr_new (Emchar);
+rtw_ichar_dynarr = Dynarr_new (Ichar);
-Dynarr_reset (rtw_emchar_dynarr);
+Dynarr_reset (rtw_ichar_dynarr);
 fixup_internal_substring (nonreloc, reloc, offset, &len);
 if (STRINGP (reloc))
 nonreloc = XSTRING_DATA (reloc);
-convert_intbyte_string_into_emchar_dynarr (nonreloc, len, rtw_emchar_dynarr);
+convert_ibyte_string_into_ichar_dynarr (nonreloc, len, rtw_ichar_dynarr);
-return redisplay_text_width_emchar_string
+return redisplay_text_width_ichar_string
-(w, findex, Dynarr_atp (rtw_emchar_dynarr, 0),
+(w, findex, Dynarr_atp (rtw_ichar_dynarr, 0),
-Dynarr_length (rtw_emchar_dynarr));
+Dynarr_length (rtw_ichar_dynarr));
 }
 int
 redisplay_frame_text_width_string (struct frame *f, Lisp_Object face,
-				   Intbyte *nonreloc, Lisp_Object reloc,
+				   Ibyte *nonreloc, Lisp_Object reloc,
 				   Bytecount offset, Bytecount len)
 {
 unsigned char charsets[NUM_LEADING_BYTES];
 Lisp_Object frame;
 struct face_cachel cachel;
-if (!rtw_emchar_dynarr)
+if (!rtw_ichar_dynarr)
-rtw_emchar_dynarr = Dynarr_new (Emchar);
+rtw_ichar_dynarr = Dynarr_new (Ichar);
-Dynarr_reset (rtw_emchar_dynarr);
+Dynarr_reset (rtw_ichar_dynarr);
 fixup_internal_substring (nonreloc, reloc, offset, &len);
 if (STRINGP (reloc))
 nonreloc = XSTRING_DATA (reloc);
-convert_intbyte_string_into_emchar_dynarr (nonreloc, len, rtw_emchar_dynarr);
+convert_ibyte_string_into_ichar_dynarr (nonreloc, len, rtw_ichar_dynarr);
-find_charsets_in_intbyte_string (charsets, nonreloc, len);
+find_charsets_in_ibyte_string (charsets, nonreloc, len);
 reset_face_cachel (&cachel);
 cachel.face = face;
 frame = wrap_frame (f);
 ensure_face_cachel_complete (&cachel, frame, charsets);
 return DEVMETH (XDEVICE (FRAME_DEVICE (f)),
-		  text_width, (f, &cachel, Dynarr_atp (rtw_emchar_dynarr, 0),
+		  text_width, (f, &cachel, Dynarr_atp (rtw_ichar_dynarr, 0),
-			       Dynarr_length (rtw_emchar_dynarr)));
+			       Dynarr_length (rtw_ichar_dynarr)));
 }
 /* Return the display block from DL of the given TYPE.  A display line
 can have only one display block of each possible type.  If DL does
 not have a block of type TYPE, one will be created and added to DL. */
 display_line as a whole).
 If the baseline is completely blank, or contains no manually positioned
 glyphs, then the textual baseline is simply the baseline of the default font.
 (The `contains no manually positioned glyphs' part is actually done for
-us by `add_emchar_rune'.)
+us by `add_ichar_rune'.)
 If the baseline contains pixmaps, and they're all manually positioned, then
 the textual baseline location is constrained that way, and we need do no
 work.
 /* Adds a character rune to a display block.  If there is not enough room
 to fit the rune on the display block (as determined by the MAX_PIXPOS)
 then it adds nothing and returns ADD_FAILED.  If
 NO_CONTRIBUTE_TO_LINE_HEIGHT is non-zero, don't allow the char's height
-to affect the total line height. (See add_intbyte_string_runes()). */
+to affect the total line height. (See add_ibyte_string_runes()). */
 static prop_block_dynarr *
-add_emchar_rune_1 (pos_data *data, int no_contribute_to_line_height)
+add_ichar_rune_1 (pos_data *data, int no_contribute_to_line_height)
 {
 struct rune rb, *crb;
 int width, local;
 if (data->start_col)
 /* Cheesy end-of-line pseudo-character. */
 width = data->blank_width;
 }
 else
 {
-Lisp_Object charset = emchar_charset (data->ch);
+Lisp_Object charset = ichar_charset (data->ch);
 if (!EQ (charset, data->last_charset) ||
 	  data->findex != data->last_findex)
 	{
 	  /* OK, we need to do things the hard way. */
 	  struct window *w = XWINDOW (data->window);
 	    data->font_is_bogus = 0;
 	  fi = XFONT_INSTANCE (font_instance);
 	  if (!fi->proportional_p || data->font_is_bogus)
 	    {
-	      Emchar ch = data->font_is_bogus ? '~' : data->ch;
+	      Ichar ch = data->font_is_bogus ? '~' : data->ch;
 	      data->last_char_width =
-		redisplay_text_width_emchar_string (XWINDOW (data->window),
+		redisplay_text_width_ichar_string (XWINDOW (data->window),
 						    data->findex, &ch, 1);
 	    }
 	  else
 	    data->last_char_width = -1;
 	  data->last_findex = data->findex;
 	}
 width = data->last_char_width;
 if (width < 0) /* proportional fonts */
-	width = redisplay_text_width_emchar_string (XWINDOW (data->window),
+	width = redisplay_text_width_ichar_string (XWINDOW (data->window),
 						    data->findex,
 						    &data->ch, 1);
 }
 if (data->max_pixpos != -1 && (data->pixpos + width > data->max_pixpos))
 return NULL;
 }
 static prop_block_dynarr *
-add_emchar_rune (pos_data *data)
+add_ichar_rune (pos_data *data)
 {
-return add_emchar_rune_1 (data, 0);
+return add_ichar_rune_1 (data, 0);
 }
-/* Given a string C_STRING of length C_LENGTH, call add_emchar_rune for
+/* Given a string C_STRING of length C_LENGTH, call add_ichar_rune for
 each character in the string.  Propagate any left-over data unless
 NO_PROP is non-zero.  If NO_CONTRIBUTE_TO_LINE_HEIGHT is non-zero, don't
 allow this character to increase the total height of the line. (This is
 used when the character is part of a text glyph.  In that case, the
 glyph code itself adjusts the line height as necessary, depending on
 whether glyph-contrib-p is true.) */
 static prop_block_dynarr *
-add_intbyte_string_runes (pos_data *data, Intbyte *c_string,
+add_ibyte_string_runes (pos_data *data, Ibyte *c_string,
 			  Bytecount c_length, int no_prop,
 			  int no_contribute_to_line_height)
 {
-Intbyte *pos, *end = c_string + c_length;
+Ibyte *pos, *end = c_string + c_length;
 prop_block_dynarr *prop;
 /* #### This function is too simplistic.  It needs to do the same
 sort of character interpretation (display-table lookup,
 ctl-arrow checking), etc. that create_text_block() does.
 The functionality to do this in that routine needs to be
 modularized. */
 for (pos = c_string; pos < end;)
 {
-Intbyte *old_pos = pos;
+Ibyte *old_pos = pos;
-data->ch = charptr_emchar (pos);
+data->ch = itext_ichar (pos);
-prop = add_emchar_rune_1 (data, no_contribute_to_line_height);
+prop = add_ichar_rune_1 (data, no_contribute_to_line_height);
 if (prop)
 	{
 	  if (no_prop)
 	    return ADD_FAILED;
 	      struct prop_block pb;
 	      Bytecount len = end - pos;
 	      prop = Dynarr_new (prop_block);
 	      pb.type = PROP_STRING;
-	      pb.data.p_string.str = xnew_array (Intbyte, len);
+	      pb.data.p_string.str = xnew_array (Ibyte, len);
 	      strncpy ((char *) pb.data.p_string.str, (char *) pos, len);
 	      pb.data.p_string.len = len;
 	      Dynarr_add (prop, pb);
 	      return prop;
 	    }
 	}
-INC_CHARPTR (pos);
+INC_IBYTEPTR (pos);
 assert (pos <= end);
 /* #### Duplicate code from add_string_to_fstring_db_runes
 	 should we do more?*/
 data->bytepos += pos - old_pos;
 }
 /* Add runes representing a character in octal. */
 #define ADD_NEXT_OCTAL_RUNE_CHAR do				\
 {								\
-if (add_failed || (add_failed = add_emchar_rune (data)))	\
+if (add_failed || (add_failed = add_ichar_rune (data)))	\
 {								\
 struct prop_block pb;					\
 if (!prop)						\
 	prop = Dynarr_new (prop_block);				\
 								\
 static prop_block_dynarr *
 add_octal_runes (pos_data *data)
 {
 prop_block_dynarr *add_failed, *prop = 0;
-Emchar orig_char = data->ch;
+Ichar orig_char = data->ch;
 int orig_cursor_type = data->cursor_type;
 /* Initialize */
 add_failed = NULL;
 add_control_char_runes (pos_data *data, struct buffer *b)
 {
 if (!NILP (b->ctl_arrow))
 {
 prop_block_dynarr *prop;
-Emchar orig_char = data->ch;
+Ichar orig_char = data->ch;
 int old_cursor_type = data->cursor_type;
 /* Initialize */
 prop = NULL;
 	data->ch = '?';
 else
 	data->ch = orig_char ^ 0100;
 data->cursor_type = IGNORE_CURSOR;
-if (add_emchar_rune (data))
+if (add_ichar_rune (data))
 	{
 	  struct prop_block pb;
 	  if (!prop)
 	    prop = Dynarr_new (prop_block);
 {
 prop_block_dynarr *prop = NULL;
 if (STRINGP (entry))
 {
-prop = add_intbyte_string_runes (data,
+prop = add_ibyte_string_runes (data,
 				       XSTRING_DATA   (entry),
 				       XSTRING_LENGTH (entry),
 				       0, 0);
 }
 else if (GLYPHP (entry))
 	}
 }
 else if (CHAR_OR_CHAR_INTP (entry))
 {
 data->ch = XCHAR_OR_CHAR_INT (entry);
-prop = add_emchar_rune (data);
+prop = add_ichar_rune (data);
 }
 else if (CONSP (entry))
 {
 if (EQ (XCAR (entry), Qformat)
 	  && CONSP (XCDR (entry))
 	  && STRINGP (XCAR (XCDR (entry))))
 	{
 	  Lisp_Object format = XCAR (XCDR (entry));
 	  Bytebpos len = XSTRING_LENGTH (format);
-	  Intbyte *src = XSTRING_DATA (format), *end = src + len;
+	  Ibyte *src = XSTRING_DATA (format), *end = src + len;
-	  Intbyte *result = alloca_array (Intbyte, len);
+	  Ibyte *result = alloca_array (Ibyte, len);
-	  Intbyte *dst = result;
+	  Ibyte *dst = result;
 	  while (src < end)
 	    {
-	      Emchar c = charptr_emchar (src);
+	      Ichar c = itext_ichar (src);
-	      INC_CHARPTR (src);
+	      INC_IBYTEPTR (src);
 	      if (c != '%' || src == end)
-		dst += set_charptr_emchar (dst, c);
+		dst += set_itext_ichar (dst, c);
 	      else
 		{
-		  c = charptr_emchar (src);
+		  c = itext_ichar (src);
-		  INC_CHARPTR (src);
+		  INC_IBYTEPTR (src);
 		  switch (c)
 		    {
 		      /*case 'x':
 		      dst += long_to_string_base ((char *)dst, data->ch, 16);
 		      break;*/
 		    case '%':
-		      dst += set_charptr_emchar (dst, '%');
+		      dst += set_itext_ichar (dst, '%');
 		      break;
 		      /* #### unimplemented */
 		    }
 		}
 	    }
-	  prop = add_intbyte_string_runes (data, result, dst - result, 0, 0);
+	  prop = add_ibyte_string_runes (data, result, dst - result, 0, 0);
 	}
 }
 /* Else blow it off because someone added a bad entry and we don't
 have any safe way of signaling an error. */
 	{
 	case PROP_CHAR:
 	  data->ch = pb->data.p_char.ch;
 	  data->byte_cursor_charpos = pb->data.p_char.byte_cursor_charpos;
 	  data->cursor_type = pb->data.p_char.cursor_type;
-	  add_failed = add_emchar_rune (data);
+	  add_failed = add_ichar_rune (data);
 	  if (add_failed)
 	    goto oops_no_more_space;
 	  break;
 	case PROP_STRING:
 	  if (pb->data.p_string.str)
 	    xfree (pb->data.p_string.str);
 	  /* #### bogus bogus -- this doesn't do anything!
-	     Should probably call add_intbyte_string_runes(),
+	     Should probably call add_ibyte_string_runes(),
 	     once that function is fixed. */
 	  break;
 	case PROP_MINIBUF_PROMPT:
 	  {
 	    face_index old_findex = data->findex;
 	    data->byte_charpos = 0;
 	    data->cursor_type = NO_CURSOR;
 	    while (pb->data.p_string.len > 0)
 	      {
-		data->ch = charptr_emchar (pb->data.p_string.str);
+		data->ch = itext_ichar (pb->data.p_string.str);
-		add_failed = add_emchar_rune (data);
+		add_failed = add_ichar_rune (data);
 		if (add_failed)
 		  {
 		    data->findex = old_findex;
 		    data->byte_charpos = byte_old_charpos;
 		    goto oops_no_more_space;
 		  }
 		else
 		  {
 		    /* Complicated equivalent of ptr++, len-- */
-		    Intbyte *oldpos = pb->data.p_string.str;
+		    Ibyte *oldpos = pb->data.p_string.str;
-		    INC_CHARPTR (pb->data.p_string.str);
+		    INC_IBYTEPTR (pb->data.p_string.str);
 		    pb->data.p_string.len -= pb->data.p_string.str - oldpos;
 		  }
 	      }
 	    data->findex = old_findex;
 	  data->findex = findex;
 	  data->byte_start_col_enabled = 0;
 	  if (!allow_cursor)
 	    data->byte_charpos = 0;
-	  add_intbyte_string_runes (data, XSTRING_DATA (string),
+	  add_ibyte_string_runes (data, XSTRING_DATA (string),
 				    XSTRING_LENGTH (string), 0, 1);
 	  data->findex = orig_findex;
 	  data->byte_charpos = orig_charpos;
 	  data->byte_start_col_enabled = orig_start_col_enabled;
 	  return retval;
 #s(range-table data ((256 524288) (format "%x")))
 Since more than one display table is possible, you have
 great flexibility in mapping ranges of characters.  */
-Emchar printable_min = (CHAR_OR_CHAR_INTP (b->ctl_arrow)
+Ichar printable_min = (CHAR_OR_CHAR_INTP (b->ctl_arrow)
 			  ? XCHAR_OR_CHAR_INT (b->ctl_arrow)
 			  : ((EQ (b->ctl_arrow, Qt) || EQ (b->ctl_arrow, Qnil))
 			     ? 255 : 160));
 Lisp_Object face_dt, window_dt;
 		      Dynarr_free (*prop);
 		      *prop = 0;
 		    }
 		  else {
 		    data.blank_width = DEVMETH (d, eol_cursor_width, ());
-		    add_emchar_rune (&data); /* discard prop data. */
+		    add_ichar_rune (&data); /* discard prop data. */
 		    goto done;
 		  }
 		}
 	      else
 		goto done;
 		      /* Cheesy, cheesy, cheesy.  We mark the end of the
 			 line with a special "character rune" whose width
 			 is the EOL cursor width and whose character is
 			 the non-printing character '\n'. */
 		      data.blank_width = DEVMETH (d, eol_cursor_width, ());
-		      *prop = add_emchar_rune (&data);
+		      *prop = add_ichar_rune (&data);
 		    }
 		  /* We need to set data.byte_charpos to the start of the
 next visible region in order to make this line
 appear to contain all of the invisible area.
 		    DEC_BYTEBPOS (b, data.byte_charpos);
 		}
 	      else
 		{
 		  data.blank_width = DEVMETH (d, eol_cursor_width, ());
-		  *prop = add_emchar_rune (&data);
+		  *prop = add_ichar_rune (&data);
 		}
 	      goto done;
 	    }
 		  data.findex = DEFAULT_INDEX;
 		  data.start_col = 0;
 		  data.start_col_xoffset = 0;
 		  data.byte_start_col_enabled = 0;
-		  add_emchar_rune (&data);
+		  add_ichar_rune (&data);
 		}
 	      /* This had better be a newline but doing it this way
 we'll see obvious incorrect results if it isn't.  No
 need to abort here. */
 	  /* If the current character is considered to be printable, then
 just add it. */
 	  else if (data.ch >= printable_min)
 	    {
-	      *prop = add_emchar_rune (&data);
+	      *prop = add_ichar_rune (&data);
 	      if (*prop)
 		goto done;
 	    }
 	  /* If the current character is a tab, determine the next tab
 	     The is_*() routines have undefined results on
 	     arguments outside of the range [-1, 255].  (This
 	     often bites people who carelessly use `char' instead
 	     of `unsigned char'.)
 	     */
-	  else if (data.ch < 0x100 && iscntrl ((Intbyte) data.ch))
+	  else if (data.ch < 0x100 && iscntrl ((Ibyte) data.ch))
 	    {
 	      *prop = add_control_char_runes (&data, b);
 	      if (*prop)
 		goto done;
 	  /* Assume the current character is considered to be printable,
 then just add it. */
 	  else
 	    {
-	      *prop = add_emchar_rune (&data);
+	      *prop = add_ichar_rune (&data);
 	      if (*prop)
 		goto done;
 	    }
 	  INC_BYTEBPOS (b, data.byte_charpos);
 		  /* This duplicates code down below to add a newline to
 the end of an otherwise empty line.*/
 		  data.ch = '\n';
 		  data.blank_width = DEVMETH (d, eol_cursor_width, ());
-		  add_emchar_rune (&data);
+		  add_ichar_rune (&data);
 		}
 	    }
 	  INC_BYTEBPOS (b, data.byte_charpos);
 	}
 data.start_col = 0;
 data.start_col_xoffset = 0;
 data.byte_start_col_enabled = 0;
 data.max_pixpos += data.blank_width;
-add_emchar_rune (&data);
+add_ichar_rune (&data);
 data.max_pixpos -= data.blank_width;
 /* #### urk!  Chuck, this shit is bad news.  Going around
 	 manipulating invalid positions is guaranteed to result in
 	 trouble sooner or later. */
 Dynarr_reset (data.db->runes);
 if (STRINGP (Voverlay_arrow_string))
 {
-add_intbyte_string_runes
+add_ibyte_string_runes
 	(&data,
 	 XSTRING_DATA   (Voverlay_arrow_string),
 	 XSTRING_LENGTH (Voverlay_arrow_string),
 	 1, 0);
 }
 /* Now create the result string and frob the extents into it. */
 if (!NILP (result_str))
 {
 int elt;
 Bytecount len;
-Intbyte *strdata;
+Ibyte *strdata;
 struct buffer *buf = XBUFFER (WINDOW_BUFFER (w));
 in_modeline_generation = 1;
 sledgehammer_check_ascii_begin (result_str);
 for (elt = 0, len = 0; elt < Dynarr_length (db->runes); elt++)
 {
 if (Dynarr_atp (db->runes, elt)->type == RUNE_CHAR)
 {
-len += (set_charptr_emchar
+len += (set_itext_ichar
 (strdata + len, Dynarr_atp (db->runes,
 elt)->object.chr.ch));
 }
 }
 for any embedded faces. */
 dl->ypos = WINDOW_BOTTOM (w) - dl->descent - ypos_adj;
 }
 static Charcount
-add_string_to_fstring_db_runes (pos_data *data, const Intbyte *str,
+add_string_to_fstring_db_runes (pos_data *data, const Ibyte *str,
 Charcount pos, Charcount min_pos,
 				Charcount max_pos)
 {
 /* This function has been Mule-ized. */
 Charcount end;
-const Intbyte *cur_pos = str;
+const Ibyte *cur_pos = str;
 struct display_block *db = data->db;
 data->blank_width = space_width (XWINDOW (data->window));
 while (Dynarr_length (db->runes) < pos)
 add_blank_rune (data, NULL, 0);
 if (max_pos != -1)
 end = min (max_pos, end);
 while (pos < end && *cur_pos)
 {
-const Intbyte *old_cur_pos = cur_pos;
+const Ibyte *old_cur_pos = cur_pos;
 int succeeded;
-data->ch = charptr_emchar (cur_pos);
+data->ch = itext_ichar (cur_pos);
-succeeded = (add_emchar_rune (data) != ADD_FAILED);
+succeeded = (add_ichar_rune (data) != ADD_FAILED);
-INC_CHARPTR (cur_pos);
+INC_IBYTEPTR (cur_pos);
 if (succeeded)
 {
 pos++;
 data->modeline_charpos++;
 data->bytepos += cur_pos - old_cur_pos;
 if (STRINGP (elt))
 {
 /* A string.  Add to the display line and check for %-constructs
 within it. */
-Intbyte *this = XSTRING_DATA (elt);
+Ibyte *this = XSTRING_DATA (elt);
 while ((pos < max_pos || max_pos == -1) && *this)
 {
-Intbyte *last = this;
+Ibyte *last = this;
 while (*this && *this != '%')
 this++;
 if (this != last)
 		*offset -= size;
 	      else
 		{
 		  Charcount tmp_max = (max_pos == -1 ? pos + size - *offset :
 				       min (pos + size - *offset, max_pos));
-		  const Intbyte *tmp_last = charptr_n_addr (last, *offset);
+		  const Ibyte *tmp_last = itext_n_addr (last, *offset);
 		  pos = add_string_to_fstring_db_runes (data, tmp_last,
 							pos, pos, tmp_max);
 		  *offset = 0;
 		}
 num_to_add = max_pos - pos;
 else
 {
 int cur_pixsize;
 int dash_pixsize;
-Intbyte ch = '-';
+Ibyte ch = '-';
 SET_CURRENT_MODE_CHARS_PIXSIZE;
 dash_pixsize =
 redisplay_text_width_string (w, findex, &ch, Qnil, 0,
 1);
 num_to_add++;
 }
 while (num_to_add--)
 pos = add_string_to_fstring_db_runes
-(data, (const Intbyte *) "-", pos, pos, max_pos);
+(data, (const Ibyte *) "-", pos, pos, max_pos);
 }
 else if (*this != 0)
 {
-Emchar ch = charptr_emchar (this);
+Ichar ch = itext_ichar (this);
-Intbyte *str;
+Ibyte *str;
 		  Charcount size;
 decode_mode_spec (w, ch, type);
-str = Dynarr_atp (mode_spec_intbyte_string, 0);
+str = Dynarr_atp (mode_spec_ibyte_string, 0);
 		  size = bytecount_to_charcount
 		    /* Skip the null character added by `decode_mode_spec' */
-		    (str, Dynarr_length (mode_spec_intbyte_string)) - 1;
+		    (str, Dynarr_length (mode_spec_ibyte_string)) - 1;
 		  if (size <= *offset)
 		    *offset -= size;
 		  else
 		    {
-		      const Intbyte *tmp_str = charptr_n_addr (str, *offset);
+		      const Ibyte *tmp_str = itext_n_addr (str, *offset);
 		      /* #### NOTE: I don't understand why a tmp_max is not
 			 computed and used here as in the plain string case
 			 above. -- dv */
 		      pos = add_string_to_fstring_db_runes (data, tmp_str,
 		    }
 }
 /* NOT this++.  There could be any sort of character at
 the current position. */
-INC_CHARPTR (this);
+INC_IBYTEPTR (this);
 }
 if (max_pixsize > 0)
 {
 int cur_pixsize;
 {
 	  /* If value is a string, output that string literally:
 don't check for % within it.  */
 if (STRINGP (tem))
 {
-	      Intbyte *str = XSTRING_DATA (tem);
+	      Ibyte *str = XSTRING_DATA (tem);
 	      Charcount size = string_char_length (tem);
 	      if (size <= *offset)
 		*offset -= size;
 	      else
 		{
-		  const Intbyte *tmp_str = charptr_n_addr (str, *offset);
+		  const Ibyte *tmp_str = itext_n_addr (str, *offset);
 		  /* #### NOTE: I don't understand why a tmp_max is not
 		     computed and used here as in the plain string case
 		     above. -- dv */
 		  pos = add_string_to_fstring_db_runes (data, tmp_str, pos,
 	if (size <= *offset)
 	  *offset -= size;
 	else
 	  {
-	    const Intbyte *tmp_str =
+	    const Ibyte *tmp_str =
-	      charptr_n_addr ((const Intbyte *) str, *offset);
+	      itext_n_addr ((const Ibyte *) str, *offset);
 	    /* #### NOTE: I don't understand why a tmp_max is not computed and
 	       used here as in the plain string case above. -- dv */
 	    pos = add_string_to_fstring_db_runes (data, tmp_str, pos,
 						  min_pos, max_pos);
 }
 }
 if (min_pos > pos)
 {
-add_string_to_fstring_db_runes (data, (const Intbyte *) "", pos,
+add_string_to_fstring_db_runes (data, (const Ibyte *) "", pos,
 				      min_pos, -1);
 }
 return pos;
 }
 #s(range-table data ((256 524288) (format "%x")))
 Since more than one display table is possible, you have
 great flexibility in mapping ranges of characters.  */
-Emchar printable_min = b ? (CHAR_OR_CHAR_INTP (b->ctl_arrow)
+Ichar printable_min = b ? (CHAR_OR_CHAR_INTP (b->ctl_arrow)
 			  ? XCHAR_OR_CHAR_INT (b->ctl_arrow)
 			  : ((EQ (b->ctl_arrow, Qt) || EQ (b->ctl_arrow, Qnil))
 			     ? 255 : 160)) : 255;
 Lisp_Object face_dt, window_dt;
 	 here rather than doing them at the end of handling the
 	 previous run so that glyphs at the beginning and end of
 	 a line are handled correctly. */
 else if (Dynarr_length (data.ef->end_glyphs) > 0)
 	{
-	  data.ch = string_emchar (disp_string, data.byte_charpos);
+	  data.ch = string_ichar (disp_string, data.byte_charpos);
 	  *prop = add_glyph_runes (&data, END_GLYPHS);
 	  if (*prop) {
 	    goto done;
 	  }
 	}
 /* If there are begin glyphs, add them to the line. */
 else if (Dynarr_length (data.ef->begin_glyphs) > 0)
 	{
-	  data.ch = string_emchar (disp_string, data.byte_charpos);
+	  data.ch = string_ichar (disp_string, data.byte_charpos);
 	  *prop = add_glyph_runes (&data, BEGIN_GLYPHS);
 	  if (*prop) {
 	    goto done;
 	  }
 else
 	{
 	  Lisp_Object entry = Qnil;
 	  /* Get the character at the current buffer position. */
-	  data.ch = string_emchar (disp_string, data.byte_charpos);
+	  data.ch = string_ichar (disp_string, data.byte_charpos);
 	  if (!NILP (face_dt) || !NILP (window_dt))
 	    entry = display_table_entry (data.ch, face_dt, window_dt);
 	  /* If there is a display table entry for it, hand it off to
 add_disp_table_entry_runes and let it worry about it. */
 	  /* If the current character is considered to be printable, then
 just add it. */
 	  else if (data.ch >= printable_min)
 	    {
-	      *prop = add_emchar_rune (&data);
+	      *prop = add_ichar_rune (&data);
 	      if (*prop)
 		goto done;
 	    }
 	  /* If the current character is a tab, determine the next tab
 	     The is_*() routines have undefined results on
 	     arguments outside of the range [-1, 255].  (This
 	     often bites people who carelessly use `char' instead
 	     of `unsigned char'.)
 	     */
-	  else if (data.ch < 0x100 && iscntrl ((Intbyte) data.ch))
+	  else if (data.ch < 0x100 && iscntrl ((Ibyte) data.ch))
 	    {
 	      *prop = add_control_char_runes (&data, b);
 	      if (*prop)
 		goto done;
 	  /* Assume the current character is considered to be printable,
 then just add it. */
 	  else
 	    {
-	      *prop = add_emchar_rune (&data);
+	      *prop = add_ichar_rune (&data);
 	      if (*prop)
 		goto done;
 	    }
 	  INC_BYTECOUNT (XSTRING_DATA (disp_string), data.byte_charpos);
 	  if (truncate_win)
 	    {
 	      Bytecount byte_pos;
 	      /* Now find the start of the next line. */
-	      byte_pos = byte_find_next_emchar_in_string (disp_string, '\n',
+	      byte_pos = byte_find_next_ichar_in_string (disp_string, '\n',
 						      data.byte_charpos, 1);
 	      data.cursor_type = NO_CURSOR;
 	      data.byte_charpos = byte_pos;
 	      gb.glyph = Vtruncation_glyph;
 	  if (data.end_glyph_width)
 	    add_glyph_rune (&data, &gb, BEGIN_GLYPHS, 0, cachel);
 	  if (truncate_win && data.byte_charpos == byte_string_zv)
 	    {
-	      const Intbyte *endb = charptr_n_addr (XSTRING_DATA (disp_string),
+	      const Ibyte *endb = itext_n_addr (XSTRING_DATA (disp_string),
 						    byte_string_zv);
-	      DEC_CHARPTR (endb);
+	      DEC_IBYTEPTR (endb);
-	      if (charptr_emchar (endb) != '\n')
+	      if (itext_ichar (endb) != '\n')
 		{
 		  /* #### Damn this losing shit. */
 		  data.byte_charpos++;
 		}
 	    }
 }
 /* Given a character representing an object in a modeline
 specification, return a string (stored into the global array
-`mode_spec_intbyte_string') with the information that object
+`mode_spec_ibyte_string') with the information that object
 represents.
 This function is largely unchanged from previous versions of the
 redisplay engine.
 Warning! This code is also used for frame titles and can be called
 very early in the device/frame update process!  JV
 */
 static void
-decode_mode_spec (struct window *w, Emchar spec, int type)
+decode_mode_spec (struct window *w, Ichar spec, int type)
 {
 Lisp_Object obj = Qnil;
 const char *str = NULL;
 struct buffer *b = XBUFFER (w->buffer);
-Dynarr_reset (mode_spec_intbyte_string);
+Dynarr_reset (mode_spec_ibyte_string);
 switch (spec)
 {
 /* print buffer name */
 case 'b':
 	int col = column_at_point (b, pt, 1) + !!column_number_start_at_one;
 	char buf[DECIMAL_PRINT_SIZE (long)];
 	long_to_string (buf, col);
-	Dynarr_add_many (mode_spec_intbyte_string,
+	Dynarr_add_many (mode_spec_ibyte_string,
-			 (const Intbyte *) buf, strlen (buf));
+			 (const Ibyte *) buf, strlen (buf));
 	goto decode_mode_spec_done;
 }
 /* print the file coding system */
 case 'C':
 2-digit number that is close. */
 	  if (percent == 100)
 	    percent = 99;
 	  sprintf (buf, "%d%%", percent);
-	  Dynarr_add_many (mode_spec_intbyte_string, (Intbyte *) buf,
+	  Dynarr_add_many (mode_spec_ibyte_string, (Ibyte *) buf,
 			   strlen (buf));
 	  goto decode_mode_spec_done;
 	}
 break;
 	  if (toppos <= BUF_BEGV (b))
 	    sprintf (buf, "Top%d%%", percent);
 	  else
 	    sprintf (buf, "%d%%", percent);
-	  Dynarr_add_many (mode_spec_intbyte_string, (Intbyte *) buf,
+	  Dynarr_add_many (mode_spec_ibyte_string, (Ibyte *) buf,
 			   strlen (buf));
 	  goto decode_mode_spec_done;
 	}
 break;
 	  str = "[[[... ";
 	  break;
 	}
 for (i = 0; i < command_loop_level; i++)
-	Dynarr_add (mode_spec_intbyte_string, '[');
+	Dynarr_add (mode_spec_ibyte_string, '[');
 goto decode_mode_spec_done;
 }
 /* print one ] for each recursive editing level. */
 	  str = "...]]]";
 	  break;
 	}
 for (i = 0; i < command_loop_level; i++)
-	Dynarr_add (mode_spec_intbyte_string, ']');
+	Dynarr_add (mode_spec_ibyte_string, ']');
 goto decode_mode_spec_done;
 }
 /* print infinitely many dashes -- handle at top level now */
 break;
 }
 if (STRINGP (obj))
-Dynarr_add_many (mode_spec_intbyte_string,
+Dynarr_add_many (mode_spec_ibyte_string,
 		     XSTRING_DATA   (obj),
 		     XSTRING_LENGTH (obj));
 else if (str)
-Dynarr_add_many (mode_spec_intbyte_string, (Intbyte *) str, strlen (str));
+Dynarr_add_many (mode_spec_ibyte_string, (Ibyte *) str, strlen (str));
 decode_mode_spec_done:
-Dynarr_add (mode_spec_intbyte_string, '\0');
+Dynarr_add (mode_spec_ibyte_string, '\0');
 }
 /* Given a display line, free all of its data structures. */
 static void
 if (!initialized)
 #endif
 {
 if (!cmotion_display_lines)
 	cmotion_display_lines = Dynarr_new (display_line);
-if (!mode_spec_intbyte_string)
+if (!mode_spec_ibyte_string)
-	mode_spec_intbyte_string = Dynarr_new (Intbyte);
+	mode_spec_ibyte_string = Dynarr_new (Ibyte);
 if (!formatted_string_extent_dynarr)
 	formatted_string_extent_dynarr = Dynarr_new (EXTENT);
 if (!formatted_string_extent_start_dynarr)
 	formatted_string_extent_start_dynarr = Dynarr_new (Bytecount);
 if (!formatted_string_extent_end_dynarr)

Mercurial > hg > xemacs-beta

comparison src/redisplay.c @ 867:804517e16990