(current_column_1, Fmove_to_column):

Update call to CHAR_HEAD_P.

(indented_beyond_p): Take POS in bytes and chars.  Callers changed.
(pos_tab_indent): Function moved to xdisp.c.

(Fcurrent_indentation): Use scan_newline and SET_PT_BOTH.
(indented_beyond_p, current_column_1): Likewise.

(vmotion, compute_motion): Set up bytepos value to return it.
(current_column): Handle bytepos and charpos.
(position_indentation): Take bytepos as arg, and scan with it.  Calls changed.
(Fmove_to_column): Scan with bytepos and charpos.
(pos_tab_offset): Use bytepos to do FETCH_BYTE.
(skip_invisible): Don't worry about position in middle of character.

1 files changed, 161 insertions, 108 deletions

diff --git a/src/indent.c b/src/indent.c
index b4592a2dddf..cf8e361a00c 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -53,6 +53,7 @@ int last_known_column_point;
 int last_known_column_modified;
 
 static int current_column_1 ();
+static int position_indentation ();
 
 /* Cache of beginning of line found by the last call of
    current_column. */
@@ -243,6 +244,7 @@ skip_invisible (pos, next_boundary_p, to, window)
 	proplimit = overlay_limit;
       end = XFASTINT (Fnext_single_property_change (position, Qinvisible,
 						    buffer, proplimit));
+#if 0
       /* Don't put the boundary in the middle of multibyte form if
          there is no actual property change.  */
       if (end == pos + 100
@@ -250,6 +252,7 @@ skip_invisible (pos, next_boundary_p, to, window)
 	  && end < ZV)
 	while (pos < end && !CHAR_HEAD_P (POS_ADDR (end)))
 	  end--;
+#endif
       *next_boundary_p = end;
     }
   /* if the `invisible' property is set, we can skip to
@@ -317,7 +320,7 @@ current_column ()
      counting width.  Tab characters are the only complicated case.  */
 
   /* Make a pointer for decrementing through the chars before point.  */
-  ptr = POS_ADDR (PT - 1) + 1;
+  ptr = BYTE_POS_ADDR (PT_BYTE - 1) + 1;
   /* Make a pointer to where consecutive chars leave off,
      going backwards from point.  */
   if (PT == BEGV)
@@ -379,7 +382,8 @@ current_column ()
   if (ptr == BEGV_ADDR)
     current_column_bol_cache = BEGV;
   else
-    current_column_bol_cache = PTR_CHAR_POS (ptr);
+    current_column_bol_cache = BYTE_TO_CHAR (PTR_BYTE_POS (ptr));
+
   last_known_column = col;
   last_known_column_point = PT;
   last_known_column_modified = MODIFF;
@@ -399,12 +403,20 @@ current_column_1 (pos)
   register int tab_width = XINT (current_buffer->tab_width);
   register int ctl_arrow = !NILP (current_buffer->ctl_arrow);
   register struct Lisp_Char_Table *dp = buffer_display_table ();
+  int multibyte = !NILP (current_buffer->enable_multibyte_characters);
 
   /* Start the scan at the beginning of this line with column number 0.  */
   register int col = 0;
-  int scan = current_column_bol_cache = find_next_newline (pos, -1);
-  int next_boundary = scan;
-  int multibyte = !NILP (current_buffer->enable_multibyte_characters);
+  int scan, scan_byte;
+  int next_boundary, next_boundary_byte;
+  int opoint = PT, opoint_byte = PT_BYTE;
+
+  scan_newline (pos, CHAR_TO_BYTE (pos), BEGV, BEGV_BYTE, -1, 1);
+  current_column_bol_cache = PT;
+  scan = PT, scan_byte = PT_BYTE;
+  SET_PT_BOTH (opoint, opoint_byte);
+  next_boundary = scan;
+  next_boundary_byte = scan_byte;
 
   if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
 
@@ -416,11 +428,15 @@ current_column_1 (pos)
       /* Occasionally we may need to skip invisible text.  */
       while (scan == next_boundary)
 	{
+	  int old_scan = scan;
 	  /* This updates NEXT_BOUNDARY to the next place
 	     where we might need to skip more invisible text.  */
 	  scan = skip_invisible (scan, &next_boundary, pos, Qnil);
 	  if (scan >= pos)
 	    goto endloop;
+	  if (scan != old_scan)
+	    scan_byte = CHAR_TO_BYTE (scan);
+	  next_boundary_byte = CHAR_TO_BYTE (next_boundary);
 	}
 
       c = FETCH_BYTE (scan);
@@ -428,6 +444,7 @@ current_column_1 (pos)
 	{
 	  col += XVECTOR (DISP_CHAR_VECTOR (dp, c))->size;
 	  scan++;
+	  scan_byte++;
 	  continue;
 	}
       if (c == '\n')
@@ -435,6 +452,7 @@ current_column_1 (pos)
       if (c == '\r' && EQ (current_buffer->selective_display, Qt))
 	break;
       scan++;
+      scan_byte++;
       if (c == '\t')
 	{
 	  int prev_col = col;
@@ -443,21 +461,22 @@ current_column_1 (pos)
 	}
       else if (multibyte && BASE_LEADING_CODE_P (c))
 	{
-	  scan--;
+	  scan_byte--;
 	  /* Start of multi-byte form.  */
 	  if (c == LEADING_CODE_COMPOSITION)
 	    {
-	      unsigned char *ptr = POS_ADDR (scan);
+	      unsigned char *ptr = BYTE_POS_ADDR (scan_byte);
 
-	      int cmpchar_id = str_cmpchar_id (ptr, next_boundary - scan);
+	      int cmpchar_id
+		= str_cmpchar_id (ptr, next_boundary_byte - scan_byte);
 	      if (cmpchar_id >= 0)
 		{
-		  scan += cmpchar_table[cmpchar_id]->len,
+		  scan_byte += cmpchar_table[cmpchar_id]->len;
 		  col += cmpchar_table[cmpchar_id]->width;
 		}
 	      else
 		{		/* invalid composite character */
-		  scan++;
+		  scan_byte++;
 		  col += 4;
 		}
 	    }
@@ -467,12 +486,14 @@ current_column_1 (pos)
 		 constituents of multi-byte form.  */
 	      int len = BYTES_BY_CHAR_HEAD (c), i;
 
-	      for (i = 1, scan++; i < len; i++, scan++)
+	      for (i = 1, scan_byte++; i < len; i++, scan_byte++)
 		/* We don't need range checking for PTR because there
 		   are anchors (`\0') at GAP and Z.  */
-		if (CHAR_HEAD_P (POS_ADDR (scan))) break;
+		if (CHAR_HEAD_P (FETCH_BYTE (scan_byte)))
+		  break;
+
 	      if (i < len)
-		col += 4, scan -= i - 1;
+		col += 4, scan_byte -= i - 1;
 	      else
 		col += WIDTH_BY_CHAR_HEAD (c);
 	    }
@@ -628,25 +649,30 @@ following any initial whitespace.")
   ()
 {
   Lisp_Object val;
+  int opoint = PT, opoint_byte = PT_BYTE;
+
+  scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -1, 1);
 
-  XSETFASTINT (val, position_indentation (find_next_newline (PT, -1)));
+  XSETFASTINT (val, position_indentation (PT_BYTE));
+  SET_PT_BOTH (opoint, opoint_byte);
   return val;
 }
 
-position_indentation (pos)
-     register int pos;
+static int
+position_indentation (pos_byte)
+     register int pos_byte;
 {
   register int column = 0;
   register int tab_width = XINT (current_buffer->tab_width);
   register unsigned char *p;
   register unsigned char *stop;
   unsigned char *start;
-  int next_boundary = pos;
-  int ceiling = pos;
+  int next_boundary_byte = pos_byte;
+  int ceiling = next_boundary_byte;
 
   if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
 
-  p = POS_ADDR (pos);
+  p = BYTE_POS_ADDR (pos_byte);
   /* STOP records the value of P at which we will need
      to think about the gap, or about invisible text,
      or about the end of the buffer.  */
@@ -657,28 +683,34 @@ position_indentation (pos)
     {
       while (p == stop)
 	{
-	  int stop_pos;
+	  int stop_pos_byte;
 
-	  /* If we have updated P, set POS to match.
-	     The first time we enter the loop, POS is already right.  */
+	  /* If we have updated P, set POS_BYTE to match.
+	     The first time we enter the loop, POS_BYTE is already right.  */
 	  if (p != start)
-	    pos = PTR_CHAR_POS (p);
+	    pos_byte = PTR_BYTE_POS (p);
 	  /* Consider the various reasons STOP might have been set here.  */
-	  if (pos == ZV)
+	  if (pos_byte == ZV_BYTE)
 	    return column;
-	  if (pos == next_boundary)
-	    pos = skip_invisible (pos, &next_boundary, ZV, Qnil);
-	  if (pos >= ceiling)
-	    ceiling = BUFFER_CEILING_OF (pos) + 1;
+	  if (pos_byte == next_boundary_byte)
+	    {
+	      int next_boundary;
+	      int pos = BYTE_TO_CHAR (pos_byte);
+	      pos = skip_invisible (pos, &next_boundary, ZV, Qnil);
+	      pos_byte = CHAR_TO_BYTE (pos);
+	      next_boundary_byte = CHAR_TO_BYTE (next_boundary);
+	    }
+	  if (pos_byte >= ceiling)
+	    ceiling = BUFFER_CEILING_OF (pos_byte) + 1;
 	  /* Compute the next place we need to stop and think,
 	     and set STOP accordingly.  */
-	  stop_pos = min (ceiling, next_boundary);
+	  stop_pos_byte = min (ceiling, next_boundary_byte);
 	  /* The -1 and +1 arrange to point at the first byte of gap
-	     (if STOP_POS is the position of the gap)
+	     (if STOP_POS_BYTE is the position of the gap)
 	     rather than at the data after the gap.  */
 	     
-	  stop = POS_ADDR (stop_pos - 1) + 1;
-	  p = POS_ADDR (pos);
+	  stop = BYTE_POS_ADDR (stop_pos_byte - 1) + 1;
+	  p = BYTE_POS_ADDR (pos_byte);
 	}
       switch (*p++)
 	{
@@ -696,13 +728,14 @@ position_indentation (pos)
 	      || NILP (current_buffer->enable_multibyte_characters))
 	    return column;
 	  {
-	    int pos = PTR_CHAR_POS (p - 1);
-	    int c = FETCH_MULTIBYTE_CHAR (pos);
+	    int c;
+	    pos_byte = PTR_BYTE_POS (p - 1);
+	    c = FETCH_MULTIBYTE_CHAR (pos_byte);
 	    if (CHAR_HAS_CATEGORY (c, ' '))
 	      {
 		column++;
-		INC_POS (pos);
-		p = POS_ADDR (pos);
+		INC_POS (pos_byte);
+		p = BYTE_POS_ADDR (pos_byte);
 	      }
 	    else
 	      return column;
@@ -714,13 +747,21 @@ position_indentation (pos)
 /* Test whether the line beginning at POS is indented beyond COLUMN.
    Blank lines are treated as if they had the same indentation as the
    preceding line.  */
+
 int
-indented_beyond_p (pos, column)
-     int pos, column;
+indented_beyond_p (pos, pos_byte, column)
+     int pos, pos_byte, column;
 {
-  while (pos > BEGV && FETCH_BYTE (pos) == '\n')
-    pos = find_next_newline_no_quit (pos - 1, -1);
-  return (position_indentation (pos) >= column);
+  Lisp_Object val;
+  int opoint = PT, opoint_byte = PT_BYTE;
+
+  SET_PT_BOTH (pos, pos_byte);
+  while (PT > BEGV && FETCH_BYTE (PT_BYTE) == '\n')
+    scan_newline (PT - 1, PT_BYTE - 1, BEGV, BEGV_BYTE, -1, 0);
+
+  XSETFASTINT (val, position_indentation (PT_BYTE));
+  SET_PT_BOTH (opoint, opoint_byte);
+  return val;
 }
 
 DEFUN ("move-to-column", Fmove_to_column, Smove_to_column, 1, 2, "p",
@@ -753,16 +794,20 @@ The return value is the current column.")
   Lisp_Object val;
   int prev_col;
   int c;
-
   int next_boundary;
 
+  int pos_byte, end_byte, next_boundary_byte;
+
   if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
   CHECK_NATNUM (column, 0);
   goal = XINT (column);
 
   pos = PT;
+  pos_byte = PT_BYTE;
   end = ZV;
+  end_byte = ZV_BYTE;
   next_boundary = pos;
+  next_boundary_byte = PT_BYTE;
 
   /* If we're starting past the desired column,
      back up to beginning of line and scan from there.  */
@@ -770,6 +815,7 @@ The return value is the current column.")
     {
       end = pos;
       pos = current_column_bol_cache;
+      pos_byte = CHAR_TO_BYTE (pos);
       col = 0;
     }
 
@@ -777,7 +823,11 @@ The return value is the current column.")
     {
       while (pos == next_boundary)
 	{
+	  int prev = pos;
 	  pos = skip_invisible (pos, &next_boundary, end, Qnil);
+	  if (pos != prev)
+	    pos_byte = CHAR_TO_BYTE (pos);
+	  next_boundary_byte = CHAR_TO_BYTE (next_boundary);
 	  if (pos >= end)
 	    goto endloop;
 	}
@@ -788,10 +838,11 @@ The return value is the current column.")
       if (col >= goal)
 	break;
 
-      c = FETCH_BYTE (pos);
+      c = FETCH_BYTE (pos_byte);
       if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
 	{
 	  col += XVECTOR (DISP_CHAR_VECTOR (dp, c))->size;
+	  pos_byte++;
 	  pos++;
 	  continue;
 	}
@@ -800,6 +851,7 @@ The return value is the current column.")
       if (c == '\r' && EQ (current_buffer->selective_display, Qt))
 	break;
       pos++;
+      pos_byte++;
       if (c == '\t')
 	{
 	  prev_col = col;
@@ -817,21 +869,21 @@ The return value is the current column.")
 	  /* Start of multi-byte form.  */
 	  unsigned char *ptr;
 
-	  pos--;		/* rewind to the character head */
-	  ptr = POS_ADDR (pos);
+	  pos_byte--;		/* rewind to the character head */
+	  ptr = BYTE_POS_ADDR (pos_byte);
 	  if (c == LEADING_CODE_COMPOSITION)
 	    {
-	      int cmpchar_id = str_cmpchar_id (ptr, end - pos);
+	      int cmpchar_id = str_cmpchar_id (ptr, end_byte - pos_byte);
 
 	      if (cmpchar_id >= 0)
 		{
 		  col += cmpchar_table[cmpchar_id]->width;
-		  pos += cmpchar_table[cmpchar_id]->len;
+		  pos_byte += cmpchar_table[cmpchar_id]->len;
 		}
 	      else
 		{		/* invalid composite character */
 		  col += 4;
-		  pos++;
+		  pos_byte++;
 		}
 	    }
 	  else
@@ -843,11 +895,13 @@ The return value is the current column.")
 	      for (i = 1, ptr++; i < len; i++, ptr++)
 		/* We don't need range checking for PTR because there
 		   are anchors (`\0') both at GPT and Z.  */
-		if (CHAR_HEAD_P (ptr)) break;
+		if (CHAR_HEAD_P (*ptr))
+		  break;
+
 	      if (i < len)
-		col += 4, pos++;
+		col += 4, pos_byte++;
 	      else
-		col += WIDTH_BY_CHAR_HEAD (c), pos += i;
+		col += WIDTH_BY_CHAR_HEAD (c), pos_byte += i;
 	    }
 	}
       else
@@ -855,19 +909,20 @@ The return value is the current column.")
     }
  endloop:
 
-  SET_PT (pos);
+  SET_PT_BOTH (pos, pos_byte);
 
   /* If a tab char made us overshoot, change it to spaces
      and scan through it again.  */
   if (!NILP (force) && col > goal && c == '\t' && prev_col < goal)
     {
-      int old_point;
+      int old_point, old_point_byte;
 
       del_range (PT - 1, PT);
       Findent_to (make_number (goal), Qnil);
       old_point = PT;
+      old_point_byte = PT_BYTE;
       Findent_to (make_number (col), Qnil);
-      SET_PT (old_point);
+      SET_PT_BOTH (old_point, old_point_byte);
       /* Set the last_known... vars consistently.  */
       col = goal;
     }
@@ -960,6 +1015,7 @@ compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width,
   register int vpos = fromvpos;
 
   register int pos;
+  int pos_byte;
   register int c;
   register int tab_width = XFASTINT (current_buffer->tab_width);
   register int ctl_arrow = !NILP (current_buffer->ctl_arrow);
@@ -994,6 +1050,7 @@ compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width,
   int wide_column = 0;		/* Set to 1 when a previous character
 				   is wide-colomn.  */
   int prev_pos;			/* Previous buffer position.  */
+  int prev_pos_byte;		/* Previous buffer position.  */
   int contin_hpos;		/* HPOS of last column of continued line.  */
   int prev_tab_offset;		/* Previous tab offset.  */
 
@@ -1013,12 +1070,14 @@ compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width,
   if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
 
   pos = prev_pos = from;
+  pos_byte = prev_pos_byte = CHAR_TO_BYTE (from);
   contin_hpos = 0;
   prev_tab_offset = tab_offset;
   while (1)
     {
       while (pos == next_boundary)
 	{
+	  int pos_here = pos;
 	  int newpos;
 
 	  /* If the caller says that the screen position came from an earlier
@@ -1049,7 +1108,11 @@ compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width,
 	  if (newpos >= to)
 	    goto after_loop;
 
-	  pos = newpos;
+	  if (newpos != pos_here)
+	    {
+	      pos = newpos;
+	      pos_byte = CHAR_TO_BYTE (pos);
+	    }
 	}
 
       /* Handle right margin.  */
@@ -1105,7 +1168,10 @@ compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width,
 	    {
 	      /* Truncating: skip to newline.  */
 	      if (pos <= to)  /* This IF is needed because we may past TO */
-		pos = find_before_next_newline (pos, to, 1);
+		{
+		  pos = find_before_next_newline (pos, to, 1);
+		  pos_byte = CHAR_TO_BYTE (pos);
+		}
 	      hpos = width;
 	      /* If we just skipped next_boundary,
 		 loop around in the main while
@@ -1142,6 +1208,7 @@ compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width,
 	{
 	  /* Go back to the previous position.  */
 	  pos = prev_pos;
+	  pos_byte = prev_pos_byte;
 	  hpos = prev_hpos;
 	  tab_offset = prev_tab_offset;
 
@@ -1181,6 +1248,7 @@ compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width,
 		 to previous value.  It's the beginning of the
 		 line.  */
 	      pos = prev_pos;
+	      pos_byte = prev_pos_byte;
 	      hpos = prev_hpos;
 	      tab_offset = prev_tab_offset;
 	    }
@@ -1191,6 +1259,7 @@ compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width,
 
       prev_hpos = hpos;
       prev_pos = pos;
+      prev_pos_byte = pos_byte;
       wide_column = 0;
 
       /* Consult the width run cache to see if we can avoid inspecting
@@ -1235,7 +1304,11 @@ compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width,
               hpos = run_end_hpos;
               if (run_end > pos)
                 prev_hpos = hpos - common_width;
-              pos = run_end;
+	      if (pos != run_end)
+		{
+		  pos = run_end;
+		  pos_byte = CHAR_TO_BYTE (pos);
+		}
             }
 
           next_width_run = run_end + 1;
@@ -1244,8 +1317,8 @@ compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width,
       /* We have to scan the text character-by-character.  */
       else
 	{
-	  c = FETCH_BYTE (pos);
-	  pos++;
+	  c = FETCH_BYTE (pos_byte);
+	  pos++, pos_byte++;
 
 	  /* Perhaps add some info to the width_run_cache.  */
 	  if (current_buffer->width_run_cache)
@@ -1289,7 +1362,8 @@ compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width,
 	    }
 	  else if (c == '\n')
 	    {
-	      if (selective > 0 && indented_beyond_p (pos, selective))
+	      if (selective > 0
+		  && indented_beyond_p (pos, pos_byte, selective))
 		{
 		  /* If (pos == to), we don't have to take care of
 		    selective display.  */
@@ -1297,9 +1371,12 @@ compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width,
 		    {
 		      /* Skip any number of invisible lines all at once */
 		      do
-			pos = find_before_next_newline (pos, to, 1) + 1;
+			{
+			  pos = find_before_next_newline (pos, to, 1) + 1;
+			  pos_byte = CHAR_TO_BYTE (pos);
+			}
 		      while (pos < to
-			     && indented_beyond_p (pos, selective));
+			     && indented_beyond_p (pos, pos_byte, selective));
 		      /* Allow for the " ..." that is displayed for them. */
 		      if (selective_rlen)
 			{
@@ -1307,7 +1384,7 @@ compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width,
 			  if (hpos >= width)
 			    hpos = width;
 			}
-		      --pos;
+		      DEC_BOTH (pos, pos_byte);
 		      /* We have skipped the invis text, but not the
 			newline after.  */
 		    }
@@ -1331,7 +1408,10 @@ compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width,
 		 everything from a ^M to the end of the line is invisible.
 		 Stop *before* the real newline.  */
 	      if (pos < to)
-		pos = find_before_next_newline (pos, to, 1);
+		{
+		  pos = find_before_next_newline (pos, to, 1);
+		  pos_byte = CHAR_TO_BYTE (pos);
+		}
 	      /* If we just skipped next_boundary,
 		 loop around in the main while
 		 and handle it.  */
@@ -1351,10 +1431,10 @@ compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width,
 	      unsigned char *ptr;
 	      int len, actual_len;
 
-	      pos--;		/* rewind POS */
+	      pos--, pos_byte--;		/* rewind POS */
 
-	      ptr = (((pos) >= GPT ? GAP_SIZE : 0) + (pos) + BEG_ADDR - 1);
-	      len = ((pos) >= GPT ? ZV : GPT) - (pos);
+	      ptr = BYTE_POS_ADDR (pos_byte);
+	      len = BUFFER_CEILING_OF (pos_byte) - pos_byte + 1;
 
 	      c = STRING_CHAR_AND_LENGTH (ptr, len, actual_len);
 
@@ -1378,7 +1458,8 @@ compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width,
 		    wide_column = 1;
 		}
 
-	      pos += actual_len;
+	      pos++;
+	      pos_byte += actual_len;
 	    }
 	  else
 	    hpos += (ctl_arrow && c < 0200) ? 2 : 4;
@@ -1395,6 +1476,7 @@ compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width,
                        width_run_start, width_run_end);
 
   val_compute_motion.bufpos = pos;
+  val_compute_motion.bytepos = pos_byte;
   val_compute_motion.hpos = hpos;
   val_compute_motion.vpos = vpos;
   val_compute_motion.prevhpos = prev_hpos;
@@ -1507,42 +1589,6 @@ DEFUN ("compute-motion", Fcompute_motion, Scompute_motion, 7, 7, 0,
 
 }
 
-/* Return the column of position POS in window W's buffer.
-   The result is rounded down to a multiple of the internal width of W.
-   This is the amount of indentation of position POS
-   that is not visible in its horizontal position in the window.  */
-
-int
-pos_tab_offset (w, pos)
-     struct window *w;
-     register int pos;
-{
-  int opoint = PT;
-  int col;
-  int width = window_internal_width (w) - 1;
-
-  if (pos == BEGV)
-    return MINI_WINDOW_P (w) ? -minibuf_prompt_width : 0;
-  if (FETCH_BYTE (pos - 1) == '\n')
-    return 0;
-  TEMP_SET_PT (pos);
-  col = current_column ();
-  TEMP_SET_PT (opoint);
-  /* Modulo is no longer valid, as a line may get shorter than WIDTH
-     columns by continuation of a wide-column character.  Just return
-     COL here. */
-#if 0
-  /* In the continuation of the first line in a minibuffer we must
-     take the width of the prompt into account.  */
-  if (MINI_WINDOW_P (w) && col >= width - minibuf_prompt_width
-      && find_next_newline_no_quit (pos, -1) == BEGV)
-    return col - (col + minibuf_prompt_width) % width;
-  return col - (col % width);
-#endif
-  return col;
-}
-
-
 /* Fvertical_motion and vmotion */
 struct position val_vmotion;
 
@@ -1558,6 +1604,7 @@ vmotion (from, vtarget, w)
   register int vpos = 0;
   Lisp_Object prevline;
   register int first;
+  int from_byte;
   int lmargin = hscroll > 0 ? 1 - hscroll : 0;
   int selective
     = (INTEGERP (current_buffer->selective_display)
@@ -1585,7 +1632,7 @@ vmotion (from, vtarget, w)
   if (vpos >= vtarget)
     {
       /* To move upward, go a line at a time until
-	 we have gone at least far enough */
+	 we have gone at least far enough.  */
 
       first = 1;
 
@@ -1596,7 +1643,9 @@ vmotion (from, vtarget, w)
 	  XSETFASTINT (prevline, find_next_newline_no_quit (from - 1, -1));
 	  while (XFASTINT (prevline) > BEGV
 		 && ((selective > 0
-		      && indented_beyond_p (XFASTINT (prevline), selective))
+		      && indented_beyond_p (XFASTINT (prevline),
+					    CHAR_TO_BYTE (XFASTINT (prevline)),
+					    selective))
 #ifdef USE_TEXT_PROPERTIES
 		     /* watch out for newlines with `invisible' property */
 		     || (propval = Fget_char_property (prevline,
@@ -1635,6 +1684,7 @@ vmotion (from, vtarget, w)
       if (vpos >= vtarget)
 	{
 	  val_vmotion.bufpos = from;
+	  val_vmotion.bytepos = CHAR_TO_BYTE (from);
 	  val_vmotion.vpos = vpos;
 	  val_vmotion.hpos = lmargin;
 	  val_vmotion.contin = 0;
@@ -1648,14 +1698,17 @@ vmotion (from, vtarget, w)
     }
   /* Moving downward is simple, but must calculate from beg of line
      to determine hpos of starting point */
-  if (from > BEGV && FETCH_BYTE (from - 1) != '\n')
+  from_byte = CHAR_TO_BYTE (from);
+  if (from > BEGV && FETCH_BYTE (from_byte - 1) != '\n')
     {
       Lisp_Object propval;
 
       XSETFASTINT (prevline, find_next_newline_no_quit (from, -1));
       while (XFASTINT (prevline) > BEGV
 	     && ((selective > 0
-		  && indented_beyond_p (XFASTINT (prevline), selective))
+		  && indented_beyond_p (XFASTINT (prevline),
+					CHAR_TO_BYTE (XFASTINT (prevline)),
+					selective))
 #ifdef USE_TEXT_PROPERTIES
 		 /* watch out for newlines with `invisible' property */
 		 || (propval = Fget_char_property (prevline, Qinvisible,