Merge from emacs--devo--0
[emacs.git] / src / indent.c
blob4f5b55acc4771fd688fa6a7a20f2e8cd8296abc7
1 /* Indentation functions.
2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995, 1998, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
23 #include <config.h>
24 #include <stdio.h>
26 #include "lisp.h"
27 #include "buffer.h"
28 #include "character.h"
29 #include "category.h"
30 #include "indent.h"
31 #include "keyboard.h"
32 #include "frame.h"
33 #include "window.h"
34 #include "termchar.h"
35 #include "termopts.h"
36 #include "disptab.h"
37 #include "intervals.h"
38 #include "region-cache.h"
40 /* Indentation can insert tabs if this is non-zero;
41 otherwise always uses spaces. */
43 static int indent_tabs_mode;
45 #define CR 015
47 /* These three values memorize the current column to avoid recalculation. */
49 /* Last value returned by current_column.
50 Some things in set last_known_column_point to -1
51 to mark the memorized value as invalid. */
53 static double last_known_column;
55 /* Value of point when current_column was called. */
57 EMACS_INT last_known_column_point;
59 /* Value of MODIFF when current_column was called. */
61 static int last_known_column_modified;
63 static double current_column_1 P_ ((void));
64 static double position_indentation P_ ((int));
66 /* Cache of beginning of line found by the last call of
67 current_column. */
69 static EMACS_INT current_column_bol_cache;
71 /* Get the display table to use for the current buffer. */
73 struct Lisp_Char_Table *
74 buffer_display_table ()
76 Lisp_Object thisbuf;
78 thisbuf = current_buffer->display_table;
79 if (DISP_TABLE_P (thisbuf))
80 return XCHAR_TABLE (thisbuf);
81 if (DISP_TABLE_P (Vstandard_display_table))
82 return XCHAR_TABLE (Vstandard_display_table);
83 return 0;
86 /* Width run cache considerations. */
88 /* Return the width of character C under display table DP. */
90 static int
91 character_width (c, dp)
92 int c;
93 struct Lisp_Char_Table *dp;
95 Lisp_Object elt;
97 /* These width computations were determined by examining the cases
98 in display_text_line. */
100 /* Everything can be handled by the display table, if it's
101 present and the element is right. */
102 if (dp && (elt = DISP_CHAR_VECTOR (dp, c), VECTORP (elt)))
103 return XVECTOR (elt)->size;
105 /* Some characters are special. */
106 if (c == '\n' || c == '\t' || c == '\015')
107 return 0;
109 /* Printing characters have width 1. */
110 else if (c >= 040 && c < 0177)
111 return 1;
113 /* Everybody else (control characters, metacharacters) has other
114 widths. We could return their actual widths here, but they
115 depend on things like ctl_arrow and crud like that, and they're
116 not very common at all. So we'll just claim we don't know their
117 widths. */
118 else
119 return 0;
122 /* Return true if the display table DISPTAB specifies the same widths
123 for characters as WIDTHTAB. We use this to decide when to
124 invalidate the buffer's width_run_cache. */
127 disptab_matches_widthtab (disptab, widthtab)
128 struct Lisp_Char_Table *disptab;
129 struct Lisp_Vector *widthtab;
131 int i;
133 if (widthtab->size != 256)
134 abort ();
136 for (i = 0; i < 256; i++)
137 if (character_width (i, disptab)
138 != XFASTINT (widthtab->contents[i]))
139 return 0;
141 return 1;
144 /* Recompute BUF's width table, using the display table DISPTAB. */
146 void
147 recompute_width_table (buf, disptab)
148 struct buffer *buf;
149 struct Lisp_Char_Table *disptab;
151 int i;
152 struct Lisp_Vector *widthtab;
154 if (!VECTORP (buf->width_table))
155 buf->width_table = Fmake_vector (make_number (256), make_number (0));
156 widthtab = XVECTOR (buf->width_table);
157 if (widthtab->size != 256)
158 abort ();
160 for (i = 0; i < 256; i++)
161 XSETFASTINT (widthtab->contents[i], character_width (i, disptab));
164 /* Allocate or free the width run cache, as requested by the current
165 state of current_buffer's cache_long_line_scans variable. */
167 static void
168 width_run_cache_on_off ()
170 if (NILP (current_buffer->cache_long_line_scans)
171 /* And, for the moment, this feature doesn't work on multibyte
172 characters. */
173 || !NILP (current_buffer->enable_multibyte_characters))
175 /* It should be off. */
176 if (current_buffer->width_run_cache)
178 free_region_cache (current_buffer->width_run_cache);
179 current_buffer->width_run_cache = 0;
180 current_buffer->width_table = Qnil;
183 else
185 /* It should be on. */
186 if (current_buffer->width_run_cache == 0)
188 current_buffer->width_run_cache = new_region_cache ();
189 recompute_width_table (current_buffer, buffer_display_table ());
195 /* Skip some invisible characters starting from POS.
196 This includes characters invisible because of text properties
197 and characters invisible because of overlays.
199 If position POS is followed by invisible characters,
200 skip some of them and return the position after them.
201 Otherwise return POS itself.
203 Set *NEXT_BOUNDARY_P to the next position at which
204 it will be necessary to call this function again.
206 Don't scan past TO, and don't set *NEXT_BOUNDARY_P
207 to a value greater than TO.
209 If WINDOW is non-nil, and this buffer is displayed in WINDOW,
210 take account of overlays that apply only in WINDOW.
212 We don't necessarily skip all the invisible characters after POS
213 because that could take a long time. We skip a reasonable number
214 which can be skipped quickly. If there might be more invisible
215 characters immediately following, then *NEXT_BOUNDARY_P
216 will equal the return value. */
218 EMACS_INT
219 skip_invisible (pos, next_boundary_p, to, window)
220 EMACS_INT pos;
221 EMACS_INT *next_boundary_p;
222 EMACS_INT to;
223 Lisp_Object window;
225 Lisp_Object prop, position, overlay_limit, proplimit;
226 Lisp_Object buffer, tmp;
227 EMACS_INT end;
228 int inv_p;
230 XSETFASTINT (position, pos);
231 XSETBUFFER (buffer, current_buffer);
233 /* Give faster response for overlay lookup near POS. */
234 recenter_overlay_lists (current_buffer, pos);
236 /* We must not advance farther than the next overlay change.
237 The overlay change might change the invisible property;
238 or there might be overlay strings to be displayed there. */
239 overlay_limit = Fnext_overlay_change (position);
240 /* As for text properties, this gives a lower bound
241 for where the invisible text property could change. */
242 proplimit = Fnext_property_change (position, buffer, Qt);
243 if (XFASTINT (overlay_limit) < XFASTINT (proplimit))
244 proplimit = overlay_limit;
245 /* PROPLIMIT is now a lower bound for the next change
246 in invisible status. If that is plenty far away,
247 use that lower bound. */
248 if (XFASTINT (proplimit) > pos + 100 || XFASTINT (proplimit) >= to)
249 *next_boundary_p = XFASTINT (proplimit);
250 /* Otherwise, scan for the next `invisible' property change. */
251 else
253 /* Don't scan terribly far. */
254 XSETFASTINT (proplimit, min (pos + 100, to));
255 /* No matter what. don't go past next overlay change. */
256 if (XFASTINT (overlay_limit) < XFASTINT (proplimit))
257 proplimit = overlay_limit;
258 tmp = Fnext_single_property_change (position, Qinvisible,
259 buffer, proplimit);
260 end = XFASTINT (tmp);
261 #if 0
262 /* Don't put the boundary in the middle of multibyte form if
263 there is no actual property change. */
264 if (end == pos + 100
265 && !NILP (current_buffer->enable_multibyte_characters)
266 && end < ZV)
267 while (pos < end && !CHAR_HEAD_P (POS_ADDR (end)))
268 end--;
269 #endif
270 *next_boundary_p = end;
272 /* if the `invisible' property is set, we can skip to
273 the next property change */
274 prop = Fget_char_property (position, Qinvisible,
275 (!NILP (window)
276 && EQ (XWINDOW (window)->buffer, buffer))
277 ? window : buffer);
278 inv_p = TEXT_PROP_MEANS_INVISIBLE (prop);
279 /* When counting columns (window == nil), don't skip over ellipsis text. */
280 if (NILP (window) ? inv_p == 1 : inv_p)
281 return *next_boundary_p;
282 return pos;
285 /* If a composition starts at POS/POS_BYTE and it doesn't stride over
286 POINT, set *LEN / *LEN_BYTE to the character and byte lengths, *WIDTH
287 to the width, and return 1. Otherwise, return 0. */
289 static int
290 check_composition (pos, pos_byte, point, len, len_byte, width)
291 int pos, pos_byte, point;
292 int *len, *len_byte, *width;
294 Lisp_Object prop;
295 EMACS_INT start, end;
296 int id;
298 if (! find_composition (pos, -1, &start, &end, &prop, Qnil)
299 || pos != start || point < end
300 || !COMPOSITION_VALID_P (start, end, prop))
301 return 0;
302 if ((id = get_composition_id (pos, pos_byte, end - pos, prop, Qnil)) < 0)
303 return 0;
305 *len = COMPOSITION_LENGTH (prop);
306 *len_byte = CHAR_TO_BYTE (end) - pos_byte;
307 *width = composition_table[id]->width;
308 return 1;
311 /* Set variables WIDTH and BYTES for a multibyte sequence starting at P.
313 DP is a display table or NULL.
315 This macro is used in current_column_1, Fmove_to_column, and
316 compute_motion. */
318 #define MULTIBYTE_BYTES_WIDTH(p, dp) \
319 do { \
320 int c; \
322 wide_column = 0; \
323 c = STRING_CHAR_AND_LENGTH (p, MAX_MULTIBYTE_LENGTH, bytes); \
324 if (BYTES_BY_CHAR_HEAD (*p) != bytes) \
325 width = bytes * 4; \
326 else \
328 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c))) \
329 width = XVECTOR (DISP_CHAR_VECTOR (dp, c))->size; \
330 else \
331 width = CHAR_WIDTH (c); \
332 if (width > 1) \
333 wide_column = width; \
335 } while (0)
338 DEFUN ("current-column", Fcurrent_column, Scurrent_column, 0, 0, 0,
339 doc: /* Return the horizontal position of point. Beginning of line is column 0.
340 This is calculated by adding together the widths of all the displayed
341 representations of the character between the start of the previous line
342 and point (eg. control characters will have a width of 2 or 4, tabs
343 will have a variable width).
344 Ignores finite width of frame, which means that this function may return
345 values greater than (frame-width).
346 Whether the line is visible (if `selective-display' is t) has no effect;
347 however, ^M is treated as end of line when `selective-display' is t.
348 Text that has an invisible property is considered as having width 0, unless
349 `buffer-invisibility-spec' specifies that it is replaced by an ellipsis. */)
352 Lisp_Object temp;
353 XSETFASTINT (temp, (int) current_column ()); /* iftc */
354 return temp;
357 /* Cancel any recorded value of the horizontal position. */
359 void
360 invalidate_current_column ()
362 last_known_column_point = 0;
365 double
366 current_column ()
368 register int col;
369 register unsigned char *ptr, *stop;
370 register int tab_seen;
371 int post_tab;
372 register int c;
373 register int tab_width = XINT (current_buffer->tab_width);
374 int ctl_arrow = !NILP (current_buffer->ctl_arrow);
375 register struct Lisp_Char_Table *dp = buffer_display_table ();
377 if (PT == last_known_column_point
378 && MODIFF == last_known_column_modified)
379 return last_known_column;
381 /* If the buffer has overlays, text properties,
382 or multibyte characters, use a more general algorithm. */
383 if (BUF_INTERVALS (current_buffer)
384 || current_buffer->overlays_before
385 || current_buffer->overlays_after
386 || Z != Z_BYTE)
387 return current_column_1 ();
389 /* Scan backwards from point to the previous newline,
390 counting width. Tab characters are the only complicated case. */
392 /* Make a pointer for decrementing through the chars before point. */
393 ptr = BYTE_POS_ADDR (PT_BYTE - 1) + 1;
394 /* Make a pointer to where consecutive chars leave off,
395 going backwards from point. */
396 if (PT == BEGV)
397 stop = ptr;
398 else if (PT <= GPT || BEGV > GPT)
399 stop = BEGV_ADDR;
400 else
401 stop = GAP_END_ADDR;
403 if (tab_width <= 0 || tab_width > 1000)
404 tab_width = 8;
406 col = 0, tab_seen = 0, post_tab = 0;
408 while (1)
410 EMACS_INT i, n;
411 Lisp_Object charvec;
413 if (ptr == stop)
415 /* We stopped either for the beginning of the buffer
416 or for the gap. */
417 if (ptr == BEGV_ADDR)
418 break;
420 /* It was the gap. Jump back over it. */
421 stop = BEGV_ADDR;
422 ptr = GPT_ADDR;
424 /* Check whether that brings us to beginning of buffer. */
425 if (BEGV >= GPT)
426 break;
429 c = *--ptr;
431 if (dp && VECTORP (DISP_CHAR_VECTOR (dp, c)))
433 charvec = DISP_CHAR_VECTOR (dp, c);
434 n = ASIZE (charvec);
436 else
438 charvec = Qnil;
439 n = 1;
442 for (i = n - 1; i >= 0; --i)
444 if (VECTORP (charvec))
446 /* This should be handled the same as
447 next_element_from_display_vector does it. */
448 Lisp_Object entry = AREF (charvec, i);
450 if (INTEGERP (entry)
451 && GLYPH_CHAR_VALID_P (XFASTINT (entry)))
452 c = FAST_GLYPH_CHAR (XFASTINT (entry));
453 else
454 c = ' ';
457 if (c >= 040 && c < 0177)
458 col++;
459 else if (c == '\n'
460 || (c == '\r'
461 && EQ (current_buffer->selective_display, Qt)))
463 ptr++;
464 goto start_of_line_found;
466 else if (c == '\t')
468 if (tab_seen)
469 col = ((col + tab_width) / tab_width) * tab_width;
471 post_tab += col;
472 col = 0;
473 tab_seen = 1;
475 else if (VECTORP (charvec))
476 /* With a display table entry, C is displayed as is, and
477 not displayed as \NNN or as ^N. If C is a single-byte
478 character, it takes one column. If C is multi-byte in
479 an unibyte buffer, it's translated to unibyte, so it
480 also takes one column. */
481 ++col;
482 else
483 col += (ctl_arrow && c < 0200) ? 2 : 4;
487 start_of_line_found:
489 if (tab_seen)
491 col = ((col + tab_width) / tab_width) * tab_width;
492 col += post_tab;
495 if (ptr == BEGV_ADDR)
496 current_column_bol_cache = BEGV;
497 else
498 current_column_bol_cache = BYTE_TO_CHAR (PTR_BYTE_POS (ptr));
500 last_known_column = col;
501 last_known_column_point = PT;
502 last_known_column_modified = MODIFF;
504 return col;
507 /* Return the column number of position POS
508 by scanning forward from the beginning of the line.
509 This function handles characters that are invisible
510 due to text properties or overlays. */
512 static double
513 current_column_1 ()
515 register EMACS_INT tab_width = XINT (current_buffer->tab_width);
516 register int ctl_arrow = !NILP (current_buffer->ctl_arrow);
517 register struct Lisp_Char_Table *dp = buffer_display_table ();
518 int multibyte = !NILP (current_buffer->enable_multibyte_characters);
520 /* Start the scan at the beginning of this line with column number 0. */
521 register EMACS_INT col = 0;
522 EMACS_INT scan, scan_byte;
523 EMACS_INT next_boundary;
524 EMACS_INT opoint = PT, opoint_byte = PT_BYTE;
526 scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -1, 1);
527 current_column_bol_cache = PT;
528 scan = PT, scan_byte = PT_BYTE;
529 SET_PT_BOTH (opoint, opoint_byte);
530 next_boundary = scan;
532 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
534 /* Scan forward to the target position. */
535 while (scan < opoint)
537 int c;
539 /* Occasionally we may need to skip invisible text. */
540 while (scan == next_boundary)
542 int old_scan = scan;
543 /* This updates NEXT_BOUNDARY to the next place
544 where we might need to skip more invisible text. */
545 scan = skip_invisible (scan, &next_boundary, opoint, Qnil);
546 if (scan >= opoint)
547 goto endloop;
548 if (scan != old_scan)
549 scan_byte = CHAR_TO_BYTE (scan);
552 /* Check composition sequence. */
554 int len, len_byte, width;
556 if (check_composition (scan, scan_byte, opoint,
557 &len, &len_byte, &width))
559 scan += len;
560 scan_byte += len_byte;
561 if (scan <= opoint)
562 col += width;
563 continue;
567 c = FETCH_BYTE (scan_byte);
569 if (dp != 0
570 && ! (multibyte && BASE_LEADING_CODE_P (c))
571 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
573 Lisp_Object charvec;
574 EMACS_INT i, n;
576 /* This character is displayed using a vector of glyphs.
577 Update the column based on those glyphs. */
579 charvec = DISP_CHAR_VECTOR (dp, c);
580 n = ASIZE (charvec);
582 for (i = 0; i < n; i++)
584 /* This should be handled the same as
585 next_element_from_display_vector does it. */
586 Lisp_Object entry;
587 entry = AREF (charvec, i);
589 if (INTEGERP (entry)
590 && GLYPH_CHAR_VALID_P (XFASTINT (entry)))
591 c = FAST_GLYPH_CHAR (XFASTINT (entry));
592 else
593 c = ' ';
595 if (c == '\n')
596 goto endloop;
597 if (c == '\r' && EQ (current_buffer->selective_display, Qt))
598 goto endloop;
599 if (c == '\t')
601 col += tab_width;
602 col = col / tab_width * tab_width;
604 else
605 ++col;
608 else
610 /* The display table says nothing for this character.
611 Display it as itself. */
613 if (c == '\n')
614 goto endloop;
615 if (c == '\r' && EQ (current_buffer->selective_display, Qt))
616 goto endloop;
617 if (c == '\t')
619 col += tab_width;
620 col = col / tab_width * tab_width;
622 else if (multibyte && BASE_LEADING_CODE_P (c))
624 unsigned char *ptr;
625 int bytes, width, wide_column;
627 ptr = BYTE_POS_ADDR (scan_byte);
628 MULTIBYTE_BYTES_WIDTH (ptr, dp);
629 scan_byte += bytes;
630 /* Subtract one to compensate for the increment
631 that is going to happen below. */
632 scan_byte--;
633 col += width;
635 else if (ctl_arrow && (c < 040 || c == 0177))
636 col += 2;
637 else if (c < 040 || c >= 0177)
638 col += 4;
639 else
640 col++;
642 scan++;
643 scan_byte++;
646 endloop:
648 last_known_column = col;
649 last_known_column_point = PT;
650 last_known_column_modified = MODIFF;
652 return col;
656 #if 0 /* Not used. */
658 /* Return the width in columns of the part of STRING from BEG to END.
659 If BEG is nil, that stands for the beginning of STRING.
660 If END is nil, that stands for the end of STRING. */
662 static double
663 string_display_width (string, beg, end)
664 Lisp_Object string, beg, end;
666 register int col;
667 register unsigned char *ptr, *stop;
668 register int tab_seen;
669 int post_tab;
670 register int c;
671 register int tab_width = XINT (current_buffer->tab_width);
672 int ctl_arrow = !NILP (current_buffer->ctl_arrow);
673 register struct Lisp_Char_Table *dp = buffer_display_table ();
674 int b, e;
676 if (NILP (end))
677 e = SCHARS (string);
678 else
680 CHECK_NUMBER (end);
681 e = XINT (end);
684 if (NILP (beg))
685 b = 0;
686 else
688 CHECK_NUMBER (beg);
689 b = XINT (beg);
692 /* Make a pointer for decrementing through the chars before point. */
693 ptr = SDATA (string) + e;
694 /* Make a pointer to where consecutive chars leave off,
695 going backwards from point. */
696 stop = SDATA (string) + b;
698 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
700 col = 0, tab_seen = 0, post_tab = 0;
702 while (1)
704 if (ptr == stop)
705 break;
707 c = *--ptr;
708 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
709 col += XVECTOR (DISP_CHAR_VECTOR (dp, c))->size;
710 else if (c >= 040 && c < 0177)
711 col++;
712 else if (c == '\n')
713 break;
714 else if (c == '\t')
716 if (tab_seen)
717 col = ((col + tab_width) / tab_width) * tab_width;
719 post_tab += col;
720 col = 0;
721 tab_seen = 1;
723 else
724 col += (ctl_arrow && c < 0200) ? 2 : 4;
727 if (tab_seen)
729 col = ((col + tab_width) / tab_width) * tab_width;
730 col += post_tab;
733 return col;
736 #endif /* 0 */
739 DEFUN ("indent-to", Findent_to, Sindent_to, 1, 2, "NIndent to column: ",
740 doc: /* Indent from point with tabs and spaces until COLUMN is reached.
741 Optional second argument MINIMUM says always do at least MINIMUM spaces
742 even if that goes past COLUMN; by default, MINIMUM is zero.
744 The return value is COLUMN. */)
745 (column, minimum)
746 Lisp_Object column, minimum;
748 int mincol;
749 register int fromcol;
750 register int tab_width = XINT (current_buffer->tab_width);
752 CHECK_NUMBER (column);
753 if (NILP (minimum))
754 XSETFASTINT (minimum, 0);
755 CHECK_NUMBER (minimum);
757 fromcol = current_column ();
758 mincol = fromcol + XINT (minimum);
759 if (mincol < XINT (column)) mincol = XINT (column);
761 if (fromcol == mincol)
762 return make_number (mincol);
764 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
766 if (indent_tabs_mode)
768 Lisp_Object n;
769 XSETFASTINT (n, mincol / tab_width - fromcol / tab_width);
770 if (XFASTINT (n) != 0)
772 Finsert_char (make_number ('\t'), n, Qt);
774 fromcol = (mincol / tab_width) * tab_width;
778 XSETFASTINT (column, mincol - fromcol);
779 Finsert_char (make_number (' '), column, Qt);
781 last_known_column = mincol;
782 last_known_column_point = PT;
783 last_known_column_modified = MODIFF;
785 XSETINT (column, mincol);
786 return column;
790 static double position_indentation P_ ((int));
792 DEFUN ("current-indentation", Fcurrent_indentation, Scurrent_indentation,
793 0, 0, 0,
794 doc: /* Return the indentation of the current line.
795 This is the horizontal position of the character
796 following any initial whitespace. */)
799 Lisp_Object val;
800 int opoint = PT, opoint_byte = PT_BYTE;
802 scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -1, 1);
804 XSETFASTINT (val, (int) position_indentation (PT_BYTE)); /* iftc */
805 SET_PT_BOTH (opoint, opoint_byte);
806 return val;
809 static double
810 position_indentation (pos_byte)
811 register int pos_byte;
813 register EMACS_INT column = 0;
814 register EMACS_INT tab_width = XINT (current_buffer->tab_width);
815 register unsigned char *p;
816 register unsigned char *stop;
817 unsigned char *start;
818 EMACS_INT next_boundary_byte = pos_byte;
819 EMACS_INT ceiling = next_boundary_byte;
821 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
823 p = BYTE_POS_ADDR (pos_byte);
824 /* STOP records the value of P at which we will need
825 to think about the gap, or about invisible text,
826 or about the end of the buffer. */
827 stop = p;
828 /* START records the starting value of P. */
829 start = p;
830 while (1)
832 while (p == stop)
834 EMACS_INT stop_pos_byte;
836 /* If we have updated P, set POS_BYTE to match.
837 The first time we enter the loop, POS_BYTE is already right. */
838 if (p != start)
839 pos_byte = PTR_BYTE_POS (p);
840 /* Consider the various reasons STOP might have been set here. */
841 if (pos_byte == ZV_BYTE)
842 return column;
843 if (pos_byte == next_boundary_byte)
845 EMACS_INT next_boundary;
846 EMACS_INT pos = BYTE_TO_CHAR (pos_byte);
847 pos = skip_invisible (pos, &next_boundary, ZV, Qnil);
848 pos_byte = CHAR_TO_BYTE (pos);
849 next_boundary_byte = CHAR_TO_BYTE (next_boundary);
851 if (pos_byte >= ceiling)
852 ceiling = BUFFER_CEILING_OF (pos_byte) + 1;
853 /* Compute the next place we need to stop and think,
854 and set STOP accordingly. */
855 stop_pos_byte = min (ceiling, next_boundary_byte);
856 /* The -1 and +1 arrange to point at the first byte of gap
857 (if STOP_POS_BYTE is the position of the gap)
858 rather than at the data after the gap. */
860 stop = BYTE_POS_ADDR (stop_pos_byte - 1) + 1;
861 p = BYTE_POS_ADDR (pos_byte);
863 switch (*p++)
865 case 0240:
866 if (! NILP (current_buffer->enable_multibyte_characters))
867 return column;
868 case ' ':
869 column++;
870 break;
871 case '\t':
872 column += tab_width - column % tab_width;
873 break;
874 default:
875 if (ASCII_BYTE_P (p[-1])
876 || NILP (current_buffer->enable_multibyte_characters))
877 return column;
879 int c;
880 pos_byte = PTR_BYTE_POS (p - 1);
881 c = FETCH_MULTIBYTE_CHAR (pos_byte);
882 if (CHAR_HAS_CATEGORY (c, ' '))
884 column++;
885 INC_POS (pos_byte);
886 p = BYTE_POS_ADDR (pos_byte);
888 else
889 return column;
895 /* Test whether the line beginning at POS is indented beyond COLUMN.
896 Blank lines are treated as if they had the same indentation as the
897 preceding line. */
900 indented_beyond_p (pos, pos_byte, column)
901 int pos, pos_byte;
902 double column;
904 double val;
905 int opoint = PT, opoint_byte = PT_BYTE;
907 SET_PT_BOTH (pos, pos_byte);
908 while (PT > BEGV && FETCH_BYTE (PT_BYTE) == '\n')
909 scan_newline (PT - 1, PT_BYTE - 1, BEGV, BEGV_BYTE, -1, 0);
911 val = position_indentation (PT_BYTE);
912 SET_PT_BOTH (opoint, opoint_byte);
913 return val >= column; /* hmm, float comparison */
916 DEFUN ("move-to-column", Fmove_to_column, Smove_to_column, 1, 2, "p",
917 doc: /* Move point to column COLUMN in the current line.
918 Interactively, COLUMN is the value of prefix numeric argument.
919 The column of a character is calculated by adding together the widths
920 as displayed of the previous characters in the line.
921 This function ignores line-continuation;
922 there is no upper limit on the column number a character can have
923 and horizontal scrolling has no effect.
925 If specified column is within a character, point goes after that character.
926 If it's past end of line, point goes to end of line.
928 Optional second argument FORCE non-nil means if COLUMN is in the
929 middle of a tab character, change it to spaces.
930 In addition, if FORCE is t, and the line is too short to reach
931 COLUMN, add spaces/tabs to get there.
933 The return value is the current column. */)
934 (column, force)
935 Lisp_Object column, force;
937 register EMACS_INT pos;
938 register EMACS_INT col = current_column ();
939 register EMACS_INT goal;
940 register EMACS_INT end;
941 register int tab_width = XINT (current_buffer->tab_width);
942 register int ctl_arrow = !NILP (current_buffer->ctl_arrow);
943 register struct Lisp_Char_Table *dp = buffer_display_table ();
944 register int multibyte = !NILP (current_buffer->enable_multibyte_characters);
946 Lisp_Object val;
947 EMACS_INT prev_col = 0;
948 int c = 0;
949 EMACS_INT next_boundary, pos_byte;
951 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
952 CHECK_NATNUM (column);
953 goal = XINT (column);
955 pos = PT;
956 pos_byte = PT_BYTE;
957 end = ZV;
959 /* If we're starting past the desired column,
960 back up to beginning of line and scan from there. */
961 if (col > goal)
963 end = pos;
964 pos = current_column_bol_cache;
965 pos_byte = CHAR_TO_BYTE (pos);
966 col = 0;
969 next_boundary = pos;
971 while (pos < end)
973 while (pos == next_boundary)
975 EMACS_INT prev = pos;
976 pos = skip_invisible (pos, &next_boundary, end, Qnil);
977 if (pos != prev)
978 pos_byte = CHAR_TO_BYTE (pos);
979 if (pos >= end)
980 goto endloop;
983 /* Test reaching the goal column. We do this after skipping
984 invisible characters, so that we put point before the
985 character on which the cursor will appear. */
986 if (col >= goal)
987 break;
989 /* Check composition sequence. */
991 int len, len_byte, width;
993 if (check_composition (pos, pos_byte, Z, &len, &len_byte, &width))
995 pos += len;
996 pos_byte += len_byte;
997 col += width;
998 continue;
1002 c = FETCH_BYTE (pos_byte);
1004 /* See if there is a display table and it relates
1005 to this character. */
1007 if (dp != 0
1008 && ! (multibyte && BASE_LEADING_CODE_P (c))
1009 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
1011 Lisp_Object charvec;
1012 EMACS_INT i, n;
1014 /* This character is displayed using a vector of glyphs.
1015 Update the position based on those glyphs. */
1017 charvec = DISP_CHAR_VECTOR (dp, c);
1018 n = ASIZE (charvec);
1020 for (i = 0; i < n; i++)
1022 /* This should be handled the same as
1023 next_element_from_display_vector does it. */
1025 Lisp_Object entry;
1026 entry = AREF (charvec, i);
1028 if (INTEGERP (entry)
1029 && GLYPH_CHAR_VALID_P (XFASTINT (entry)))
1030 c = FAST_GLYPH_CHAR (XFASTINT (entry));
1031 else
1032 c = ' ';
1034 if (c == '\n')
1035 goto endloop;
1036 if (c == '\r' && EQ (current_buffer->selective_display, Qt))
1037 goto endloop;
1038 if (c == '\t')
1040 prev_col = col;
1041 col += tab_width;
1042 col = col / tab_width * tab_width;
1044 else
1045 ++col;
1048 else
1050 /* The display table doesn't affect this character;
1051 it displays as itself. */
1053 if (c == '\n')
1054 goto endloop;
1055 if (c == '\r' && EQ (current_buffer->selective_display, Qt))
1056 goto endloop;
1057 if (c == '\t')
1059 prev_col = col;
1060 col += tab_width;
1061 col = col / tab_width * tab_width;
1063 else if (ctl_arrow && (c < 040 || c == 0177))
1064 col += 2;
1065 else if (c < 040 || c == 0177)
1066 col += 4;
1067 else if (c < 0177)
1068 col++;
1069 else if (multibyte && BASE_LEADING_CODE_P (c))
1071 /* Start of multi-byte form. */
1072 unsigned char *ptr;
1073 int bytes, width, wide_column;
1075 ptr = BYTE_POS_ADDR (pos_byte);
1076 MULTIBYTE_BYTES_WIDTH (ptr, dp);
1077 pos_byte += bytes - 1;
1078 col += width;
1080 else
1081 col += 4;
1084 pos++;
1085 pos_byte++;
1087 endloop:
1089 SET_PT_BOTH (pos, pos_byte);
1091 /* If a tab char made us overshoot, change it to spaces
1092 and scan through it again. */
1093 if (!NILP (force) && col > goal && c == '\t' && prev_col < goal)
1095 EMACS_INT goal_pt, goal_pt_byte;
1097 /* Insert spaces in front of the tab to reach GOAL. Do this
1098 first so that a marker at the end of the tab gets
1099 adjusted. */
1100 SET_PT_BOTH (PT - 1, PT_BYTE - 1);
1101 Finsert_char (make_number (' '), make_number (goal - prev_col), Qt);
1103 /* Now delete the tab, and indent to COL. */
1104 del_range (PT, PT + 1);
1105 goal_pt = PT;
1106 goal_pt_byte = PT_BYTE;
1107 Findent_to (make_number (col), Qnil);
1108 SET_PT_BOTH (goal_pt, goal_pt_byte);
1110 /* Set the last_known... vars consistently. */
1111 col = goal;
1114 /* If line ends prematurely, add space to the end. */
1115 if (col < goal && EQ (force, Qt))
1116 Findent_to (make_number (col = goal), Qnil);
1118 last_known_column = col;
1119 last_known_column_point = PT;
1120 last_known_column_modified = MODIFF;
1122 XSETFASTINT (val, col);
1123 return val;
1126 /* compute_motion: compute buffer posn given screen posn and vice versa */
1128 struct position val_compute_motion;
1130 /* Scan the current buffer forward from offset FROM, pretending that
1131 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
1132 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
1133 and return the ending buffer position and screen location. If we
1134 can't hit the requested column exactly (because of a tab or other
1135 multi-column character), overshoot.
1137 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
1138 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
1139 earlier call to compute_motion. The other common case is that FROMHPOS
1140 is zero and FROM is a position that "belongs" at column zero, but might
1141 be shifted by overlay strings; in this case DID_MOTION should be 0.
1143 WIDTH is the number of columns available to display text;
1144 compute_motion uses this to handle continuation lines and such.
1145 If WIDTH is -1, use width of window's text area adjusted for
1146 continuation glyph when needed.
1148 HSCROLL is the number of columns not being displayed at the left
1149 margin; this is usually taken from a window's hscroll member.
1150 TAB_OFFSET is the number of columns of the first tab that aren't
1151 being displayed, perhaps because of a continuation line or
1152 something.
1154 compute_motion returns a pointer to a struct position. The bufpos
1155 member gives the buffer position at the end of the scan, and hpos
1156 and vpos give its cartesian location. prevhpos is the column at
1157 which the character before bufpos started, and contin is non-zero
1158 if we reached the current line by continuing the previous.
1160 Note that FROMHPOS and TOHPOS should be expressed in real screen
1161 columns, taking HSCROLL and the truncation glyph at the left margin
1162 into account. That is, beginning-of-line moves you to the hpos
1163 -HSCROLL + (HSCROLL > 0).
1165 For example, to find the buffer position of column COL of line LINE
1166 of a certain window, pass the window's starting location as FROM
1167 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
1168 Pass the buffer's ZV as TO, to limit the scan to the end of the
1169 visible section of the buffer, and pass LINE and COL as TOVPOS and
1170 TOHPOS.
1172 When displaying in window w, a typical formula for WIDTH is:
1174 window_width - 1
1175 - (has_vertical_scroll_bars
1176 ? WINDOW_CONFIG_SCROLL_BAR_COLS (window)
1177 : (window_width + window_left != frame_cols))
1179 where
1180 window_width is XFASTINT (w->total_cols),
1181 window_left is XFASTINT (w->left_col),
1182 has_vertical_scroll_bars is
1183 WINDOW_HAS_VERTICAL_SCROLL_BAR (window)
1184 and frame_cols = FRAME_COLS (XFRAME (window->frame))
1186 Or you can let window_box_text_cols do this all for you, and write:
1187 window_box_text_cols (w) - 1
1189 The `-1' accounts for the continuation-line backslashes; the rest
1190 accounts for window borders if the window is split horizontally, and
1191 the scroll bars if they are turned on. */
1193 struct position *
1194 compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width, hscroll, tab_offset, win)
1195 EMACS_INT from, fromvpos, fromhpos, to, tovpos, tohpos;
1196 int did_motion;
1197 EMACS_INT width;
1198 EMACS_INT hscroll, tab_offset;
1199 struct window *win;
1201 register EMACS_INT hpos = fromhpos;
1202 register EMACS_INT vpos = fromvpos;
1204 register EMACS_INT pos;
1205 EMACS_INT pos_byte;
1206 register int c = 0;
1207 register EMACS_INT tab_width = XFASTINT (current_buffer->tab_width);
1208 register int ctl_arrow = !NILP (current_buffer->ctl_arrow);
1209 register struct Lisp_Char_Table *dp = window_display_table (win);
1210 int selective
1211 = (INTEGERP (current_buffer->selective_display)
1212 ? XINT (current_buffer->selective_display)
1213 : !NILP (current_buffer->selective_display) ? -1 : 0);
1214 int selective_rlen
1215 = (selective && dp && VECTORP (DISP_INVIS_VECTOR (dp))
1216 ? XVECTOR (DISP_INVIS_VECTOR (dp))->size : 0);
1217 /* The next location where the `invisible' property changes, or an
1218 overlay starts or ends. */
1219 EMACS_INT next_boundary = from;
1221 /* For computing runs of characters with similar widths.
1222 Invariant: width_run_width is zero, or all the characters
1223 from width_run_start to width_run_end have a fixed width of
1224 width_run_width. */
1225 EMACS_INT width_run_start = from;
1226 EMACS_INT width_run_end = from;
1227 EMACS_INT width_run_width = 0;
1228 Lisp_Object *width_table;
1229 Lisp_Object buffer;
1231 /* The next buffer pos where we should consult the width run cache. */
1232 EMACS_INT next_width_run = from;
1233 Lisp_Object window;
1235 int multibyte = !NILP (current_buffer->enable_multibyte_characters);
1236 /* If previous char scanned was a wide character,
1237 this is the column where it ended. Otherwise, this is 0. */
1238 EMACS_INT wide_column_end_hpos = 0;
1239 EMACS_INT prev_pos; /* Previous buffer position. */
1240 EMACS_INT prev_pos_byte; /* Previous buffer position. */
1241 EMACS_INT prev_hpos = 0;
1242 EMACS_INT prev_vpos = 0;
1243 EMACS_INT contin_hpos; /* HPOS of last column of continued line. */
1244 EMACS_INT prev_tab_offset; /* Previous tab offset. */
1245 EMACS_INT continuation_glyph_width;
1247 XSETBUFFER (buffer, current_buffer);
1248 XSETWINDOW (window, win);
1250 width_run_cache_on_off ();
1251 if (dp == buffer_display_table ())
1252 width_table = (VECTORP (current_buffer->width_table)
1253 ? XVECTOR (current_buffer->width_table)->contents
1254 : 0);
1255 else
1256 /* If the window has its own display table, we can't use the width
1257 run cache, because that's based on the buffer's display table. */
1258 width_table = 0;
1260 if (tab_width <= 0 || tab_width > 1000)
1261 tab_width = 8;
1263 /* Negative width means use all available text columns. */
1264 if (width < 0)
1266 width = window_box_text_cols (win);
1267 /* We must make room for continuation marks if we don't have fringes. */
1268 #ifdef HAVE_WINDOW_SYSTEM
1269 if (!FRAME_WINDOW_P (XFRAME (win->frame)))
1270 #endif
1271 width -= 1;
1274 continuation_glyph_width = 1;
1275 #ifdef HAVE_WINDOW_SYSTEM
1276 if (FRAME_WINDOW_P (XFRAME (win->frame)))
1277 continuation_glyph_width = 0; /* In the fringe. */
1278 #endif
1280 immediate_quit = 1;
1281 QUIT;
1283 pos = prev_pos = from;
1284 pos_byte = prev_pos_byte = CHAR_TO_BYTE (from);
1285 contin_hpos = 0;
1286 prev_tab_offset = tab_offset;
1287 while (1)
1289 while (pos == next_boundary)
1291 EMACS_INT pos_here = pos;
1292 EMACS_INT newpos;
1294 /* Don't skip invisible if we are already at the margin. */
1295 if (vpos > tovpos || (vpos == tovpos && hpos >= tohpos))
1297 if (contin_hpos && prev_hpos == 0
1298 && hpos > tohpos
1299 && (contin_hpos == width || wide_column_end_hpos > width))
1300 { /* Line breaks because we can't put the character at the
1301 previous line any more. It is not the multi-column
1302 character continued in middle. Go back to previous
1303 buffer position, screen position, and set tab offset
1304 to previous value. It's the beginning of the
1305 line. */
1306 pos = prev_pos;
1307 pos_byte = prev_pos_byte;
1308 hpos = prev_hpos;
1309 vpos = prev_vpos;
1310 tab_offset = prev_tab_offset;
1312 break;
1315 /* If the caller says that the screen position came from an earlier
1316 call to compute_motion, then we've already accounted for the
1317 overlay strings at point. This is only true the first time
1318 through, so clear the flag after testing it. */
1319 if (!did_motion)
1320 /* We need to skip past the overlay strings. Currently those
1321 strings must not contain TAB;
1322 if we want to relax that restriction, something will have
1323 to be changed here. */
1325 unsigned char *ovstr;
1326 int ovlen = overlay_strings (pos, win, &ovstr);
1327 hpos += ((multibyte && ovlen > 0)
1328 ? strwidth (ovstr, ovlen) : ovlen);
1330 did_motion = 0;
1332 if (pos >= to)
1333 break;
1335 /* Advance POS past invisible characters
1336 (but not necessarily all that there are here),
1337 and store in next_boundary the next position where
1338 we need to call skip_invisible. */
1339 newpos = skip_invisible (pos, &next_boundary, to, window);
1341 if (newpos >= to)
1343 pos = min (to, newpos);
1344 pos_byte = CHAR_TO_BYTE (pos);
1345 goto after_loop;
1348 if (newpos != pos_here)
1350 pos = newpos;
1351 pos_byte = CHAR_TO_BYTE (pos);
1355 /* Handle right margin. */
1356 /* Note on a wide-column character.
1358 Characters are classified into the following three categories
1359 according to the width (columns occupied on screen).
1361 (1) single-column character: ex. `a'
1362 (2) multi-column character: ex. `^A', TAB, `\033'
1363 (3) wide-column character: ex. Japanese character, Chinese character
1364 (In the following example, `W_' stands for them.)
1366 Multi-column characters can be divided around the right margin,
1367 but wide-column characters cannot.
1369 NOTE:
1371 (*) The cursor is placed on the next character after the point.
1373 ----------
1374 abcdefghi\
1375 j ^---- next after the point
1376 ^--- next char. after the point.
1377 ----------
1378 In case of sigle-column character
1380 ----------
1381 abcdefgh\\
1382 033 ^---- next after the point, next char. after the point.
1383 ----------
1384 In case of multi-column character
1386 ----------
1387 abcdefgh\\
1388 W_ ^---- next after the point
1389 ^---- next char. after the point.
1390 ----------
1391 In case of wide-column character
1393 The problem here is continuation at a wide-column character.
1394 In this case, the line may shorter less than WIDTH.
1395 And we find the continuation AFTER it occurs.
1399 if (hpos > width)
1401 if (hscroll
1402 || (truncate_partial_width_windows
1403 && ((width + continuation_glyph_width)
1404 < FRAME_COLS (XFRAME (WINDOW_FRAME (win)))))
1405 || !NILP (current_buffer->truncate_lines))
1407 /* Truncating: skip to newline, unless we are already past
1408 TO (we need to go back below). */
1409 if (pos <= to)
1411 pos = find_before_next_newline (pos, to, 1);
1412 pos_byte = CHAR_TO_BYTE (pos);
1413 hpos = width;
1414 /* If we just skipped next_boundary,
1415 loop around in the main while
1416 and handle it. */
1417 if (pos >= next_boundary)
1418 next_boundary = pos + 1;
1419 prev_hpos = width;
1420 prev_vpos = vpos;
1421 prev_tab_offset = tab_offset;
1424 else
1426 /* Continuing. */
1427 /* Remember the previous value. */
1428 prev_tab_offset = tab_offset;
1430 if (wide_column_end_hpos > width)
1432 hpos -= prev_hpos;
1433 tab_offset += prev_hpos;
1435 else
1437 tab_offset += width;
1438 hpos -= width;
1440 vpos++;
1441 contin_hpos = prev_hpos;
1442 prev_hpos = 0;
1443 prev_vpos = vpos;
1447 /* Stop if past the target buffer position or screen position. */
1448 if (pos > to)
1450 /* Go back to the previous position. */
1451 pos = prev_pos;
1452 pos_byte = prev_pos_byte;
1453 hpos = prev_hpos;
1454 vpos = prev_vpos;
1455 tab_offset = prev_tab_offset;
1457 /* NOTE on contin_hpos, hpos, and prev_hpos.
1459 ----------
1460 abcdefgh\\
1461 W_ ^---- contin_hpos
1462 | ^----- hpos
1463 \---- prev_hpos
1464 ----------
1467 if (contin_hpos && prev_hpos == 0
1468 && contin_hpos < width && !wide_column_end_hpos)
1470 /* Line breaking occurs in the middle of multi-column
1471 character. Go back to previous line. */
1472 hpos = contin_hpos;
1473 vpos = vpos - 1;
1475 break;
1478 if (vpos > tovpos || (vpos == tovpos && hpos >= tohpos))
1480 if (contin_hpos && prev_hpos == 0
1481 && hpos > tohpos
1482 && (contin_hpos == width || wide_column_end_hpos > width))
1483 { /* Line breaks because we can't put the character at the
1484 previous line any more. It is not the multi-column
1485 character continued in middle. Go back to previous
1486 buffer position, screen position, and set tab offset
1487 to previous value. It's the beginning of the
1488 line. */
1489 pos = prev_pos;
1490 pos_byte = prev_pos_byte;
1491 hpos = prev_hpos;
1492 vpos = prev_vpos;
1493 tab_offset = prev_tab_offset;
1495 break;
1497 if (pos == ZV) /* We cannot go beyond ZV. Stop here. */
1498 break;
1500 prev_hpos = hpos;
1501 prev_vpos = vpos;
1502 prev_pos = pos;
1503 prev_pos_byte = pos_byte;
1504 wide_column_end_hpos = 0;
1506 /* Consult the width run cache to see if we can avoid inspecting
1507 the text character-by-character. */
1508 if (current_buffer->width_run_cache && pos >= next_width_run)
1510 int run_end;
1511 int common_width
1512 = region_cache_forward (current_buffer,
1513 current_buffer->width_run_cache,
1514 pos, &run_end);
1516 /* A width of zero means the character's width varies (like
1517 a tab), is meaningless (like a newline), or we just don't
1518 want to skip over it for some other reason. */
1519 if (common_width != 0)
1521 int run_end_hpos;
1523 /* Don't go past the final buffer posn the user
1524 requested. */
1525 if (run_end > to)
1526 run_end = to;
1528 run_end_hpos = hpos + (run_end - pos) * common_width;
1530 /* Don't go past the final horizontal position the user
1531 requested. */
1532 if (vpos == tovpos && run_end_hpos > tohpos)
1534 run_end = pos + (tohpos - hpos) / common_width;
1535 run_end_hpos = hpos + (run_end - pos) * common_width;
1538 /* Don't go past the margin. */
1539 if (run_end_hpos >= width)
1541 run_end = pos + (width - hpos) / common_width;
1542 run_end_hpos = hpos + (run_end - pos) * common_width;
1545 hpos = run_end_hpos;
1546 if (run_end > pos)
1547 prev_hpos = hpos - common_width;
1548 if (pos != run_end)
1550 pos = run_end;
1551 pos_byte = CHAR_TO_BYTE (pos);
1555 next_width_run = run_end + 1;
1558 /* We have to scan the text character-by-character. */
1559 else
1561 EMACS_INT i, n;
1562 Lisp_Object charvec;
1564 c = FETCH_BYTE (pos_byte);
1566 /* Check composition sequence. */
1568 int len, len_byte, width;
1570 if (check_composition (pos, pos_byte, to, &len, &len_byte, &width))
1572 pos += len;
1573 pos_byte += len_byte;
1574 hpos += width;
1575 continue;
1579 pos++, pos_byte++;
1581 /* Perhaps add some info to the width_run_cache. */
1582 if (current_buffer->width_run_cache)
1584 /* Is this character part of the current run? If so, extend
1585 the run. */
1586 if (pos - 1 == width_run_end
1587 && XFASTINT (width_table[c]) == width_run_width)
1588 width_run_end = pos;
1590 /* The previous run is over, since this is a character at a
1591 different position, or a different width. */
1592 else
1594 /* Have we accumulated a run to put in the cache?
1595 (Currently, we only cache runs of width == 1). */
1596 if (width_run_start < width_run_end
1597 && width_run_width == 1)
1598 know_region_cache (current_buffer,
1599 current_buffer->width_run_cache,
1600 width_run_start, width_run_end);
1602 /* Start recording a new width run. */
1603 width_run_width = XFASTINT (width_table[c]);
1604 width_run_start = pos - 1;
1605 width_run_end = pos;
1609 if (dp != 0
1610 && ! (multibyte && BASE_LEADING_CODE_P (c))
1611 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
1613 charvec = DISP_CHAR_VECTOR (dp, c);
1614 n = ASIZE (charvec);
1616 else
1618 charvec = Qnil;
1619 n = 1;
1622 for (i = n - 1; i >= 0; --i)
1624 if (VECTORP (charvec))
1626 /* This should be handled the same as
1627 next_element_from_display_vector does it. */
1628 Lisp_Object entry = AREF (charvec, i);
1630 if (INTEGERP (entry)
1631 && GLYPH_CHAR_VALID_P (XFASTINT (entry)))
1632 c = FAST_GLYPH_CHAR (XFASTINT (entry));
1633 else
1634 c = ' ';
1637 if (c >= 040 && c < 0177)
1638 hpos++;
1639 else if (c == '\t')
1641 int tem = ((hpos + tab_offset + hscroll - (hscroll > 0))
1642 % tab_width);
1643 if (tem < 0)
1644 tem += tab_width;
1645 hpos += tab_width - tem;
1647 else if (c == '\n')
1649 if (selective > 0
1650 && indented_beyond_p (pos, pos_byte,
1651 (double) selective)) /* iftc */
1653 /* If (pos == to), we don't have to take care of
1654 selective display. */
1655 if (pos < to)
1657 /* Skip any number of invisible lines all at once */
1660 pos = find_before_next_newline (pos, to, 1);
1661 if (pos < to)
1662 pos++;
1663 pos_byte = CHAR_TO_BYTE (pos);
1665 while (pos < to
1666 && indented_beyond_p (pos, pos_byte,
1667 (double) selective)); /* iftc */
1668 /* Allow for the " ..." that is displayed for them. */
1669 if (selective_rlen)
1671 hpos += selective_rlen;
1672 if (hpos >= width)
1673 hpos = width;
1675 DEC_BOTH (pos, pos_byte);
1676 /* We have skipped the invis text, but not the
1677 newline after. */
1680 else
1682 /* A visible line. */
1683 vpos++;
1684 hpos = 0;
1685 hpos -= hscroll;
1686 /* Count the truncation glyph on column 0 */
1687 if (hscroll > 0)
1688 hpos += continuation_glyph_width;
1689 tab_offset = 0;
1691 contin_hpos = 0;
1693 else if (c == CR && selective < 0)
1695 /* In selective display mode,
1696 everything from a ^M to the end of the line is invisible.
1697 Stop *before* the real newline. */
1698 if (pos < to)
1700 pos = find_before_next_newline (pos, to, 1);
1701 pos_byte = CHAR_TO_BYTE (pos);
1703 /* If we just skipped next_boundary,
1704 loop around in the main while
1705 and handle it. */
1706 if (pos > next_boundary)
1707 next_boundary = pos;
1708 /* Allow for the " ..." that is displayed for them. */
1709 if (selective_rlen)
1711 hpos += selective_rlen;
1712 if (hpos >= width)
1713 hpos = width;
1716 else if (multibyte && BASE_LEADING_CODE_P (c))
1718 /* Start of multi-byte form. */
1719 unsigned char *ptr;
1720 int bytes, width, wide_column;
1722 pos_byte--; /* rewind POS_BYTE */
1723 ptr = BYTE_POS_ADDR (pos_byte);
1724 MULTIBYTE_BYTES_WIDTH (ptr, dp);
1725 pos_byte += bytes;
1726 if (wide_column)
1727 wide_column_end_hpos = hpos + wide_column;
1728 hpos += width;
1730 else if (VECTORP (charvec))
1731 ++hpos;
1732 else
1733 hpos += (ctl_arrow && c < 0200) ? 2 : 4;
1738 after_loop:
1740 /* Remember any final width run in the cache. */
1741 if (current_buffer->width_run_cache
1742 && width_run_width == 1
1743 && width_run_start < width_run_end)
1744 know_region_cache (current_buffer, current_buffer->width_run_cache,
1745 width_run_start, width_run_end);
1747 val_compute_motion.bufpos = pos;
1748 val_compute_motion.bytepos = pos_byte;
1749 val_compute_motion.hpos = hpos;
1750 val_compute_motion.vpos = vpos;
1751 if (contin_hpos && prev_hpos == 0)
1752 val_compute_motion.prevhpos = contin_hpos;
1753 else
1754 val_compute_motion.prevhpos = prev_hpos;
1755 /* We alalways handle all of them here; none of them remain to do. */
1756 val_compute_motion.ovstring_chars_done = 0;
1758 /* Nonzero if have just continued a line */
1759 val_compute_motion.contin = (contin_hpos && prev_hpos == 0);
1761 immediate_quit = 0;
1762 return &val_compute_motion;
1766 DEFUN ("compute-motion", Fcompute_motion, Scompute_motion, 7, 7, 0,
1767 doc: /* Scan through the current buffer, calculating screen position.
1768 Scan the current buffer forward from offset FROM,
1769 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--
1770 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--
1771 and return the ending buffer position and screen location.
1773 If TOPOS is nil, the actual width and height of the window's
1774 text area are used.
1776 There are three additional arguments:
1778 WIDTH is the number of columns available to display text;
1779 this affects handling of continuation lines. A value of nil
1780 corresponds to the actual number of available text columns.
1782 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).
1783 HSCROLL is the number of columns not being displayed at the left
1784 margin; this is usually taken from a window's hscroll member.
1785 TAB-OFFSET is the number of columns of the first tab that aren't
1786 being displayed, perhaps because the line was continued within it.
1787 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.
1789 WINDOW is the window to operate on. It is used to choose the display table;
1790 if it is showing the current buffer, it is used also for
1791 deciding which overlay properties apply.
1792 Note that `compute-motion' always operates on the current buffer.
1794 The value is a list of five elements:
1795 (POS HPOS VPOS PREVHPOS CONTIN)
1796 POS is the buffer position where the scan stopped.
1797 VPOS is the vertical position where the scan stopped.
1798 HPOS is the horizontal position where the scan stopped.
1800 PREVHPOS is the horizontal position one character back from POS.
1801 CONTIN is t if a line was continued after (or within) the previous character.
1803 For example, to find the buffer position of column COL of line LINE
1804 of a certain window, pass the window's starting location as FROM
1805 and the window's upper-left coordinates as FROMPOS.
1806 Pass the buffer's (point-max) as TO, to limit the scan to the end of the
1807 visible section of the buffer, and pass LINE and COL as TOPOS. */)
1808 (from, frompos, to, topos, width, offsets, window)
1809 Lisp_Object from, frompos, to, topos;
1810 Lisp_Object width, offsets, window;
1812 struct window *w;
1813 Lisp_Object bufpos, hpos, vpos, prevhpos;
1814 struct position *pos;
1815 int hscroll, tab_offset;
1817 CHECK_NUMBER_COERCE_MARKER (from);
1818 CHECK_CONS (frompos);
1819 CHECK_NUMBER_CAR (frompos);
1820 CHECK_NUMBER_CDR (frompos);
1821 CHECK_NUMBER_COERCE_MARKER (to);
1822 if (!NILP (topos))
1824 CHECK_CONS (topos);
1825 CHECK_NUMBER_CAR (topos);
1826 CHECK_NUMBER_CDR (topos);
1828 if (!NILP (width))
1829 CHECK_NUMBER (width);
1831 if (!NILP (offsets))
1833 CHECK_CONS (offsets);
1834 CHECK_NUMBER_CAR (offsets);
1835 CHECK_NUMBER_CDR (offsets);
1836 hscroll = XINT (XCAR (offsets));
1837 tab_offset = XINT (XCDR (offsets));
1839 else
1840 hscroll = tab_offset = 0;
1842 if (NILP (window))
1843 window = Fselected_window ();
1844 else
1845 CHECK_LIVE_WINDOW (window);
1846 w = XWINDOW (window);
1848 if (XINT (from) < BEGV || XINT (from) > ZV)
1849 args_out_of_range_3 (from, make_number (BEGV), make_number (ZV));
1850 if (XINT (to) < BEGV || XINT (to) > ZV)
1851 args_out_of_range_3 (to, make_number (BEGV), make_number (ZV));
1853 pos = compute_motion (XINT (from), XINT (XCDR (frompos)),
1854 XINT (XCAR (frompos)), 0,
1855 XINT (to),
1856 (NILP (topos)
1857 ? window_internal_height (w)
1858 : XINT (XCDR (topos))),
1859 (NILP (topos)
1860 ? (window_box_text_cols (w)
1862 #ifdef HAVE_WINDOW_SYSTEM
1863 FRAME_WINDOW_P (XFRAME (w->frame)) ? 0 :
1864 #endif
1866 : XINT (XCAR (topos))),
1867 (NILP (width) ? -1 : XINT (width)),
1868 hscroll, tab_offset,
1869 XWINDOW (window));
1871 XSETFASTINT (bufpos, pos->bufpos);
1872 XSETINT (hpos, pos->hpos);
1873 XSETINT (vpos, pos->vpos);
1874 XSETINT (prevhpos, pos->prevhpos);
1876 return Fcons (bufpos,
1877 Fcons (hpos,
1878 Fcons (vpos,
1879 Fcons (prevhpos,
1880 Fcons (pos->contin ? Qt : Qnil, Qnil)))));
1884 /* Fvertical_motion and vmotion */
1886 struct position val_vmotion;
1888 struct position *
1889 vmotion (from, vtarget, w)
1890 register EMACS_INT from, vtarget;
1891 struct window *w;
1893 EMACS_INT hscroll = XINT (w->hscroll);
1894 struct position pos;
1895 /* vpos is cumulative vertical position, changed as from is changed */
1896 register int vpos = 0;
1897 EMACS_INT prevline;
1898 register EMACS_INT first;
1899 EMACS_INT from_byte;
1900 EMACS_INT lmargin = hscroll > 0 ? 1 - hscroll : 0;
1901 int selective
1902 = (INTEGERP (current_buffer->selective_display)
1903 ? XINT (current_buffer->selective_display)
1904 : !NILP (current_buffer->selective_display) ? -1 : 0);
1905 Lisp_Object window;
1906 EMACS_INT start_hpos = 0;
1907 int did_motion;
1908 /* This is the object we use for fetching character properties. */
1909 Lisp_Object text_prop_object;
1911 XSETWINDOW (window, w);
1913 /* If the window contains this buffer, use it for getting text properties.
1914 Otherwise use the current buffer as arg for doing that. */
1915 if (EQ (w->buffer, Fcurrent_buffer ()))
1916 text_prop_object = window;
1917 else
1918 text_prop_object = Fcurrent_buffer ();
1920 if (vpos >= vtarget)
1922 /* To move upward, go a line at a time until
1923 we have gone at least far enough. */
1925 first = 1;
1927 while ((vpos > vtarget || first) && from > BEGV)
1929 Lisp_Object propval;
1931 prevline = find_next_newline_no_quit (from - 1, -1);
1932 while (prevline > BEGV
1933 && ((selective > 0
1934 && indented_beyond_p (prevline,
1935 CHAR_TO_BYTE (prevline),
1936 (double) selective)) /* iftc */
1937 /* Watch out for newlines with `invisible' property.
1938 When moving upward, check the newline before. */
1939 || (propval = Fget_char_property (make_number (prevline - 1),
1940 Qinvisible,
1941 text_prop_object),
1942 TEXT_PROP_MEANS_INVISIBLE (propval))))
1943 prevline = find_next_newline_no_quit (prevline - 1, -1);
1944 pos = *compute_motion (prevline, 0,
1945 lmargin + (prevline == BEG ? start_hpos : 0),
1947 from,
1948 /* Don't care for VPOS... */
1949 1 << (BITS_PER_SHORT - 1),
1950 /* ... nor HPOS. */
1951 1 << (BITS_PER_SHORT - 1),
1952 -1, hscroll,
1953 /* This compensates for start_hpos
1954 so that a tab as first character
1955 still occupies 8 columns. */
1956 (prevline == BEG ? -start_hpos : 0),
1958 vpos -= pos.vpos;
1959 first = 0;
1960 from = prevline;
1963 /* If we made exactly the desired vertical distance,
1964 or if we hit beginning of buffer,
1965 return point found */
1966 if (vpos >= vtarget)
1968 val_vmotion.bufpos = from;
1969 val_vmotion.bytepos = CHAR_TO_BYTE (from);
1970 val_vmotion.vpos = vpos;
1971 val_vmotion.hpos = lmargin;
1972 val_vmotion.contin = 0;
1973 val_vmotion.prevhpos = 0;
1974 val_vmotion.ovstring_chars_done = 0;
1975 val_vmotion.tab_offset = 0; /* For accumulating tab offset. */
1976 return &val_vmotion;
1979 /* Otherwise find the correct spot by moving down */
1981 /* Moving downward is simple, but must calculate from beg of line
1982 to determine hpos of starting point */
1983 from_byte = CHAR_TO_BYTE (from);
1984 if (from > BEGV && FETCH_BYTE (from_byte - 1) != '\n')
1986 Lisp_Object propval;
1988 prevline = find_next_newline_no_quit (from, -1);
1989 while (prevline > BEGV
1990 && ((selective > 0
1991 && indented_beyond_p (prevline,
1992 CHAR_TO_BYTE (prevline),
1993 (double) selective)) /* iftc */
1994 /* Watch out for newlines with `invisible' property.
1995 When moving downward, check the newline after. */
1996 || (propval = Fget_char_property (make_number (prevline),
1997 Qinvisible,
1998 text_prop_object),
1999 TEXT_PROP_MEANS_INVISIBLE (propval))))
2000 prevline = find_next_newline_no_quit (prevline - 1, -1);
2001 pos = *compute_motion (prevline, 0,
2002 lmargin + (prevline == BEG
2003 ? start_hpos : 0),
2005 from,
2006 /* Don't care for VPOS... */
2007 1 << (BITS_PER_SHORT - 1),
2008 /* ... nor HPOS. */
2009 1 << (BITS_PER_SHORT - 1),
2010 -1, hscroll,
2011 (prevline == BEG ? -start_hpos : 0),
2013 did_motion = 1;
2015 else
2017 pos.hpos = lmargin + (from == BEG ? start_hpos : 0);
2018 pos.vpos = 0;
2019 pos.tab_offset = 0;
2020 did_motion = 0;
2022 return compute_motion (from, vpos, pos.hpos, did_motion,
2023 ZV, vtarget, - (1 << (BITS_PER_SHORT - 1)),
2024 -1, hscroll,
2025 pos.tab_offset - (from == BEG ? start_hpos : 0),
2029 DEFUN ("vertical-motion", Fvertical_motion, Svertical_motion, 1, 2, 0,
2030 doc: /* Move point to start of the screen line LINES lines down.
2031 If LINES is negative, this means moving up.
2033 This function is an ordinary cursor motion function
2034 which calculates the new position based on how text would be displayed.
2035 The new position may be the start of a line,
2036 or just the start of a continuation line.
2037 The function returns number of screen lines moved over;
2038 that usually equals LINES, but may be closer to zero
2039 if beginning or end of buffer was reached.
2041 The optional second argument WINDOW specifies the window to use for
2042 parameters such as width, horizontal scrolling, and so on.
2043 The default is to use the selected window's parameters.
2045 `vertical-motion' always uses the current buffer,
2046 regardless of which buffer is displayed in WINDOW.
2047 This is consistent with other cursor motion functions
2048 and makes it possible to use `vertical-motion' in any buffer,
2049 whether or not it is currently displayed in some window. */)
2050 (lines, window)
2051 Lisp_Object lines, window;
2053 struct it it;
2054 struct text_pos pt;
2055 struct window *w;
2056 Lisp_Object old_buffer;
2057 struct gcpro gcpro1;
2059 CHECK_NUMBER (lines);
2060 if (! NILP (window))
2061 CHECK_WINDOW (window);
2062 else
2063 window = selected_window;
2064 w = XWINDOW (window);
2066 old_buffer = Qnil;
2067 GCPRO1 (old_buffer);
2068 if (XBUFFER (w->buffer) != current_buffer)
2070 /* Set the window's buffer temporarily to the current buffer. */
2071 old_buffer = w->buffer;
2072 XSETBUFFER (w->buffer, current_buffer);
2075 if (noninteractive)
2077 struct position pos;
2078 pos = *vmotion (PT, XINT (lines), w);
2079 SET_PT_BOTH (pos.bufpos, pos.bytepos);
2081 else
2083 int it_start;
2084 int oselective;
2085 int it_overshoot_expected;
2087 SET_TEXT_POS (pt, PT, PT_BYTE);
2088 start_display (&it, w, pt);
2090 /* Scan from the start of the line containing PT. If we don't
2091 do this, we start moving with IT->current_x == 0, while PT is
2092 really at some x > 0. The effect is, in continuation lines, that
2093 we end up with the iterator placed at where it thinks X is 0,
2094 while the end position is really at some X > 0, the same X that
2095 PT had. */
2096 it_start = IT_CHARPOS (it);
2098 /* We expect the call to move_it_to, further down, to overshoot
2099 if the starting point is on an image, stretch glyph,
2100 composition, or Lisp string. We won't need to backtrack in
2101 this situation, except for one corner case: when the Lisp
2102 string contains a newline. */
2103 if (it.method == GET_FROM_STRING)
2105 const char *s = SDATA (it.string);
2106 const char *e = s + SBYTES (it.string);
2108 while (s < e && *s != '\n')
2109 ++s;
2111 /* If there is no newline in the string, we need to check
2112 whether there is a newline immediately after the string
2113 in move_it_to below. This may happen if there is an
2114 overlay with an after-string just before the newline. */
2115 it_overshoot_expected = (s == e) ? -1 : 0;
2117 else
2118 it_overshoot_expected = (it.method == GET_FROM_IMAGE
2119 || it.method == GET_FROM_STRETCH
2120 || it.method == GET_FROM_COMPOSITION);
2122 reseat_at_previous_visible_line_start (&it);
2123 it.current_x = it.hpos = 0;
2124 /* Temporarily disable selective display so we don't move too far */
2125 oselective = it.selective;
2126 it.selective = 0;
2127 move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
2128 it.selective = oselective;
2130 /* Move back if we got too far. This may happen if
2131 truncate-lines is on and PT is beyond right margin.
2132 Don't go back if the overshoot is expected (see above). */
2133 if (IT_CHARPOS (it) > it_start && XINT (lines) > 0
2134 && (!it_overshoot_expected
2135 || (it_overshoot_expected < 0
2136 && it.method == GET_FROM_BUFFER
2137 && it.c == '\n')))
2138 move_it_by_lines (&it, -1, 0);
2140 it.vpos = 0;
2141 /* Do this even if LINES is 0, so that we move back
2142 to the beginning of the current line as we ought. */
2143 if (XINT (lines) >= 0 || IT_CHARPOS (it) > 0)
2144 move_it_by_lines (&it, XINT (lines), 0);
2146 SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
2149 if (BUFFERP (old_buffer))
2150 w->buffer = old_buffer;
2152 RETURN_UNGCPRO (make_number (it.vpos));
2157 /* File's initialization. */
2159 void
2160 syms_of_indent ()
2162 DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode,
2163 doc: /* *Indentation can insert tabs if this is non-nil. */);
2164 indent_tabs_mode = 1;
2166 defsubr (&Scurrent_indentation);
2167 defsubr (&Sindent_to);
2168 defsubr (&Scurrent_column);
2169 defsubr (&Smove_to_column);
2170 defsubr (&Svertical_motion);
2171 defsubr (&Scompute_motion);
2174 /* arch-tag: 9adfea44-71f7-4988-8ee3-96da15c502cc
2175 (do not change this comment) */