Merge from origin/emacs-24
[emacs.git] / src / indent.c
blob04f5d6cfa4abae90c67a97a76b1779e76552a0ae
1 /* Indentation functions.
2 Copyright (C) 1985-1988, 1993-1995, 1998, 2000-2014 Free Software
3 Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 #include <config.h>
21 #include <stdio.h>
23 #include "lisp.h"
24 #include "character.h"
25 #include "buffer.h"
26 #include "category.h"
27 #include "composite.h"
28 #include "indent.h"
29 #include "keyboard.h"
30 #include "frame.h"
31 #include "window.h"
32 #include "termchar.h"
33 #include "disptab.h"
34 #include "intervals.h"
35 #include "dispextern.h"
36 #include "region-cache.h"
38 #define CR 015
40 /* These three values memorize the current column to avoid recalculation. */
42 /* Last value returned by current_column.
43 Some things in set last_known_column_point to -1
44 to mark the memorized value as invalid. */
46 static ptrdiff_t last_known_column;
48 /* Value of point when current_column was called. */
50 ptrdiff_t last_known_column_point;
52 /* Value of MODIFF when current_column was called. */
54 static EMACS_INT last_known_column_modified;
56 static ptrdiff_t current_column_1 (void);
57 static ptrdiff_t position_indentation (ptrdiff_t);
59 /* Get the display table to use for the current buffer. */
61 struct Lisp_Char_Table *
62 buffer_display_table (void)
64 Lisp_Object thisbuf;
66 thisbuf = BVAR (current_buffer, display_table);
67 if (DISP_TABLE_P (thisbuf))
68 return XCHAR_TABLE (thisbuf);
69 if (DISP_TABLE_P (Vstandard_display_table))
70 return XCHAR_TABLE (Vstandard_display_table);
71 return 0;
74 /* Width run cache considerations. */
76 /* Return the width of character C under display table DP. */
78 static int
79 character_width (int c, struct Lisp_Char_Table *dp)
81 Lisp_Object elt;
83 /* These width computations were determined by examining the cases
84 in display_text_line. */
86 /* Everything can be handled by the display table, if it's
87 present and the element is right. */
88 if (dp && (elt = DISP_CHAR_VECTOR (dp, c), VECTORP (elt)))
89 return ASIZE (elt);
91 /* Some characters are special. */
92 if (c == '\n' || c == '\t' || c == '\015')
93 return 0;
95 /* Printing characters have width 1. */
96 else if (c >= 040 && c < 0177)
97 return 1;
99 /* Everybody else (control characters, metacharacters) has other
100 widths. We could return their actual widths here, but they
101 depend on things like ctl_arrow and crud like that, and they're
102 not very common at all. So we'll just claim we don't know their
103 widths. */
104 else
105 return 0;
108 /* Return true if the display table DISPTAB specifies the same widths
109 for characters as WIDTHTAB. We use this to decide when to
110 invalidate the buffer's width_run_cache. */
112 bool
113 disptab_matches_widthtab (struct Lisp_Char_Table *disptab, struct Lisp_Vector *widthtab)
115 int i;
117 eassert (widthtab->header.size == 256);
119 for (i = 0; i < 256; i++)
120 if (character_width (i, disptab)
121 != XFASTINT (widthtab->contents[i]))
122 return 0;
124 return 1;
127 /* Recompute BUF's width table, using the display table DISPTAB. */
129 void
130 recompute_width_table (struct buffer *buf, struct Lisp_Char_Table *disptab)
132 int i;
133 struct Lisp_Vector *widthtab;
135 if (!VECTORP (BVAR (buf, width_table)))
136 bset_width_table (buf, make_uninit_vector (256));
137 widthtab = XVECTOR (BVAR (buf, width_table));
138 eassert (widthtab->header.size == 256);
140 for (i = 0; i < 256; i++)
141 XSETFASTINT (widthtab->contents[i], character_width (i, disptab));
144 /* Allocate or free the width run cache, as requested by the
145 current state of current_buffer's cache_long_scans variable. */
147 static struct region_cache *
148 width_run_cache_on_off (void)
150 struct buffer *cache_buffer = current_buffer;
151 bool indirect_p = false;
153 if (cache_buffer->base_buffer)
155 cache_buffer = cache_buffer->base_buffer;
156 indirect_p = true;
159 if (NILP (BVAR (current_buffer, cache_long_scans))
160 /* And, for the moment, this feature doesn't work on multibyte
161 characters. */
162 || !NILP (BVAR (current_buffer, enable_multibyte_characters)))
164 if (!indirect_p
165 || NILP (BVAR (cache_buffer, cache_long_scans))
166 || !NILP (BVAR (cache_buffer, enable_multibyte_characters)))
168 /* It should be off. */
169 if (cache_buffer->width_run_cache)
171 free_region_cache (cache_buffer->width_run_cache);
172 cache_buffer->width_run_cache = 0;
173 bset_width_table (current_buffer, Qnil);
176 return NULL;
178 else
180 if (!indirect_p
181 || (!NILP (BVAR (cache_buffer, cache_long_scans))
182 && NILP (BVAR (cache_buffer, enable_multibyte_characters))))
184 /* It should be on. */
185 if (cache_buffer->width_run_cache == 0)
187 cache_buffer->width_run_cache = new_region_cache ();
188 recompute_width_table (current_buffer, buffer_display_table ());
191 return cache_buffer->width_run_cache;
196 /* Skip some invisible characters starting from POS.
197 This includes characters invisible because of text properties
198 and characters invisible because of overlays.
200 If position POS is followed by invisible characters,
201 skip some of them and return the position after them.
202 Otherwise return POS itself.
204 Set *NEXT_BOUNDARY_P to the next position at which
205 it will be necessary to call this function again.
207 Don't scan past TO, and don't set *NEXT_BOUNDARY_P
208 to a value greater than TO.
210 If WINDOW is non-nil, and this buffer is displayed in WINDOW,
211 take account of overlays that apply only in WINDOW.
213 We don't necessarily skip all the invisible characters after POS
214 because that could take a long time. We skip a reasonable number
215 which can be skipped quickly. If there might be more invisible
216 characters immediately following, then *NEXT_BOUNDARY_P
217 will equal the return value. */
219 ptrdiff_t
220 skip_invisible (ptrdiff_t pos, ptrdiff_t *next_boundary_p, ptrdiff_t to, Lisp_Object window)
222 Lisp_Object prop, position, overlay_limit, proplimit;
223 Lisp_Object buffer, tmp;
224 ptrdiff_t end;
225 int inv_p;
227 XSETFASTINT (position, pos);
228 XSETBUFFER (buffer, current_buffer);
230 /* Give faster response for overlay lookup near POS. */
231 recenter_overlay_lists (current_buffer, pos);
233 /* We must not advance farther than the next overlay change.
234 The overlay change might change the invisible property;
235 or there might be overlay strings to be displayed there. */
236 overlay_limit = Fnext_overlay_change (position);
237 /* As for text properties, this gives a lower bound
238 for where the invisible text property could change. */
239 proplimit = Fnext_property_change (position, buffer, Qt);
240 if (XFASTINT (overlay_limit) < XFASTINT (proplimit))
241 proplimit = overlay_limit;
242 /* PROPLIMIT is now a lower bound for the next change
243 in invisible status. If that is plenty far away,
244 use that lower bound. */
245 if (XFASTINT (proplimit) > pos + 100 || XFASTINT (proplimit) >= to)
246 *next_boundary_p = XFASTINT (proplimit);
247 /* Otherwise, scan for the next `invisible' property change. */
248 else
250 /* Don't scan terribly far. */
251 XSETFASTINT (proplimit, min (pos + 100, to));
252 /* No matter what, don't go past next overlay change. */
253 if (XFASTINT (overlay_limit) < XFASTINT (proplimit))
254 proplimit = overlay_limit;
255 tmp = Fnext_single_property_change (position, Qinvisible,
256 buffer, proplimit);
257 end = XFASTINT (tmp);
258 #if 0
259 /* Don't put the boundary in the middle of multibyte form if
260 there is no actual property change. */
261 if (end == pos + 100
262 && !NILP (current_buffer->enable_multibyte_characters)
263 && end < ZV)
264 while (pos < end && !CHAR_HEAD_P (POS_ADDR (end)))
265 end--;
266 #endif
267 *next_boundary_p = end;
269 /* if the `invisible' property is set, we can skip to
270 the next property change */
271 prop = Fget_char_property (position, Qinvisible,
272 (!NILP (window)
273 && EQ (XWINDOW (window)->contents, buffer))
274 ? window : buffer);
275 inv_p = TEXT_PROP_MEANS_INVISIBLE (prop);
276 /* When counting columns (window == nil), don't skip over ellipsis text. */
277 if (NILP (window) ? inv_p == 1 : inv_p)
278 return *next_boundary_p;
279 return pos;
282 /* Set variables WIDTH and BYTES for a multibyte sequence starting at P.
284 DP is a display table or NULL.
286 This macro is used in scan_for_column and in
287 compute_motion. */
289 #define MULTIBYTE_BYTES_WIDTH(p, dp, bytes, width) \
290 do { \
291 int ch; \
293 ch = STRING_CHAR_AND_LENGTH (p, bytes); \
294 if (BYTES_BY_CHAR_HEAD (*p) != bytes) \
295 width = bytes * 4; \
296 else \
298 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, ch))) \
299 width = sanitize_char_width (ASIZE (DISP_CHAR_VECTOR (dp, ch))); \
300 else \
301 width = CHAR_WIDTH (ch); \
303 } while (0)
306 DEFUN ("current-column", Fcurrent_column, Scurrent_column, 0, 0, 0,
307 doc: /* Return the horizontal position of point. Beginning of line is column 0.
308 This is calculated by adding together the widths of all the displayed
309 representations of the character between the start of the previous line
310 and point (e.g., control characters will have a width of 2 or 4, tabs
311 will have a variable width).
312 Ignores finite width of frame, which means that this function may return
313 values greater than (frame-width).
314 Whether the line is visible (if `selective-display' is t) has no effect;
315 however, ^M is treated as end of line when `selective-display' is t.
316 Text that has an invisible property is considered as having width 0, unless
317 `buffer-invisibility-spec' specifies that it is replaced by an ellipsis. */)
318 (void)
320 Lisp_Object temp;
321 XSETFASTINT (temp, current_column ());
322 return temp;
325 /* Cancel any recorded value of the horizontal position. */
327 void
328 invalidate_current_column (void)
330 last_known_column_point = 0;
333 ptrdiff_t
334 current_column (void)
336 ptrdiff_t col;
337 unsigned char *ptr, *stop;
338 bool tab_seen;
339 ptrdiff_t post_tab;
340 int c;
341 int tab_width = SANE_TAB_WIDTH (current_buffer);
342 bool ctl_arrow = !NILP (BVAR (current_buffer, ctl_arrow));
343 struct Lisp_Char_Table *dp = buffer_display_table ();
345 if (PT == last_known_column_point
346 && MODIFF == last_known_column_modified)
347 return last_known_column;
349 /* If the buffer has overlays, text properties,
350 or multibyte characters, use a more general algorithm. */
351 if (buffer_intervals (current_buffer)
352 || buffer_has_overlays ()
353 || Z != Z_BYTE)
354 return current_column_1 ();
356 /* Scan backwards from point to the previous newline,
357 counting width. Tab characters are the only complicated case. */
359 /* Make a pointer for decrementing through the chars before point. */
360 ptr = BYTE_POS_ADDR (PT_BYTE - 1) + 1;
361 /* Make a pointer to where consecutive chars leave off,
362 going backwards from point. */
363 if (PT == BEGV)
364 stop = ptr;
365 else if (PT <= GPT || BEGV > GPT)
366 stop = BEGV_ADDR;
367 else
368 stop = GAP_END_ADDR;
370 col = 0, tab_seen = 0, post_tab = 0;
372 while (1)
374 ptrdiff_t i, n;
375 Lisp_Object charvec;
377 if (ptr == stop)
379 /* We stopped either for the beginning of the buffer
380 or for the gap. */
381 if (ptr == BEGV_ADDR)
382 break;
384 /* It was the gap. Jump back over it. */
385 stop = BEGV_ADDR;
386 ptr = GPT_ADDR;
388 /* Check whether that brings us to beginning of buffer. */
389 if (BEGV >= GPT)
390 break;
393 c = *--ptr;
395 if (dp && VECTORP (DISP_CHAR_VECTOR (dp, c)))
397 charvec = DISP_CHAR_VECTOR (dp, c);
398 n = ASIZE (charvec);
400 else
402 charvec = Qnil;
403 n = 1;
406 for (i = n - 1; i >= 0; --i)
408 if (VECTORP (charvec))
410 /* This should be handled the same as
411 next_element_from_display_vector does it. */
412 Lisp_Object entry = AREF (charvec, i);
414 if (GLYPH_CODE_P (entry))
415 c = GLYPH_CODE_CHAR (entry);
416 else
417 c = ' ';
420 if (c >= 040 && c < 0177)
421 col++;
422 else if (c == '\n'
423 || (c == '\r'
424 && EQ (BVAR (current_buffer, selective_display), Qt)))
426 ptr++;
427 goto start_of_line_found;
429 else if (c == '\t')
431 if (tab_seen)
432 col = ((col + tab_width) / tab_width) * tab_width;
434 post_tab += col;
435 col = 0;
436 tab_seen = 1;
438 else if (VECTORP (charvec))
439 /* With a display table entry, C is displayed as is, and
440 not displayed as \NNN or as ^N. If C is a single-byte
441 character, it takes one column. If C is multi-byte in
442 a unibyte buffer, it's translated to unibyte, so it
443 also takes one column. */
444 ++col;
445 else
446 col += (ctl_arrow && c < 0200) ? 2 : 4;
450 start_of_line_found:
452 if (tab_seen)
454 col = ((col + tab_width) / tab_width) * tab_width;
455 col += post_tab;
458 last_known_column = col;
459 last_known_column_point = PT;
460 last_known_column_modified = MODIFF;
462 return col;
466 /* Check the presence of a display property and compute its width.
467 If a property was found and its width was found as well, return
468 its width (>= 0) and set the position of the end of the property
469 in ENDPOS.
470 Otherwise just return -1. */
471 static int
472 check_display_width (ptrdiff_t pos, ptrdiff_t col, ptrdiff_t *endpos)
474 Lisp_Object val, overlay;
476 if (CONSP (val = get_char_property_and_overlay
477 (make_number (pos), Qdisplay, Qnil, &overlay))
478 && EQ (Qspace, XCAR (val)))
479 { /* FIXME: Use calc_pixel_width_or_height. */
480 Lisp_Object plist = XCDR (val), prop;
481 int width = -1;
482 EMACS_INT align_to_max =
483 (col < MOST_POSITIVE_FIXNUM - INT_MAX
484 ? (EMACS_INT) INT_MAX + col
485 : MOST_POSITIVE_FIXNUM);
487 if ((prop = Fplist_get (plist, QCwidth),
488 RANGED_INTEGERP (0, prop, INT_MAX)))
489 width = XINT (prop);
490 else if (FLOATP (prop) && 0 <= XFLOAT_DATA (prop)
491 && XFLOAT_DATA (prop) <= INT_MAX)
492 width = (int)(XFLOAT_DATA (prop) + 0.5);
493 else if ((prop = Fplist_get (plist, QCalign_to),
494 RANGED_INTEGERP (col, prop, align_to_max)))
495 width = XINT (prop) - col;
496 else if (FLOATP (prop) && col <= XFLOAT_DATA (prop)
497 && (XFLOAT_DATA (prop) <= align_to_max))
498 width = (int)(XFLOAT_DATA (prop) + 0.5) - col;
500 if (width >= 0)
502 ptrdiff_t start;
503 if (OVERLAYP (overlay))
504 *endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
505 else
506 get_property_and_range (pos, Qdisplay, &val, &start, endpos, Qnil);
507 return width;
510 return -1;
513 /* Scanning from the beginning of the current line, stop at the buffer
514 position ENDPOS or at the column GOALCOL or at the end of line, whichever
515 comes first.
516 Return the resulting buffer position and column in ENDPOS and GOALCOL.
517 PREVCOL gets set to the column of the previous position (it's always
518 strictly smaller than the goal column). */
519 static void
520 scan_for_column (ptrdiff_t *endpos, EMACS_INT *goalcol, ptrdiff_t *prevcol)
522 int tab_width = SANE_TAB_WIDTH (current_buffer);
523 bool ctl_arrow = !NILP (BVAR (current_buffer, ctl_arrow));
524 struct Lisp_Char_Table *dp = buffer_display_table ();
525 bool multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
526 struct composition_it cmp_it;
527 Lisp_Object window;
528 struct window *w;
530 /* Start the scan at the beginning of this line with column number 0. */
531 register ptrdiff_t col = 0, prev_col = 0;
532 EMACS_INT goal = goalcol ? *goalcol : MOST_POSITIVE_FIXNUM;
533 ptrdiff_t end = endpos ? *endpos : PT;
534 ptrdiff_t scan, scan_byte, next_boundary;
536 scan = find_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -1, NULL, &scan_byte, 1);
537 next_boundary = scan;
539 window = Fget_buffer_window (Fcurrent_buffer (), Qnil);
540 w = ! NILP (window) ? XWINDOW (window) : NULL;
542 memset (&cmp_it, 0, sizeof cmp_it);
543 cmp_it.id = -1;
544 composition_compute_stop_pos (&cmp_it, scan, scan_byte, end, Qnil);
546 /* Scan forward to the target position. */
547 while (scan < end)
549 int c;
551 /* Occasionally we may need to skip invisible text. */
552 while (scan == next_boundary)
554 ptrdiff_t old_scan = scan;
555 /* This updates NEXT_BOUNDARY to the next place
556 where we might need to skip more invisible text. */
557 scan = skip_invisible (scan, &next_boundary, end, Qnil);
558 if (scan != old_scan)
559 scan_byte = CHAR_TO_BYTE (scan);
560 if (scan >= end)
561 goto endloop;
564 /* Test reaching the goal column. We do this after skipping
565 invisible characters, so that we put point before the
566 character on which the cursor will appear. */
567 if (col >= goal)
568 break;
569 prev_col = col;
571 { /* Check display property. */
572 ptrdiff_t endp;
573 int width = check_display_width (scan, col, &endp);
574 if (width >= 0)
576 col += width;
577 if (endp > scan) /* Avoid infinite loops with 0-width overlays. */
579 scan = endp;
580 scan_byte = CHAR_TO_BYTE (scan);
581 continue;
586 /* Check composition sequence. */
587 if (cmp_it.id >= 0
588 || (scan == cmp_it.stop_pos
589 && composition_reseat_it (&cmp_it, scan, scan_byte, end,
590 w, NULL, Qnil)))
591 composition_update_it (&cmp_it, scan, scan_byte, Qnil);
592 if (cmp_it.id >= 0)
594 scan += cmp_it.nchars;
595 scan_byte += cmp_it.nbytes;
596 if (scan <= end)
597 col += cmp_it.width;
598 if (cmp_it.to == cmp_it.nglyphs)
600 cmp_it.id = -1;
601 composition_compute_stop_pos (&cmp_it, scan, scan_byte, end,
602 Qnil);
604 else
605 cmp_it.from = cmp_it.to;
606 continue;
609 c = FETCH_BYTE (scan_byte);
611 /* See if there is a display table and it relates
612 to this character. */
614 if (dp != 0
615 && ! (multibyte && LEADING_CODE_P (c))
616 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
618 Lisp_Object charvec;
619 ptrdiff_t i, n;
621 /* This character is displayed using a vector of glyphs.
622 Update the column/position based on those glyphs. */
624 charvec = DISP_CHAR_VECTOR (dp, c);
625 n = ASIZE (charvec);
627 for (i = 0; i < n; i++)
629 /* This should be handled the same as
630 next_element_from_display_vector does it. */
631 Lisp_Object entry = AREF (charvec, i);
633 if (GLYPH_CODE_P (entry))
634 c = GLYPH_CODE_CHAR (entry);
635 else
636 c = ' ';
638 if (c == '\n')
639 goto endloop;
640 if (c == '\r' && EQ (BVAR (current_buffer, selective_display), Qt))
641 goto endloop;
642 if (c == '\t')
644 col += tab_width;
645 col = col / tab_width * tab_width;
647 else
648 ++col;
651 else
653 /* The display table doesn't affect this character;
654 it displays as itself. */
656 if (c == '\n')
657 goto endloop;
658 if (c == '\r' && EQ (BVAR (current_buffer, selective_display), Qt))
659 goto endloop;
660 if (c == '\t')
662 col += tab_width;
663 col = col / tab_width * tab_width;
665 else if (multibyte && LEADING_CODE_P (c))
667 /* Start of multi-byte form. */
668 unsigned char *ptr;
669 int bytes, width;
671 ptr = BYTE_POS_ADDR (scan_byte);
672 MULTIBYTE_BYTES_WIDTH (ptr, dp, bytes, width);
673 /* Subtract one to compensate for the increment
674 that is going to happen below. */
675 scan_byte += bytes - 1;
676 col += width;
678 else if (ctl_arrow && (c < 040 || c == 0177))
679 col += 2;
680 else if (c < 040 || c >= 0177)
681 col += 4;
682 else
683 col++;
685 scan++;
686 scan_byte++;
689 endloop:
691 last_known_column = col;
692 last_known_column_point = PT;
693 last_known_column_modified = MODIFF;
695 if (goalcol)
696 *goalcol = col;
697 if (endpos)
698 *endpos = scan;
699 if (prevcol)
700 *prevcol = prev_col;
703 /* Return the column number of point
704 by scanning forward from the beginning of the line.
705 This function handles characters that are invisible
706 due to text properties or overlays. */
708 static ptrdiff_t
709 current_column_1 (void)
711 EMACS_INT col = MOST_POSITIVE_FIXNUM;
712 ptrdiff_t opoint = PT;
714 scan_for_column (&opoint, &col, NULL);
715 return col;
719 #if 0 /* Not used. */
721 /* Return the width in columns of the part of STRING from BEG to END.
722 If BEG is nil, that stands for the beginning of STRING.
723 If END is nil, that stands for the end of STRING. */
725 static double
726 string_display_width (Lisp_Object string, Lisp_Object beg, Lisp_Object end)
728 int col;
729 unsigned char *ptr, *stop;
730 bool tab_seen;
731 int post_tab;
732 int c;
733 int tab_width = SANE_TAB_WIDTH (current_buffer);
734 bool ctl_arrow = !NILP (current_buffer->ctl_arrow);
735 struct Lisp_Char_Table *dp = buffer_display_table ();
736 int b, e;
738 if (NILP (end))
739 e = SCHARS (string);
740 else
742 CHECK_NUMBER (end);
743 e = XINT (end);
746 if (NILP (beg))
747 b = 0;
748 else
750 CHECK_NUMBER (beg);
751 b = XINT (beg);
754 /* Make a pointer for decrementing through the chars before point. */
755 ptr = SDATA (string) + e;
756 /* Make a pointer to where consecutive chars leave off,
757 going backwards from point. */
758 stop = SDATA (string) + b;
760 col = 0, tab_seen = 0, post_tab = 0;
762 while (1)
764 if (ptr == stop)
765 break;
767 c = *--ptr;
768 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
769 col += ASIZE (DISP_CHAR_VECTOR (dp, c));
770 else if (c >= 040 && c < 0177)
771 col++;
772 else if (c == '\n')
773 break;
774 else if (c == '\t')
776 if (tab_seen)
777 col = ((col + tab_width) / tab_width) * tab_width;
779 post_tab += col;
780 col = 0;
781 tab_seen = 1;
783 else
784 col += (ctl_arrow && c < 0200) ? 2 : 4;
787 if (tab_seen)
789 col = ((col + tab_width) / tab_width) * tab_width;
790 col += post_tab;
793 return col;
796 #endif /* 0 */
799 DEFUN ("indent-to", Findent_to, Sindent_to, 1, 2, "NIndent to column: ",
800 doc: /* Indent from point with tabs and spaces until COLUMN is reached.
801 Optional second argument MINIMUM says always do at least MINIMUM spaces
802 even if that goes past COLUMN; by default, MINIMUM is zero.
804 The return value is COLUMN. */)
805 (Lisp_Object column, Lisp_Object minimum)
807 EMACS_INT mincol;
808 register ptrdiff_t fromcol;
809 int tab_width = SANE_TAB_WIDTH (current_buffer);
811 CHECK_NUMBER (column);
812 if (NILP (minimum))
813 XSETFASTINT (minimum, 0);
814 CHECK_NUMBER (minimum);
816 fromcol = current_column ();
817 mincol = fromcol + XINT (minimum);
818 if (mincol < XINT (column)) mincol = XINT (column);
820 if (fromcol == mincol)
821 return make_number (mincol);
823 if (indent_tabs_mode)
825 Lisp_Object n;
826 XSETFASTINT (n, mincol / tab_width - fromcol / tab_width);
827 if (XFASTINT (n) != 0)
829 Finsert_char (make_number ('\t'), n, Qt);
831 fromcol = (mincol / tab_width) * tab_width;
835 XSETFASTINT (column, mincol - fromcol);
836 Finsert_char (make_number (' '), column, Qt);
838 last_known_column = mincol;
839 last_known_column_point = PT;
840 last_known_column_modified = MODIFF;
842 XSETINT (column, mincol);
843 return column;
847 DEFUN ("current-indentation", Fcurrent_indentation, Scurrent_indentation,
848 0, 0, 0,
849 doc: /* Return the indentation of the current line.
850 This is the horizontal position of the character
851 following any initial whitespace. */)
852 (void)
854 ptrdiff_t posbyte;
856 find_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -1, NULL, &posbyte, 1);
857 return make_number (position_indentation (posbyte));
860 static ptrdiff_t
861 position_indentation (ptrdiff_t pos_byte)
863 register ptrdiff_t column = 0;
864 int tab_width = SANE_TAB_WIDTH (current_buffer);
865 register unsigned char *p;
866 register unsigned char *stop;
867 unsigned char *start;
868 ptrdiff_t next_boundary_byte = pos_byte;
869 ptrdiff_t ceiling = next_boundary_byte;
871 p = BYTE_POS_ADDR (pos_byte);
872 /* STOP records the value of P at which we will need
873 to think about the gap, or about invisible text,
874 or about the end of the buffer. */
875 stop = p;
876 /* START records the starting value of P. */
877 start = p;
878 while (1)
880 while (p == stop)
882 ptrdiff_t stop_pos_byte;
884 /* If we have updated P, set POS_BYTE to match.
885 The first time we enter the loop, POS_BYTE is already right. */
886 if (p != start)
887 pos_byte = PTR_BYTE_POS (p);
888 /* Consider the various reasons STOP might have been set here. */
889 if (pos_byte == ZV_BYTE)
890 return column;
891 if (pos_byte == next_boundary_byte)
893 ptrdiff_t next_boundary;
894 ptrdiff_t pos = BYTE_TO_CHAR (pos_byte);
895 pos = skip_invisible (pos, &next_boundary, ZV, Qnil);
896 pos_byte = CHAR_TO_BYTE (pos);
897 next_boundary_byte = CHAR_TO_BYTE (next_boundary);
899 if (pos_byte >= ceiling)
900 ceiling = BUFFER_CEILING_OF (pos_byte) + 1;
901 /* Compute the next place we need to stop and think,
902 and set STOP accordingly. */
903 stop_pos_byte = min (ceiling, next_boundary_byte);
904 /* The -1 and +1 arrange to point at the first byte of gap
905 (if STOP_POS_BYTE is the position of the gap)
906 rather than at the data after the gap. */
908 stop = BYTE_POS_ADDR (stop_pos_byte - 1) + 1;
909 p = BYTE_POS_ADDR (pos_byte);
911 switch (*p++)
913 case 0240:
914 if (! NILP (BVAR (current_buffer, enable_multibyte_characters)))
915 return column;
916 case ' ':
917 column++;
918 break;
919 case '\t':
920 column += tab_width - column % tab_width;
921 break;
922 default:
923 if (ASCII_CHAR_P (p[-1])
924 || NILP (BVAR (current_buffer, enable_multibyte_characters)))
925 return column;
927 int c;
928 pos_byte = PTR_BYTE_POS (p - 1);
929 c = FETCH_MULTIBYTE_CHAR (pos_byte);
930 if (CHAR_HAS_CATEGORY (c, ' '))
932 column++;
933 INC_POS (pos_byte);
934 p = BYTE_POS_ADDR (pos_byte);
936 else
937 return column;
943 /* Test whether the line beginning at POS is indented beyond COLUMN.
944 Blank lines are treated as if they had the same indentation as the
945 preceding line. */
947 bool
948 indented_beyond_p (ptrdiff_t pos, ptrdiff_t pos_byte, EMACS_INT column)
950 while (pos > BEGV && FETCH_BYTE (pos_byte) == '\n')
952 DEC_BOTH (pos, pos_byte);
953 pos = find_newline (pos, pos_byte, BEGV, BEGV_BYTE,
954 -1, NULL, &pos_byte, 0);
956 return position_indentation (pos_byte) >= column;
959 DEFUN ("move-to-column", Fmove_to_column, Smove_to_column, 1, 2,
960 "NMove to column: ",
961 doc: /* Move point to column COLUMN in the current line.
962 Interactively, COLUMN is the value of prefix numeric argument.
963 The column of a character is calculated by adding together the widths
964 as displayed of the previous characters in the line.
965 This function ignores line-continuation;
966 there is no upper limit on the column number a character can have
967 and horizontal scrolling has no effect.
969 If specified column is within a character, point goes after that character.
970 If it's past end of line, point goes to end of line.
972 Optional second argument FORCE non-nil means if COLUMN is in the
973 middle of a tab character, change it to spaces.
974 In addition, if FORCE is t, and the line is too short to reach
975 COLUMN, add spaces/tabs to get there.
977 The return value is the current column. */)
978 (Lisp_Object column, Lisp_Object force)
980 ptrdiff_t pos, prev_col;
981 EMACS_INT col;
982 EMACS_INT goal;
984 CHECK_NATNUM (column);
985 goal = XINT (column);
987 col = goal;
988 pos = ZV;
989 scan_for_column (&pos, &col, &prev_col);
991 SET_PT (pos);
993 /* If a tab char made us overshoot, change it to spaces
994 and scan through it again. */
995 if (!NILP (force) && col > goal)
997 int c;
998 ptrdiff_t pos_byte = PT_BYTE;
1000 DEC_POS (pos_byte);
1001 c = FETCH_CHAR (pos_byte);
1002 if (c == '\t' && prev_col < goal)
1004 ptrdiff_t goal_pt, goal_pt_byte;
1006 /* Insert spaces in front of the tab to reach GOAL. Do this
1007 first so that a marker at the end of the tab gets
1008 adjusted. */
1009 SET_PT_BOTH (PT - 1, PT_BYTE - 1);
1010 Finsert_char (make_number (' '), make_number (goal - prev_col), Qt);
1012 /* Now delete the tab, and indent to COL. */
1013 del_range (PT, PT + 1);
1014 goal_pt = PT;
1015 goal_pt_byte = PT_BYTE;
1016 Findent_to (make_number (col), Qnil);
1017 SET_PT_BOTH (goal_pt, goal_pt_byte);
1019 /* Set the last_known... vars consistently. */
1020 col = goal;
1024 /* If line ends prematurely, add space to the end. */
1025 if (col < goal && EQ (force, Qt))
1026 Findent_to (make_number (col = goal), Qnil);
1028 last_known_column = col;
1029 last_known_column_point = PT;
1030 last_known_column_modified = MODIFF;
1032 return make_number (col);
1035 /* compute_motion: compute buffer posn given screen posn and vice versa */
1037 static struct position val_compute_motion;
1039 /* Scan the current buffer forward from offset FROM, pretending that
1040 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
1041 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
1042 and return the ending buffer position and screen location. If we
1043 can't hit the requested column exactly (because of a tab or other
1044 multi-column character), overshoot.
1046 DID_MOTION is true if FROMHPOS has already accounted for overlay strings
1047 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
1048 earlier call to compute_motion. The other common case is that FROMHPOS
1049 is zero and FROM is a position that "belongs" at column zero, but might
1050 be shifted by overlay strings; in this case DID_MOTION should be false.
1052 WIDTH is the number of columns available to display text;
1053 compute_motion uses this to handle continuation lines and such.
1054 If WIDTH is -1, use width of window's text area adjusted for
1055 continuation glyph when needed.
1057 HSCROLL is the number of columns not being displayed at the left
1058 margin; this is usually taken from a window's hscroll member.
1059 TAB_OFFSET is the number of columns of the first tab that aren't
1060 being displayed, perhaps because of a continuation line or
1061 something.
1063 compute_motion returns a pointer to a struct position. The bufpos
1064 member gives the buffer position at the end of the scan, and hpos
1065 and vpos give its cartesian location. prevhpos is the column at
1066 which the character before bufpos started, and contin is non-zero
1067 if we reached the current line by continuing the previous.
1069 Note that FROMHPOS and TOHPOS should be expressed in real screen
1070 columns, taking HSCROLL and the truncation glyph at the left margin
1071 into account. That is, beginning-of-line moves you to the hpos
1072 -HSCROLL + (HSCROLL > 0).
1074 For example, to find the buffer position of column COL of line LINE
1075 of a certain window, pass the window's starting location as FROM
1076 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
1077 Pass the buffer's ZV as TO, to limit the scan to the end of the
1078 visible section of the buffer, and pass LINE and COL as TOVPOS and
1079 TOHPOS.
1081 When displaying in window w, a typical formula for WIDTH is:
1083 window_width - 1
1084 - (has_vertical_scroll_bars
1085 ? WINDOW_CONFIG_SCROLL_BAR_COLS (window)
1086 : (window_width + window_left != frame_cols))
1088 where
1089 window_width is w->total_cols,
1090 window_left is w->left_col,
1091 has_vertical_scroll_bars is
1092 WINDOW_HAS_VERTICAL_SCROLL_BAR (window)
1093 and frame_cols = FRAME_COLS (XFRAME (window->frame))
1095 Or you can let window_body_cols do this all for you, and write:
1096 window_body_cols (w) - 1
1098 The `-1' accounts for the continuation-line backslashes; the rest
1099 accounts for window borders if the window is split horizontally, and
1100 the scroll bars if they are turned on. */
1102 struct position *
1103 compute_motion (ptrdiff_t from, ptrdiff_t frombyte, EMACS_INT fromvpos,
1104 EMACS_INT fromhpos, bool did_motion, ptrdiff_t to,
1105 EMACS_INT tovpos, EMACS_INT tohpos, EMACS_INT width,
1106 ptrdiff_t hscroll, int tab_offset, struct window *win)
1108 EMACS_INT hpos = fromhpos;
1109 EMACS_INT vpos = fromvpos;
1111 ptrdiff_t pos;
1112 ptrdiff_t pos_byte;
1113 int c = 0;
1114 int tab_width = SANE_TAB_WIDTH (current_buffer);
1115 bool ctl_arrow = !NILP (BVAR (current_buffer, ctl_arrow));
1116 struct Lisp_Char_Table *dp = window_display_table (win);
1117 EMACS_INT selective
1118 = (INTEGERP (BVAR (current_buffer, selective_display))
1119 ? XINT (BVAR (current_buffer, selective_display))
1120 : !NILP (BVAR (current_buffer, selective_display)) ? -1 : 0);
1121 ptrdiff_t selective_rlen
1122 = (selective && dp && VECTORP (DISP_INVIS_VECTOR (dp))
1123 ? ASIZE (DISP_INVIS_VECTOR (dp)) : 0);
1124 /* The next location where the `invisible' property changes, or an
1125 overlay starts or ends. */
1126 ptrdiff_t next_boundary = from;
1128 /* For computing runs of characters with similar widths.
1129 Invariant: width_run_width is zero, or all the characters
1130 from width_run_start to width_run_end have a fixed width of
1131 width_run_width. */
1132 ptrdiff_t width_run_start = from;
1133 ptrdiff_t width_run_end = from;
1134 ptrdiff_t width_run_width = 0;
1135 Lisp_Object *width_table;
1137 /* The next buffer pos where we should consult the width run cache. */
1138 ptrdiff_t next_width_run = from;
1139 Lisp_Object window;
1141 bool multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
1142 /* If previous char scanned was a wide character,
1143 this is the column where it ended. Otherwise, this is 0. */
1144 EMACS_INT wide_column_end_hpos = 0;
1145 ptrdiff_t prev_pos; /* Previous buffer position. */
1146 ptrdiff_t prev_pos_byte; /* Previous buffer position. */
1147 EMACS_INT prev_hpos = 0;
1148 EMACS_INT prev_vpos = 0;
1149 EMACS_INT contin_hpos; /* HPOS of last column of continued line. */
1150 int prev_tab_offset; /* Previous tab offset. */
1151 int continuation_glyph_width;
1152 struct buffer *cache_buffer = current_buffer;
1153 struct region_cache *width_cache;
1155 struct composition_it cmp_it;
1157 XSETWINDOW (window, win);
1159 if (cache_buffer->base_buffer)
1160 cache_buffer = cache_buffer->base_buffer;
1161 width_cache = width_run_cache_on_off ();
1162 if (dp == buffer_display_table ())
1163 width_table = (VECTORP (BVAR (current_buffer, width_table))
1164 ? XVECTOR (BVAR (current_buffer, width_table))->contents
1165 : 0);
1166 else
1167 /* If the window has its own display table, we can't use the width
1168 run cache, because that's based on the buffer's display table. */
1169 width_table = 0;
1171 /* Negative width means use all available text columns. */
1172 if (width < 0)
1174 width = window_body_width (win, 0);
1175 /* We must make room for continuation marks if we don't have fringes. */
1176 #ifdef HAVE_WINDOW_SYSTEM
1177 if (!FRAME_WINDOW_P (XFRAME (win->frame)))
1178 #endif
1179 width -= 1;
1182 continuation_glyph_width = 1;
1183 #ifdef HAVE_WINDOW_SYSTEM
1184 if (FRAME_WINDOW_P (XFRAME (win->frame)))
1185 continuation_glyph_width = 0; /* In the fringe. */
1186 #endif
1188 immediate_quit = 1;
1189 QUIT;
1191 /* It's just impossible to be too paranoid here. */
1192 eassert (from == BYTE_TO_CHAR (frombyte) && frombyte == CHAR_TO_BYTE (from));
1194 pos = prev_pos = from;
1195 pos_byte = prev_pos_byte = frombyte;
1196 contin_hpos = 0;
1197 prev_tab_offset = tab_offset;
1198 memset (&cmp_it, 0, sizeof cmp_it);
1199 cmp_it.id = -1;
1200 composition_compute_stop_pos (&cmp_it, pos, pos_byte, to, Qnil);
1202 while (1)
1204 while (pos == next_boundary)
1206 ptrdiff_t pos_here = pos;
1207 ptrdiff_t newpos;
1209 /* Don't skip invisible if we are already at the margin. */
1210 if (vpos > tovpos || (vpos == tovpos && hpos >= tohpos))
1212 if (contin_hpos && prev_hpos == 0
1213 && hpos > tohpos
1214 && (contin_hpos == width || wide_column_end_hpos > width))
1215 { /* Line breaks because we can't put the character at the
1216 previous line any more. It is not the multi-column
1217 character continued in middle. Go back to previous
1218 buffer position, screen position, and set tab offset
1219 to previous value. It's the beginning of the
1220 line. */
1221 pos = prev_pos;
1222 pos_byte = prev_pos_byte;
1223 hpos = prev_hpos;
1224 vpos = prev_vpos;
1225 tab_offset = prev_tab_offset;
1227 break;
1230 /* If the caller says that the screen position came from an earlier
1231 call to compute_motion, then we've already accounted for the
1232 overlay strings at point. This is only true the first time
1233 through, so clear the flag after testing it. */
1234 if (!did_motion)
1235 /* We need to skip past the overlay strings. Currently those
1236 strings must not contain TAB;
1237 if we want to relax that restriction, something will have
1238 to be changed here. */
1240 unsigned char *ovstr;
1241 ptrdiff_t ovlen = overlay_strings (pos, win, &ovstr);
1242 hpos += ((multibyte && ovlen > 0)
1243 ? strwidth ((char *) ovstr, ovlen) : ovlen);
1245 did_motion = 0;
1247 if (pos >= to)
1248 break;
1250 /* Advance POS past invisible characters
1251 (but not necessarily all that there are here),
1252 and store in next_boundary the next position where
1253 we need to call skip_invisible. */
1254 newpos = skip_invisible (pos, &next_boundary, to, window);
1256 if (newpos >= to)
1258 pos = min (to, newpos);
1259 pos_byte = CHAR_TO_BYTE (pos);
1260 goto after_loop;
1263 if (newpos != pos_here)
1265 pos = newpos;
1266 pos_byte = CHAR_TO_BYTE (pos);
1270 /* Handle right margin. */
1271 /* Note on a wide-column character.
1273 Characters are classified into the following three categories
1274 according to the width (columns occupied on screen).
1276 (1) single-column character: ex. `a'
1277 (2) multi-column character: ex. `^A', TAB, `\033'
1278 (3) wide-column character: ex. Japanese character, Chinese character
1279 (In the following example, `W_' stands for them.)
1281 Multi-column characters can be divided around the right margin,
1282 but wide-column characters cannot.
1284 NOTE:
1286 (*) The cursor is placed on the next character after the point.
1288 ----------
1289 abcdefghi\
1290 j ^---- next after the point
1291 ^--- next char. after the point.
1292 ----------
1293 In case of sigle-column character
1295 ----------
1296 abcdefgh\\
1297 033 ^---- next after the point, next char. after the point.
1298 ----------
1299 In case of multi-column character
1301 ----------
1302 abcdefgh\\
1303 W_ ^---- next after the point
1304 ^---- next char. after the point.
1305 ----------
1306 In case of wide-column character
1308 The problem here is continuation at a wide-column character.
1309 In this case, the line may shorter less than WIDTH.
1310 And we find the continuation AFTER it occurs.
1314 if (hpos > width)
1316 EMACS_INT total_width = width + continuation_glyph_width;
1317 bool truncate = 0;
1319 if (!NILP (Vtruncate_partial_width_windows)
1320 && (total_width < FRAME_COLS (XFRAME (WINDOW_FRAME (win)))))
1322 if (INTEGERP (Vtruncate_partial_width_windows))
1323 truncate
1324 = total_width < XFASTINT (Vtruncate_partial_width_windows);
1325 else
1326 truncate = 1;
1329 if (hscroll || truncate
1330 || !NILP (BVAR (current_buffer, truncate_lines)))
1332 /* Truncating: skip to newline, unless we are already past
1333 TO (we need to go back below). */
1334 if (pos <= to)
1336 pos = find_before_next_newline (pos, to, 1, &pos_byte);
1337 hpos = width;
1338 /* If we just skipped next_boundary,
1339 loop around in the main while
1340 and handle it. */
1341 if (pos >= next_boundary)
1342 next_boundary = pos + 1;
1343 prev_hpos = width;
1344 prev_vpos = vpos;
1345 prev_tab_offset = tab_offset;
1348 else
1350 /* Continuing. */
1351 /* Remember the previous value. */
1352 prev_tab_offset = tab_offset;
1354 if (wide_column_end_hpos > width)
1356 hpos -= prev_hpos;
1357 tab_offset += prev_hpos;
1359 else
1361 tab_offset += width;
1362 hpos -= width;
1364 vpos++;
1365 contin_hpos = prev_hpos;
1366 prev_hpos = 0;
1367 prev_vpos = vpos;
1371 /* Stop if past the target buffer position or screen position. */
1372 if (pos > to)
1374 /* Go back to the previous position. */
1375 pos = prev_pos;
1376 pos_byte = prev_pos_byte;
1377 hpos = prev_hpos;
1378 vpos = prev_vpos;
1379 tab_offset = prev_tab_offset;
1381 /* NOTE on contin_hpos, hpos, and prev_hpos.
1383 ----------
1384 abcdefgh\\
1385 W_ ^---- contin_hpos
1386 | ^----- hpos
1387 \---- prev_hpos
1388 ----------
1391 if (contin_hpos && prev_hpos == 0
1392 && contin_hpos < width && !wide_column_end_hpos)
1394 /* Line breaking occurs in the middle of multi-column
1395 character. Go back to previous line. */
1396 hpos = contin_hpos;
1397 vpos = vpos - 1;
1399 break;
1402 if (vpos > tovpos || (vpos == tovpos && hpos >= tohpos))
1404 if (contin_hpos && prev_hpos == 0
1405 && hpos > tohpos
1406 && (contin_hpos == width || wide_column_end_hpos > width))
1407 { /* Line breaks because we can't put the character at the
1408 previous line any more. It is not the multi-column
1409 character continued in middle. Go back to previous
1410 buffer position, screen position, and set tab offset
1411 to previous value. It's the beginning of the
1412 line. */
1413 pos = prev_pos;
1414 pos_byte = prev_pos_byte;
1415 hpos = prev_hpos;
1416 vpos = prev_vpos;
1417 tab_offset = prev_tab_offset;
1419 break;
1421 if (pos == ZV) /* We cannot go beyond ZV. Stop here. */
1422 break;
1424 prev_hpos = hpos;
1425 prev_vpos = vpos;
1426 prev_pos = pos;
1427 prev_pos_byte = pos_byte;
1428 wide_column_end_hpos = 0;
1430 /* Consult the width run cache to see if we can avoid inspecting
1431 the text character-by-character. */
1432 if (width_cache && pos >= next_width_run)
1434 ptrdiff_t run_end;
1435 int common_width
1436 = region_cache_forward (cache_buffer, width_cache, pos, &run_end);
1438 /* A width of zero means the character's width varies (like
1439 a tab), is meaningless (like a newline), or we just don't
1440 want to skip over it for some other reason. */
1441 if (common_width != 0)
1443 ptrdiff_t run_end_hpos;
1445 /* Don't go past the final buffer posn the user
1446 requested. */
1447 if (run_end > to)
1448 run_end = to;
1450 run_end_hpos = hpos + (run_end - pos) * common_width;
1452 /* Don't go past the final horizontal position the user
1453 requested. */
1454 if (vpos == tovpos && run_end_hpos > tohpos)
1456 run_end = pos + (tohpos - hpos) / common_width;
1457 run_end_hpos = hpos + (run_end - pos) * common_width;
1460 /* Don't go past the margin. */
1461 if (run_end_hpos >= width)
1463 run_end = pos + (width - hpos) / common_width;
1464 run_end_hpos = hpos + (run_end - pos) * common_width;
1467 hpos = run_end_hpos;
1468 if (run_end > pos)
1469 prev_hpos = hpos - common_width;
1470 if (pos != run_end)
1472 pos = run_end;
1473 pos_byte = CHAR_TO_BYTE (pos);
1477 next_width_run = run_end + 1;
1480 /* We have to scan the text character-by-character. */
1481 else
1483 ptrdiff_t i, n;
1484 Lisp_Object charvec;
1486 /* Check composition sequence. */
1487 if (cmp_it.id >= 0
1488 || (pos == cmp_it.stop_pos
1489 && composition_reseat_it (&cmp_it, pos, pos_byte, to, win,
1490 NULL, Qnil)))
1491 composition_update_it (&cmp_it, pos, pos_byte, Qnil);
1492 if (cmp_it.id >= 0)
1494 pos += cmp_it.nchars;
1495 pos_byte += cmp_it.nbytes;
1496 hpos += cmp_it.width;
1497 if (cmp_it.to == cmp_it.nglyphs)
1499 cmp_it.id = -1;
1500 composition_compute_stop_pos (&cmp_it, pos, pos_byte, to,
1501 Qnil);
1503 else
1504 cmp_it.from = cmp_it.to;
1505 continue;
1508 c = FETCH_BYTE (pos_byte);
1509 pos++, pos_byte++;
1511 /* Perhaps add some info to the width_run_cache. */
1512 if (width_cache)
1514 /* Is this character part of the current run? If so, extend
1515 the run. */
1516 if (pos - 1 == width_run_end
1517 && XFASTINT (width_table[c]) == width_run_width)
1518 width_run_end = pos;
1520 /* The previous run is over, since this is a character at a
1521 different position, or a different width. */
1522 else
1524 /* Have we accumulated a run to put in the cache?
1525 (Currently, we only cache runs of width == 1). */
1526 if (width_run_start < width_run_end
1527 && width_run_width == 1)
1528 know_region_cache (cache_buffer, width_cache,
1529 width_run_start, width_run_end);
1531 /* Start recording a new width run. */
1532 width_run_width = XFASTINT (width_table[c]);
1533 width_run_start = pos - 1;
1534 width_run_end = pos;
1538 if (dp != 0
1539 && ! (multibyte && LEADING_CODE_P (c))
1540 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
1542 charvec = DISP_CHAR_VECTOR (dp, c);
1543 n = ASIZE (charvec);
1545 else
1547 charvec = Qnil;
1548 n = 1;
1551 for (i = 0; i < n; ++i)
1553 if (VECTORP (charvec))
1555 /* This should be handled the same as
1556 next_element_from_display_vector does it. */
1557 Lisp_Object entry = AREF (charvec, i);
1559 if (GLYPH_CODE_P (entry))
1560 c = GLYPH_CODE_CHAR (entry);
1561 else
1562 c = ' ';
1565 if (c >= 040 && c < 0177)
1566 hpos++;
1567 else if (c == '\t')
1569 int tem = ((hpos + tab_offset + hscroll - (hscroll > 0))
1570 % tab_width);
1571 if (tem < 0)
1572 tem += tab_width;
1573 hpos += tab_width - tem;
1575 else if (c == '\n')
1577 if (selective > 0
1578 && indented_beyond_p (pos, pos_byte, selective))
1580 /* If (pos == to), we don't have to take care of
1581 selective display. */
1582 if (pos < to)
1584 /* Skip any number of invisible lines all at once */
1587 pos = find_before_next_newline (pos, to, 1, &pos_byte);
1588 if (pos < to)
1589 INC_BOTH (pos, pos_byte);
1591 while (pos < to
1592 && indented_beyond_p (pos, pos_byte,
1593 selective));
1594 /* Allow for the " ..." that is displayed for them. */
1595 if (selective_rlen)
1597 hpos += selective_rlen;
1598 if (hpos >= width)
1599 hpos = width;
1601 DEC_BOTH (pos, pos_byte);
1602 /* We have skipped the invis text, but not the
1603 newline after. */
1606 else
1608 /* A visible line. */
1609 vpos++;
1610 hpos = 0;
1611 hpos -= hscroll;
1612 /* Count the truncation glyph on column 0 */
1613 if (hscroll > 0)
1614 hpos += continuation_glyph_width;
1615 tab_offset = 0;
1617 contin_hpos = 0;
1619 else if (c == CR && selective < 0)
1621 /* In selective display mode,
1622 everything from a ^M to the end of the line is invisible.
1623 Stop *before* the real newline. */
1624 if (pos < to)
1625 pos = find_before_next_newline (pos, to, 1, &pos_byte);
1626 /* If we just skipped next_boundary,
1627 loop around in the main while
1628 and handle it. */
1629 if (pos > next_boundary)
1630 next_boundary = pos;
1631 /* Allow for the " ..." that is displayed for them. */
1632 if (selective_rlen)
1634 hpos += selective_rlen;
1635 if (hpos >= width)
1636 hpos = width;
1639 else if (multibyte && LEADING_CODE_P (c))
1641 /* Start of multi-byte form. */
1642 unsigned char *ptr;
1643 int mb_bytes, mb_width;
1645 pos_byte--; /* rewind POS_BYTE */
1646 ptr = BYTE_POS_ADDR (pos_byte);
1647 MULTIBYTE_BYTES_WIDTH (ptr, dp, mb_bytes, mb_width);
1648 pos_byte += mb_bytes;
1649 if (mb_width > 1 && BYTES_BY_CHAR_HEAD (*ptr) == mb_bytes)
1650 wide_column_end_hpos = hpos + mb_width;
1651 hpos += mb_width;
1653 else if (VECTORP (charvec))
1654 ++hpos;
1655 else
1656 hpos += (ctl_arrow && c < 0200) ? 2 : 4;
1661 after_loop:
1663 /* Remember any final width run in the cache. */
1664 if (width_cache
1665 && width_run_width == 1
1666 && width_run_start < width_run_end)
1667 know_region_cache (cache_buffer, width_cache,
1668 width_run_start, width_run_end);
1670 val_compute_motion.bufpos = pos;
1671 val_compute_motion.bytepos = pos_byte;
1672 val_compute_motion.hpos = hpos;
1673 val_compute_motion.vpos = vpos;
1674 if (contin_hpos && prev_hpos == 0)
1675 val_compute_motion.prevhpos = contin_hpos;
1676 else
1677 val_compute_motion.prevhpos = prev_hpos;
1679 /* Nonzero if have just continued a line */
1680 val_compute_motion.contin = (contin_hpos && prev_hpos == 0);
1682 immediate_quit = 0;
1683 return &val_compute_motion;
1687 DEFUN ("compute-motion", Fcompute_motion, Scompute_motion, 7, 7, 0,
1688 doc: /* Scan through the current buffer, calculating screen position.
1689 Scan the current buffer forward from offset FROM,
1690 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--
1691 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--
1692 and return the ending buffer position and screen location.
1694 If TOPOS is nil, the actual width and height of the window's
1695 text area are used.
1697 There are three additional arguments:
1699 WIDTH is the number of columns available to display text;
1700 this affects handling of continuation lines. A value of nil
1701 corresponds to the actual number of available text columns.
1703 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).
1704 HSCROLL is the number of columns not being displayed at the left
1705 margin; this is usually taken from a window's hscroll member.
1706 TAB-OFFSET is the number of columns of the first tab that aren't
1707 being displayed, perhaps because the line was continued within it.
1708 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.
1710 WINDOW is the window to operate on. It is used to choose the display table;
1711 if it is showing the current buffer, it is used also for
1712 deciding which overlay properties apply.
1713 Note that `compute-motion' always operates on the current buffer.
1715 The value is a list of five elements:
1716 (POS HPOS VPOS PREVHPOS CONTIN)
1717 POS is the buffer position where the scan stopped.
1718 VPOS is the vertical position where the scan stopped.
1719 HPOS is the horizontal position where the scan stopped.
1721 PREVHPOS is the horizontal position one character back from POS.
1722 CONTIN is t if a line was continued after (or within) the previous character.
1724 For example, to find the buffer position of column COL of line LINE
1725 of a certain window, pass the window's starting location as FROM
1726 and the window's upper-left coordinates as FROMPOS.
1727 Pass the buffer's (point-max) as TO, to limit the scan to the end of the
1728 visible section of the buffer, and pass LINE and COL as TOPOS. */)
1729 (Lisp_Object from, Lisp_Object frompos, Lisp_Object to, Lisp_Object topos,
1730 Lisp_Object width, Lisp_Object offsets, Lisp_Object window)
1732 struct window *w;
1733 Lisp_Object bufpos, hpos, vpos, prevhpos;
1734 struct position *pos;
1735 ptrdiff_t hscroll;
1736 int tab_offset;
1738 CHECK_NUMBER_COERCE_MARKER (from);
1739 CHECK_CONS (frompos);
1740 CHECK_NUMBER_CAR (frompos);
1741 CHECK_NUMBER_CDR (frompos);
1742 CHECK_NUMBER_COERCE_MARKER (to);
1743 if (!NILP (topos))
1745 CHECK_CONS (topos);
1746 CHECK_NUMBER_CAR (topos);
1747 CHECK_NUMBER_CDR (topos);
1749 if (!NILP (width))
1750 CHECK_NUMBER (width);
1752 if (!NILP (offsets))
1754 CHECK_CONS (offsets);
1755 CHECK_NUMBER_CAR (offsets);
1756 CHECK_NUMBER_CDR (offsets);
1757 if (! (0 <= XINT (XCAR (offsets)) && XINT (XCAR (offsets)) <= PTRDIFF_MAX
1758 && 0 <= XINT (XCDR (offsets)) && XINT (XCDR (offsets)) <= INT_MAX))
1759 args_out_of_range (XCAR (offsets), XCDR (offsets));
1760 hscroll = XINT (XCAR (offsets));
1761 tab_offset = XINT (XCDR (offsets));
1763 else
1764 hscroll = tab_offset = 0;
1766 w = decode_live_window (window);
1768 if (XINT (from) < BEGV || XINT (from) > ZV)
1769 args_out_of_range_3 (from, make_number (BEGV), make_number (ZV));
1770 if (XINT (to) < BEGV || XINT (to) > ZV)
1771 args_out_of_range_3 (to, make_number (BEGV), make_number (ZV));
1773 pos = compute_motion (XINT (from), CHAR_TO_BYTE (XINT (from)),
1774 XINT (XCDR (frompos)),
1775 XINT (XCAR (frompos)), 0,
1776 XINT (to),
1777 (NILP (topos)
1778 ? window_internal_height (w)
1779 : XINT (XCDR (topos))),
1780 (NILP (topos)
1781 ? (window_body_width (w, 0)
1783 #ifdef HAVE_WINDOW_SYSTEM
1784 FRAME_WINDOW_P (XFRAME (w->frame)) ? 0 :
1785 #endif
1787 : XINT (XCAR (topos))),
1788 (NILP (width) ? -1 : XINT (width)),
1789 hscroll, tab_offset, w);
1791 XSETFASTINT (bufpos, pos->bufpos);
1792 XSETINT (hpos, pos->hpos);
1793 XSETINT (vpos, pos->vpos);
1794 XSETINT (prevhpos, pos->prevhpos);
1796 return list5 (bufpos, hpos, vpos, prevhpos, pos->contin ? Qt : Qnil);
1799 /* Fvertical_motion and vmotion. */
1801 static struct position val_vmotion;
1803 struct position *
1804 vmotion (register ptrdiff_t from, register ptrdiff_t from_byte,
1805 register EMACS_INT vtarget, struct window *w)
1807 ptrdiff_t hscroll = w->hscroll;
1808 struct position pos;
1809 /* VPOS is cumulative vertical position, changed as from is changed. */
1810 register EMACS_INT vpos = 0;
1811 ptrdiff_t prevline;
1812 register ptrdiff_t first;
1813 ptrdiff_t lmargin = hscroll > 0 ? 1 - hscroll : 0;
1814 ptrdiff_t selective
1815 = (INTEGERP (BVAR (current_buffer, selective_display))
1816 ? clip_to_bounds (-1, XINT (BVAR (current_buffer, selective_display)),
1817 PTRDIFF_MAX)
1818 : !NILP (BVAR (current_buffer, selective_display)) ? -1 : 0);
1819 Lisp_Object window;
1820 bool did_motion;
1821 /* This is the object we use for fetching character properties. */
1822 Lisp_Object text_prop_object;
1824 XSETWINDOW (window, w);
1826 /* If the window contains this buffer, use it for getting text properties.
1827 Otherwise use the current buffer as arg for doing that. */
1828 if (EQ (w->contents, Fcurrent_buffer ()))
1829 text_prop_object = window;
1830 else
1831 text_prop_object = Fcurrent_buffer ();
1833 if (vpos >= vtarget)
1835 /* To move upward, go a line at a time until
1836 we have gone at least far enough. */
1838 first = 1;
1840 while ((vpos > vtarget || first) && from > BEGV)
1842 ptrdiff_t bytepos = from_byte;
1843 Lisp_Object propval;
1845 prevline = from;
1846 DEC_BOTH (prevline, bytepos);
1847 prevline = find_newline_no_quit (prevline, bytepos, -1, &bytepos);
1849 while (prevline > BEGV
1850 && ((selective > 0
1851 && indented_beyond_p (prevline, bytepos, selective))
1852 /* Watch out for newlines with `invisible' property.
1853 When moving upward, check the newline before. */
1854 || (propval = Fget_char_property (make_number (prevline - 1),
1855 Qinvisible,
1856 text_prop_object),
1857 TEXT_PROP_MEANS_INVISIBLE (propval))))
1859 DEC_BOTH (prevline, bytepos);
1860 prevline = find_newline_no_quit (prevline, bytepos, -1, &bytepos);
1862 pos = *compute_motion (prevline, bytepos, 0, lmargin, 0, from,
1863 /* Don't care for VPOS... */
1864 1 << (BITS_PER_SHORT - 1),
1865 /* ... nor HPOS. */
1866 1 << (BITS_PER_SHORT - 1),
1867 -1, hscroll, 0, w);
1868 vpos -= pos.vpos;
1869 first = 0;
1870 from = prevline;
1871 from_byte = bytepos;
1874 /* If we made exactly the desired vertical distance, or
1875 if we hit beginning of buffer, return point found. */
1876 if (vpos >= vtarget)
1878 val_vmotion.bufpos = from;
1879 val_vmotion.bytepos = from_byte;
1880 val_vmotion.vpos = vpos;
1881 val_vmotion.hpos = lmargin;
1882 val_vmotion.contin = 0;
1883 val_vmotion.prevhpos = 0;
1884 return &val_vmotion;
1887 /* Otherwise find the correct spot by moving down. */
1890 /* Moving downward is simple, but must calculate from
1891 beg of line to determine hpos of starting point. */
1893 if (from > BEGV && FETCH_BYTE (from_byte - 1) != '\n')
1895 ptrdiff_t bytepos;
1896 Lisp_Object propval;
1898 prevline = find_newline_no_quit (from, from_byte, -1, &bytepos);
1899 while (prevline > BEGV
1900 && ((selective > 0
1901 && indented_beyond_p (prevline, bytepos, selective))
1902 /* Watch out for newlines with `invisible' property.
1903 When moving downward, check the newline after. */
1904 || (propval = Fget_char_property (make_number (prevline),
1905 Qinvisible,
1906 text_prop_object),
1907 TEXT_PROP_MEANS_INVISIBLE (propval))))
1909 DEC_BOTH (prevline, bytepos);
1910 prevline = find_newline_no_quit (prevline, bytepos, -1, &bytepos);
1912 pos = *compute_motion (prevline, bytepos, 0, lmargin, 0, from,
1913 /* Don't care for VPOS... */
1914 1 << (BITS_PER_SHORT - 1),
1915 /* ... nor HPOS. */
1916 1 << (BITS_PER_SHORT - 1),
1917 -1, hscroll, 0, w);
1918 did_motion = 1;
1920 else
1922 pos.hpos = lmargin;
1923 pos.vpos = 0;
1924 did_motion = 0;
1926 return compute_motion (from, from_byte, vpos, pos.hpos, did_motion,
1927 ZV, vtarget, - (1 << (BITS_PER_SHORT - 1)),
1928 -1, hscroll, 0, w);
1931 DEFUN ("vertical-motion", Fvertical_motion, Svertical_motion, 1, 2, 0,
1932 doc: /* Move point to start of the screen line LINES lines down.
1933 If LINES is negative, this means moving up.
1935 This function is an ordinary cursor motion function
1936 which calculates the new position based on how text would be displayed.
1937 The new position may be the start of a line,
1938 or just the start of a continuation line.
1939 The function returns number of screen lines moved over;
1940 that usually equals LINES, but may be closer to zero
1941 if beginning or end of buffer was reached.
1943 The optional second argument WINDOW specifies the window to use for
1944 parameters such as width, horizontal scrolling, and so on.
1945 The default is to use the selected window's parameters.
1947 LINES can optionally take the form (COLS . LINES), in which case the
1948 motion will not stop at the start of a screen line but COLS column
1949 from the visual start of the line (if such exists on that line, that
1950 is). If the line is scrolled horizontally, COLS is interpreted
1951 visually, i.e., as addition to the columns of text beyond the left
1952 edge of the window.
1954 `vertical-motion' always uses the current buffer,
1955 regardless of which buffer is displayed in WINDOW.
1956 This is consistent with other cursor motion functions
1957 and makes it possible to use `vertical-motion' in any buffer,
1958 whether or not it is currently displayed in some window. */)
1959 (Lisp_Object lines, Lisp_Object window)
1961 struct it it;
1962 struct text_pos pt;
1963 struct window *w;
1964 Lisp_Object old_buffer;
1965 EMACS_INT old_charpos IF_LINT (= 0), old_bytepos IF_LINT (= 0);
1966 struct gcpro gcpro1;
1967 Lisp_Object lcols = Qnil;
1968 double cols IF_LINT (= 0);
1969 void *itdata = NULL;
1971 /* Allow LINES to be of the form (HPOS . VPOS) aka (COLUMNS . LINES). */
1972 if (CONSP (lines) && (NUMBERP (XCAR (lines))))
1974 lcols = XCAR (lines);
1975 cols = INTEGERP (lcols) ? (double) XINT (lcols) : XFLOAT_DATA (lcols);
1976 lines = XCDR (lines);
1979 CHECK_NUMBER (lines);
1980 w = decode_live_window (window);
1982 old_buffer = Qnil;
1983 GCPRO1 (old_buffer);
1984 if (XBUFFER (w->contents) != current_buffer)
1986 /* Set the window's buffer temporarily to the current buffer. */
1987 old_buffer = w->contents;
1988 old_charpos = marker_position (w->pointm);
1989 old_bytepos = marker_byte_position (w->pointm);
1990 wset_buffer (w, Fcurrent_buffer ());
1991 set_marker_both (w->pointm, w->contents,
1992 BUF_PT (current_buffer), BUF_PT_BYTE (current_buffer));
1995 if (noninteractive)
1997 struct position pos;
1998 pos = *vmotion (PT, PT_BYTE, XINT (lines), w);
1999 SET_PT_BOTH (pos.bufpos, pos.bytepos);
2001 else
2003 ptrdiff_t it_start, it_overshoot_count = 0;
2004 int first_x;
2005 bool overshoot_handled = 0;
2006 bool disp_string_at_start_p = 0;
2007 ptrdiff_t nlines = XINT (lines);
2008 int vpos_init = 0;
2010 itdata = bidi_shelve_cache ();
2011 SET_TEXT_POS (pt, PT, PT_BYTE);
2012 start_display (&it, w, pt);
2013 first_x = it.first_visible_x;
2014 it_start = IT_CHARPOS (it);
2016 /* See comments below for why we calculate this. */
2017 if (it.cmp_it.id >= 0)
2018 it_overshoot_count = 0;
2019 else if (it.method == GET_FROM_STRING)
2021 const char *s = SSDATA (it.string);
2022 const char *e = s + SBYTES (it.string);
2024 disp_string_at_start_p =
2025 /* If it.area is anything but TEXT_AREA, we need not bother
2026 about the display string, as it doesn't affect cursor
2027 positioning. */
2028 it.area == TEXT_AREA
2029 && it.string_from_display_prop_p
2030 /* A display string on anything but buffer text (e.g., on
2031 an overlay string) doesn't affect cursor positioning. */
2032 && (it.sp > 0 && it.stack[it.sp - 1].method == GET_FROM_BUFFER);
2033 while (s < e)
2035 if (*s++ == '\n')
2036 it_overshoot_count++;
2038 if (!it_overshoot_count)
2039 it_overshoot_count = -1;
2041 else
2042 it_overshoot_count =
2043 !(it.method == GET_FROM_IMAGE || it.method == GET_FROM_STRETCH);
2045 /* Scan from the start of the line containing PT. If we don't
2046 do this, we start moving with IT->current_x == 0, while PT is
2047 really at some x > 0. */
2048 reseat_at_previous_visible_line_start (&it);
2049 it.current_x = it.hpos = 0;
2050 if (IT_CHARPOS (it) != PT)
2051 /* We used to temporarily disable selective display here; the
2052 comment said this is "so we don't move too far" (2005-01-19
2053 checkin by kfs). But this does nothing useful that I can
2054 tell, and it causes Bug#2694 . -- cyd */
2055 /* When the position we started from is covered by a display
2056 string, move_it_to will overshoot it, while vertical-motion
2057 wants to put the cursor _before_ the display string. So in
2058 that case, we move to buffer position before the display
2059 string, and avoid overshooting. But if the position before
2060 the display string is a newline, we don't do this, because
2061 otherwise we will end up in a screen line that is one too
2062 far back. */
2063 move_it_to (&it,
2064 (!disp_string_at_start_p
2065 || FETCH_BYTE (IT_BYTEPOS (it)) == '\n')
2066 ? PT
2067 : PT - 1,
2068 -1, -1, -1, MOVE_TO_POS);
2070 /* IT may move too far if truncate-lines is on and PT lies
2071 beyond the right margin. IT may also move too far if the
2072 starting point is on a Lisp string that has embedded
2073 newlines, or spans several screen lines. In these cases,
2074 backtrack. */
2075 if (IT_CHARPOS (it) > it_start)
2077 /* We need to backtrack also if the Lisp string contains no
2078 newlines, but there is a newline right after it. In this
2079 case, IT overshoots if there is an after-string just
2080 before the newline. */
2081 if (it_overshoot_count < 0
2082 && it.method == GET_FROM_BUFFER
2083 && it.c == '\n')
2084 it_overshoot_count = 1;
2085 else if (disp_string_at_start_p && it.vpos > 0)
2087 /* This is the case of a display string that spans
2088 several screen lines. In that case, we end up at the
2089 end of the string, and it.vpos tells us how many
2090 screen lines we need to backtrack. */
2091 it_overshoot_count = it.vpos;
2093 if (it_overshoot_count > 0)
2094 move_it_by_lines (&it, -it_overshoot_count);
2096 overshoot_handled = 1;
2098 else if (IT_CHARPOS (it) == PT - 1
2099 && FETCH_BYTE (PT - 1) == '\n'
2100 && nlines < 0)
2102 /* The position we started from was covered by a display
2103 property, so we moved to position before the string, and
2104 backed up one line, because the character at PT - 1 is a
2105 newline. So we need one less line to go up. */
2106 nlines++;
2107 /* But we still need to record that one line, in order to
2108 return the correct value to the caller. */
2109 vpos_init = -1;
2111 if (nlines <= 0)
2113 it.vpos = vpos_init;
2114 /* Do this even if LINES is 0, so that we move back to the
2115 beginning of the current line as we ought. */
2116 if (nlines == 0 || IT_CHARPOS (it) > 0)
2117 move_it_by_lines (&it, max (PTRDIFF_MIN, nlines));
2119 else if (overshoot_handled)
2121 it.vpos = 0;
2122 move_it_by_lines (&it, min (PTRDIFF_MAX, nlines));
2124 else
2126 /* Otherwise, we are at the first row occupied by PT, which
2127 might span multiple screen lines (e.g., if it's on a
2128 multi-line display string). We want to start from the
2129 last line that it occupies. */
2130 if (it_start < ZV)
2132 while (IT_CHARPOS (it) <= it_start)
2134 it.vpos = 0;
2135 move_it_by_lines (&it, 1);
2137 if (nlines > 1)
2138 move_it_by_lines (&it, min (PTRDIFF_MAX, nlines - 1));
2140 else
2142 it.vpos = 0;
2143 move_it_by_lines (&it, min (PTRDIFF_MAX, nlines));
2147 /* Move to the goal column, if one was specified. If the window
2148 was originally hscrolled, the goal column is interpreted as
2149 an addition to the hscroll amount. */
2150 if (!NILP (lcols))
2152 int to_x = (int)(cols * FRAME_COLUMN_WIDTH (XFRAME (w->frame)) + 0.5);
2154 move_it_in_display_line (&it, ZV, first_x + to_x, MOVE_TO_X);
2157 SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
2158 bidi_unshelve_cache (itdata, 0);
2161 if (BUFFERP (old_buffer))
2163 wset_buffer (w, old_buffer);
2164 set_marker_both (w->pointm, w->contents,
2165 old_charpos, old_bytepos);
2168 RETURN_UNGCPRO (make_number (it.vpos));
2173 /* File's initialization. */
2175 void
2176 syms_of_indent (void)
2178 DEFVAR_BOOL ("indent-tabs-mode", indent_tabs_mode,
2179 doc: /* Indentation can insert tabs if this is non-nil. */);
2180 indent_tabs_mode = 1;
2182 defsubr (&Scurrent_indentation);
2183 defsubr (&Sindent_to);
2184 defsubr (&Scurrent_column);
2185 defsubr (&Smove_to_column);
2186 defsubr (&Svertical_motion);
2187 defsubr (&Scompute_motion);