1 /* Indentation functions.
2 Copyright (C) 1985-1988, 1993-1995, 1998, 2000-2012
3 Free Software 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/>. */
24 #include "character.h"
27 #include "composite.h"
34 #include "intervals.h"
35 #include "dispextern.h"
36 #include "region-cache.h"
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 /* Cache of beginning of line found by the last call of
62 static ptrdiff_t current_column_bol_cache
;
64 /* Get the display table to use for the current buffer. */
66 struct Lisp_Char_Table
*
67 buffer_display_table (void)
71 thisbuf
= BVAR (current_buffer
, display_table
);
72 if (DISP_TABLE_P (thisbuf
))
73 return XCHAR_TABLE (thisbuf
);
74 if (DISP_TABLE_P (Vstandard_display_table
))
75 return XCHAR_TABLE (Vstandard_display_table
);
79 /* Width run cache considerations. */
81 /* Return the width of character C under display table DP. */
84 character_width (int c
, struct Lisp_Char_Table
*dp
)
88 /* These width computations were determined by examining the cases
89 in display_text_line. */
91 /* Everything can be handled by the display table, if it's
92 present and the element is right. */
93 if (dp
&& (elt
= DISP_CHAR_VECTOR (dp
, c
), VECTORP (elt
)))
96 /* Some characters are special. */
97 if (c
== '\n' || c
== '\t' || c
== '\015')
100 /* Printing characters have width 1. */
101 else if (c
>= 040 && c
< 0177)
104 /* Everybody else (control characters, metacharacters) has other
105 widths. We could return their actual widths here, but they
106 depend on things like ctl_arrow and crud like that, and they're
107 not very common at all. So we'll just claim we don't know their
113 /* Return true if the display table DISPTAB specifies the same widths
114 for characters as WIDTHTAB. We use this to decide when to
115 invalidate the buffer's width_run_cache. */
118 disptab_matches_widthtab (struct Lisp_Char_Table
*disptab
, struct Lisp_Vector
*widthtab
)
122 if (widthtab
->header
.size
!= 256)
125 for (i
= 0; i
< 256; i
++)
126 if (character_width (i
, disptab
)
127 != XFASTINT (widthtab
->contents
[i
]))
133 /* Recompute BUF's width table, using the display table DISPTAB. */
136 recompute_width_table (struct buffer
*buf
, struct Lisp_Char_Table
*disptab
)
139 struct Lisp_Vector
*widthtab
;
141 if (!VECTORP (BVAR (buf
, width_table
)))
142 bset_width_table (buf
, Fmake_vector (make_number (256), make_number (0)));
143 widthtab
= XVECTOR (BVAR (buf
, width_table
));
144 if (widthtab
->header
.size
!= 256)
147 for (i
= 0; i
< 256; i
++)
148 XSETFASTINT (widthtab
->contents
[i
], character_width (i
, disptab
));
151 /* Allocate or free the width run cache, as requested by the current
152 state of current_buffer's cache_long_line_scans variable. */
155 width_run_cache_on_off (void)
157 if (NILP (BVAR (current_buffer
, cache_long_line_scans
))
158 /* And, for the moment, this feature doesn't work on multibyte
160 || !NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
162 /* It should be off. */
163 if (current_buffer
->width_run_cache
)
165 free_region_cache (current_buffer
->width_run_cache
);
166 current_buffer
->width_run_cache
= 0;
167 bset_width_table (current_buffer
, Qnil
);
172 /* It should be on. */
173 if (current_buffer
->width_run_cache
== 0)
175 current_buffer
->width_run_cache
= new_region_cache ();
176 recompute_width_table (current_buffer
, buffer_display_table ());
182 /* Skip some invisible characters starting from POS.
183 This includes characters invisible because of text properties
184 and characters invisible because of overlays.
186 If position POS is followed by invisible characters,
187 skip some of them and return the position after them.
188 Otherwise return POS itself.
190 Set *NEXT_BOUNDARY_P to the next position at which
191 it will be necessary to call this function again.
193 Don't scan past TO, and don't set *NEXT_BOUNDARY_P
194 to a value greater than TO.
196 If WINDOW is non-nil, and this buffer is displayed in WINDOW,
197 take account of overlays that apply only in WINDOW.
199 We don't necessarily skip all the invisible characters after POS
200 because that could take a long time. We skip a reasonable number
201 which can be skipped quickly. If there might be more invisible
202 characters immediately following, then *NEXT_BOUNDARY_P
203 will equal the return value. */
206 skip_invisible (ptrdiff_t pos
, ptrdiff_t *next_boundary_p
, ptrdiff_t to
, Lisp_Object window
)
208 Lisp_Object prop
, position
, overlay_limit
, proplimit
;
209 Lisp_Object buffer
, tmp
;
213 XSETFASTINT (position
, pos
);
214 XSETBUFFER (buffer
, current_buffer
);
216 /* Give faster response for overlay lookup near POS. */
217 recenter_overlay_lists (current_buffer
, pos
);
219 /* We must not advance farther than the next overlay change.
220 The overlay change might change the invisible property;
221 or there might be overlay strings to be displayed there. */
222 overlay_limit
= Fnext_overlay_change (position
);
223 /* As for text properties, this gives a lower bound
224 for where the invisible text property could change. */
225 proplimit
= Fnext_property_change (position
, buffer
, Qt
);
226 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
227 proplimit
= overlay_limit
;
228 /* PROPLIMIT is now a lower bound for the next change
229 in invisible status. If that is plenty far away,
230 use that lower bound. */
231 if (XFASTINT (proplimit
) > pos
+ 100 || XFASTINT (proplimit
) >= to
)
232 *next_boundary_p
= XFASTINT (proplimit
);
233 /* Otherwise, scan for the next `invisible' property change. */
236 /* Don't scan terribly far. */
237 XSETFASTINT (proplimit
, min (pos
+ 100, to
));
238 /* No matter what, don't go past next overlay change. */
239 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
240 proplimit
= overlay_limit
;
241 tmp
= Fnext_single_property_change (position
, Qinvisible
,
243 end
= XFASTINT (tmp
);
245 /* Don't put the boundary in the middle of multibyte form if
246 there is no actual property change. */
248 && !NILP (current_buffer
->enable_multibyte_characters
)
250 while (pos
< end
&& !CHAR_HEAD_P (POS_ADDR (end
)))
253 *next_boundary_p
= end
;
255 /* if the `invisible' property is set, we can skip to
256 the next property change */
257 prop
= Fget_char_property (position
, Qinvisible
,
259 && EQ (XWINDOW (window
)->buffer
, buffer
))
261 inv_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
262 /* When counting columns (window == nil), don't skip over ellipsis text. */
263 if (NILP (window
) ? inv_p
== 1 : inv_p
)
264 return *next_boundary_p
;
268 /* Set variables WIDTH and BYTES for a multibyte sequence starting at P.
270 DP is a display table or NULL.
272 This macro is used in scan_for_column and in
275 #define MULTIBYTE_BYTES_WIDTH(p, dp, bytes, width) \
279 ch = STRING_CHAR_AND_LENGTH (p, bytes); \
280 if (BYTES_BY_CHAR_HEAD (*p) != bytes) \
284 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, ch))) \
285 width = sanitize_char_width (ASIZE (DISP_CHAR_VECTOR (dp, ch))); \
287 width = CHAR_WIDTH (ch); \
292 DEFUN ("current-column", Fcurrent_column
, Scurrent_column
, 0, 0, 0,
293 doc
: /* Return the horizontal position of point. Beginning of line is column 0.
294 This is calculated by adding together the widths of all the displayed
295 representations of the character between the start of the previous line
296 and point (eg. control characters will have a width of 2 or 4, tabs
297 will have a variable width).
298 Ignores finite width of frame, which means that this function may return
299 values greater than (frame-width).
300 Whether the line is visible (if `selective-display' is t) has no effect;
301 however, ^M is treated as end of line when `selective-display' is t.
302 Text that has an invisible property is considered as having width 0, unless
303 `buffer-invisibility-spec' specifies that it is replaced by an ellipsis. */)
307 XSETFASTINT (temp
, current_column ());
311 /* Cancel any recorded value of the horizontal position. */
314 invalidate_current_column (void)
316 last_known_column_point
= 0;
320 current_column (void)
323 unsigned char *ptr
, *stop
;
327 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
328 bool ctl_arrow
= !NILP (BVAR (current_buffer
, ctl_arrow
));
329 struct Lisp_Char_Table
*dp
= buffer_display_table ();
331 if (PT
== last_known_column_point
332 && MODIFF
== last_known_column_modified
)
333 return last_known_column
;
335 /* If the buffer has overlays, text properties,
336 or multibyte characters, use a more general algorithm. */
337 if (buffer_intervals (current_buffer
)
338 || buffer_has_overlays ()
340 return current_column_1 ();
342 /* Scan backwards from point to the previous newline,
343 counting width. Tab characters are the only complicated case. */
345 /* Make a pointer for decrementing through the chars before point. */
346 ptr
= BYTE_POS_ADDR (PT_BYTE
- 1) + 1;
347 /* Make a pointer to where consecutive chars leave off,
348 going backwards from point. */
351 else if (PT
<= GPT
|| BEGV
> GPT
)
356 col
= 0, tab_seen
= 0, post_tab
= 0;
365 /* We stopped either for the beginning of the buffer
367 if (ptr
== BEGV_ADDR
)
370 /* It was the gap. Jump back over it. */
374 /* Check whether that brings us to beginning of buffer. */
381 if (dp
&& VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
383 charvec
= DISP_CHAR_VECTOR (dp
, c
);
392 for (i
= n
- 1; i
>= 0; --i
)
394 if (VECTORP (charvec
))
396 /* This should be handled the same as
397 next_element_from_display_vector does it. */
398 Lisp_Object entry
= AREF (charvec
, i
);
400 if (GLYPH_CODE_P (entry
))
401 c
= GLYPH_CODE_CHAR (entry
);
406 if (c
>= 040 && c
< 0177)
410 && EQ (BVAR (current_buffer
, selective_display
), Qt
)))
413 goto start_of_line_found
;
418 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
424 else if (VECTORP (charvec
))
425 /* With a display table entry, C is displayed as is, and
426 not displayed as \NNN or as ^N. If C is a single-byte
427 character, it takes one column. If C is multi-byte in
428 an unibyte buffer, it's translated to unibyte, so it
429 also takes one column. */
432 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
440 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
444 if (ptr
== BEGV_ADDR
)
445 current_column_bol_cache
= BEGV
;
447 current_column_bol_cache
= BYTE_TO_CHAR (PTR_BYTE_POS (ptr
));
449 last_known_column
= col
;
450 last_known_column_point
= PT
;
451 last_known_column_modified
= MODIFF
;
457 /* Check the presence of a display property and compute its width.
458 If a property was found and its width was found as well, return
459 its width (>= 0) and set the position of the end of the property
461 Otherwise just return -1. */
463 check_display_width (ptrdiff_t pos
, ptrdiff_t col
, ptrdiff_t *endpos
)
465 Lisp_Object val
, overlay
;
467 if (CONSP (val
= get_char_property_and_overlay
468 (make_number (pos
), Qdisplay
, Qnil
, &overlay
))
469 && EQ (Qspace
, XCAR (val
)))
470 { /* FIXME: Use calc_pixel_width_or_height. */
471 Lisp_Object plist
= XCDR (val
), prop
;
473 EMACS_INT align_to_max
=
474 (col
< MOST_POSITIVE_FIXNUM
- INT_MAX
475 ? (EMACS_INT
) INT_MAX
+ col
476 : MOST_POSITIVE_FIXNUM
);
478 if ((prop
= Fplist_get (plist
, QCwidth
),
479 RANGED_INTEGERP (0, prop
, INT_MAX
)))
481 else if (FLOATP (prop
) && 0 <= XFLOAT_DATA (prop
)
482 && XFLOAT_DATA (prop
) <= INT_MAX
)
483 width
= (int)(XFLOAT_DATA (prop
) + 0.5);
484 else if ((prop
= Fplist_get (plist
, QCalign_to
),
485 RANGED_INTEGERP (col
, prop
, align_to_max
)))
486 width
= XINT (prop
) - col
;
487 else if (FLOATP (prop
) && col
<= XFLOAT_DATA (prop
)
488 && (XFLOAT_DATA (prop
) <= align_to_max
))
489 width
= (int)(XFLOAT_DATA (prop
) + 0.5) - col
;
494 if (OVERLAYP (overlay
))
495 *endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
497 get_property_and_range (pos
, Qdisplay
, &val
, &start
, endpos
, Qnil
);
504 /* Scanning from the beginning of the current line, stop at the buffer
505 position ENDPOS or at the column GOALCOL or at the end of line, whichever
507 Return the resulting buffer position and column in ENDPOS and GOALCOL.
508 PREVCOL gets set to the column of the previous position (it's always
509 strictly smaller than the goal column). */
511 scan_for_column (ptrdiff_t *endpos
, EMACS_INT
*goalcol
, ptrdiff_t *prevcol
)
513 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
514 bool ctl_arrow
= !NILP (BVAR (current_buffer
, ctl_arrow
));
515 struct Lisp_Char_Table
*dp
= buffer_display_table ();
516 bool multibyte
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
517 struct composition_it cmp_it
;
521 /* Start the scan at the beginning of this line with column number 0. */
522 register ptrdiff_t col
= 0, prev_col
= 0;
523 EMACS_INT goal
= goalcol
? *goalcol
: MOST_POSITIVE_FIXNUM
;
524 ptrdiff_t end
= endpos
? *endpos
: PT
;
525 ptrdiff_t scan
, scan_byte
;
526 ptrdiff_t next_boundary
;
528 ptrdiff_t opoint
= PT
, opoint_byte
= PT_BYTE
;
529 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
530 current_column_bol_cache
= PT
;
531 scan
= PT
, scan_byte
= PT_BYTE
;
532 SET_PT_BOTH (opoint
, opoint_byte
);
533 next_boundary
= scan
;
536 window
= Fget_buffer_window (Fcurrent_buffer (), Qnil
);
537 w
= ! NILP (window
) ? XWINDOW (window
) : NULL
;
539 memset (&cmp_it
, 0, sizeof cmp_it
);
541 composition_compute_stop_pos (&cmp_it
, scan
, scan_byte
, end
, Qnil
);
543 /* Scan forward to the target position. */
548 /* Occasionally we may need to skip invisible text. */
549 while (scan
== next_boundary
)
551 ptrdiff_t old_scan
= scan
;
552 /* This updates NEXT_BOUNDARY to the next place
553 where we might need to skip more invisible text. */
554 scan
= skip_invisible (scan
, &next_boundary
, end
, Qnil
);
555 if (scan
!= old_scan
)
556 scan_byte
= CHAR_TO_BYTE (scan
);
561 /* Test reaching the goal column. We do this after skipping
562 invisible characters, so that we put point before the
563 character on which the cursor will appear. */
568 { /* Check display property. */
570 int width
= check_display_width (scan
, col
, &endp
);
574 if (endp
> scan
) /* Avoid infinite loops with 0-width overlays. */
576 scan
= endp
; scan_byte
= charpos_to_bytepos (scan
);
582 /* Check composition sequence. */
584 || (scan
== cmp_it
.stop_pos
585 && composition_reseat_it (&cmp_it
, scan
, scan_byte
, end
,
587 composition_update_it (&cmp_it
, scan
, scan_byte
, Qnil
);
590 scan
+= cmp_it
.nchars
;
591 scan_byte
+= cmp_it
.nbytes
;
594 if (cmp_it
.to
== cmp_it
.nglyphs
)
597 composition_compute_stop_pos (&cmp_it
, scan
, scan_byte
, end
,
601 cmp_it
.from
= cmp_it
.to
;
605 c
= FETCH_BYTE (scan_byte
);
607 /* See if there is a display table and it relates
608 to this character. */
611 && ! (multibyte
&& LEADING_CODE_P (c
))
612 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
617 /* This character is displayed using a vector of glyphs.
618 Update the column/position based on those glyphs. */
620 charvec
= DISP_CHAR_VECTOR (dp
, c
);
623 for (i
= 0; i
< n
; i
++)
625 /* This should be handled the same as
626 next_element_from_display_vector does it. */
627 Lisp_Object entry
= AREF (charvec
, i
);
629 if (GLYPH_CODE_P (entry
))
630 c
= GLYPH_CODE_CHAR (entry
);
636 if (c
== '\r' && EQ (BVAR (current_buffer
, selective_display
), Qt
))
641 col
= col
/ tab_width
* tab_width
;
649 /* The display table doesn't affect this character;
650 it displays as itself. */
654 if (c
== '\r' && EQ (BVAR (current_buffer
, selective_display
), Qt
))
659 col
= col
/ tab_width
* tab_width
;
661 else if (multibyte
&& LEADING_CODE_P (c
))
663 /* Start of multi-byte form. */
667 ptr
= BYTE_POS_ADDR (scan_byte
);
668 MULTIBYTE_BYTES_WIDTH (ptr
, dp
, bytes
, width
);
669 /* Subtract one to compensate for the increment
670 that is going to happen below. */
671 scan_byte
+= bytes
- 1;
674 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
676 else if (c
< 040 || c
>= 0177)
687 last_known_column
= col
;
688 last_known_column_point
= PT
;
689 last_known_column_modified
= MODIFF
;
699 /* Return the column number of position POS
700 by scanning forward from the beginning of the line.
701 This function handles characters that are invisible
702 due to text properties or overlays. */
705 current_column_1 (void)
707 EMACS_INT col
= MOST_POSITIVE_FIXNUM
;
708 ptrdiff_t opoint
= PT
;
710 scan_for_column (&opoint
, &col
, NULL
);
715 #if 0 /* Not used. */
717 /* Return the width in columns of the part of STRING from BEG to END.
718 If BEG is nil, that stands for the beginning of STRING.
719 If END is nil, that stands for the end of STRING. */
722 string_display_width (Lisp_Object string
, Lisp_Object beg
, Lisp_Object end
)
725 unsigned char *ptr
, *stop
;
729 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
730 bool ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
731 struct Lisp_Char_Table
*dp
= buffer_display_table ();
750 /* Make a pointer for decrementing through the chars before point. */
751 ptr
= SDATA (string
) + e
;
752 /* Make a pointer to where consecutive chars leave off,
753 going backwards from point. */
754 stop
= SDATA (string
) + b
;
756 col
= 0, tab_seen
= 0, post_tab
= 0;
764 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
765 col
+= ASIZE (DISP_CHAR_VECTOR (dp
, c
));
766 else if (c
>= 040 && c
< 0177)
773 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
780 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
785 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
795 DEFUN ("indent-to", Findent_to
, Sindent_to
, 1, 2, "NIndent to column: ",
796 doc
: /* Indent from point with tabs and spaces until COLUMN is reached.
797 Optional second argument MINIMUM says always do at least MINIMUM spaces
798 even if that goes past COLUMN; by default, MINIMUM is zero.
800 The return value is COLUMN. */)
801 (Lisp_Object column
, Lisp_Object minimum
)
804 register ptrdiff_t fromcol
;
805 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
807 CHECK_NUMBER (column
);
809 XSETFASTINT (minimum
, 0);
810 CHECK_NUMBER (minimum
);
812 fromcol
= current_column ();
813 mincol
= fromcol
+ XINT (minimum
);
814 if (mincol
< XINT (column
)) mincol
= XINT (column
);
816 if (fromcol
== mincol
)
817 return make_number (mincol
);
819 if (indent_tabs_mode
)
822 XSETFASTINT (n
, mincol
/ tab_width
- fromcol
/ tab_width
);
823 if (XFASTINT (n
) != 0)
825 Finsert_char (make_number ('\t'), n
, Qt
);
827 fromcol
= (mincol
/ tab_width
) * tab_width
;
831 XSETFASTINT (column
, mincol
- fromcol
);
832 Finsert_char (make_number (' '), column
, Qt
);
834 last_known_column
= mincol
;
835 last_known_column_point
= PT
;
836 last_known_column_modified
= MODIFF
;
838 XSETINT (column
, mincol
);
843 DEFUN ("current-indentation", Fcurrent_indentation
, Scurrent_indentation
,
845 doc
: /* Return the indentation of the current line.
846 This is the horizontal position of the character
847 following any initial whitespace. */)
851 ptrdiff_t opoint
= PT
, opoint_byte
= PT_BYTE
;
853 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
855 XSETFASTINT (val
, position_indentation (PT_BYTE
));
856 SET_PT_BOTH (opoint
, opoint_byte
);
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. */
876 /* START records the starting value of P. */
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. */
887 pos_byte
= PTR_BYTE_POS (p
);
888 /* Consider the various reasons STOP might have been set here. */
889 if (pos_byte
== ZV_BYTE
)
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
);
914 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
920 column
+= tab_width
- column
% tab_width
;
923 if (ASCII_BYTE_P (p
[-1])
924 || NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
928 pos_byte
= PTR_BYTE_POS (p
- 1);
929 c
= FETCH_MULTIBYTE_CHAR (pos_byte
);
930 if (CHAR_HAS_CATEGORY (c
, ' '))
934 p
= BYTE_POS_ADDR (pos_byte
);
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
948 indented_beyond_p (ptrdiff_t pos
, ptrdiff_t pos_byte
, EMACS_INT column
)
951 ptrdiff_t opoint
= PT
, opoint_byte
= PT_BYTE
;
953 SET_PT_BOTH (pos
, pos_byte
);
954 while (PT
> BEGV
&& FETCH_BYTE (PT_BYTE
) == '\n')
955 scan_newline (PT
- 1, PT_BYTE
- 1, BEGV
, BEGV_BYTE
, -1, 0);
957 val
= position_indentation (PT_BYTE
);
958 SET_PT_BOTH (opoint
, opoint_byte
);
959 return val
>= column
;
962 DEFUN ("move-to-column", Fmove_to_column
, Smove_to_column
, 1, 2,
964 doc
: /* Move point to column COLUMN in the current line.
965 Interactively, COLUMN is the value of prefix numeric argument.
966 The column of a character is calculated by adding together the widths
967 as displayed of the previous characters in the line.
968 This function ignores line-continuation;
969 there is no upper limit on the column number a character can have
970 and horizontal scrolling has no effect.
972 If specified column is within a character, point goes after that character.
973 If it's past end of line, point goes to end of line.
975 Optional second argument FORCE non-nil means if COLUMN is in the
976 middle of a tab character, change it to spaces.
977 In addition, if FORCE is t, and the line is too short to reach
978 COLUMN, add spaces/tabs to get there.
980 The return value is the current column. */)
981 (Lisp_Object column
, Lisp_Object force
)
983 ptrdiff_t pos
, prev_col
;
987 CHECK_NATNUM (column
);
988 goal
= XINT (column
);
992 scan_for_column (&pos
, &col
, &prev_col
);
996 /* If a tab char made us overshoot, change it to spaces
997 and scan through it again. */
998 if (!NILP (force
) && col
> goal
)
1001 ptrdiff_t pos_byte
= PT_BYTE
;
1004 c
= FETCH_CHAR (pos_byte
);
1005 if (c
== '\t' && prev_col
< goal
)
1007 ptrdiff_t goal_pt
, goal_pt_byte
;
1009 /* Insert spaces in front of the tab to reach GOAL. Do this
1010 first so that a marker at the end of the tab gets
1012 SET_PT_BOTH (PT
- 1, PT_BYTE
- 1);
1013 Finsert_char (make_number (' '), make_number (goal
- prev_col
), Qt
);
1015 /* Now delete the tab, and indent to COL. */
1016 del_range (PT
, PT
+ 1);
1018 goal_pt_byte
= PT_BYTE
;
1019 Findent_to (make_number (col
), Qnil
);
1020 SET_PT_BOTH (goal_pt
, goal_pt_byte
);
1022 /* Set the last_known... vars consistently. */
1027 /* If line ends prematurely, add space to the end. */
1028 if (col
< goal
&& EQ (force
, Qt
))
1029 Findent_to (make_number (col
= goal
), Qnil
);
1031 last_known_column
= col
;
1032 last_known_column_point
= PT
;
1033 last_known_column_modified
= MODIFF
;
1035 return make_number (col
);
1038 /* compute_motion: compute buffer posn given screen posn and vice versa */
1040 static struct position val_compute_motion
;
1042 /* Scan the current buffer forward from offset FROM, pretending that
1043 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
1044 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
1045 and return the ending buffer position and screen location. If we
1046 can't hit the requested column exactly (because of a tab or other
1047 multi-column character), overshoot.
1049 DID_MOTION is true if FROMHPOS has already accounted for overlay strings
1050 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
1051 earlier call to compute_motion. The other common case is that FROMHPOS
1052 is zero and FROM is a position that "belongs" at column zero, but might
1053 be shifted by overlay strings; in this case DID_MOTION should be false.
1055 WIDTH is the number of columns available to display text;
1056 compute_motion uses this to handle continuation lines and such.
1057 If WIDTH is -1, use width of window's text area adjusted for
1058 continuation glyph when needed.
1060 HSCROLL is the number of columns not being displayed at the left
1061 margin; this is usually taken from a window's hscroll member.
1062 TAB_OFFSET is the number of columns of the first tab that aren't
1063 being displayed, perhaps because of a continuation line or
1066 compute_motion returns a pointer to a struct position. The bufpos
1067 member gives the buffer position at the end of the scan, and hpos
1068 and vpos give its cartesian location. prevhpos is the column at
1069 which the character before bufpos started, and contin is non-zero
1070 if we reached the current line by continuing the previous.
1072 Note that FROMHPOS and TOHPOS should be expressed in real screen
1073 columns, taking HSCROLL and the truncation glyph at the left margin
1074 into account. That is, beginning-of-line moves you to the hpos
1075 -HSCROLL + (HSCROLL > 0).
1077 For example, to find the buffer position of column COL of line LINE
1078 of a certain window, pass the window's starting location as FROM
1079 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
1080 Pass the buffer's ZV as TO, to limit the scan to the end of the
1081 visible section of the buffer, and pass LINE and COL as TOVPOS and
1084 When displaying in window w, a typical formula for WIDTH is:
1087 - (has_vertical_scroll_bars
1088 ? WINDOW_CONFIG_SCROLL_BAR_COLS (window)
1089 : (window_width + window_left != frame_cols))
1092 window_width is XFASTINT (w->total_cols),
1093 window_left is XFASTINT (w->left_col),
1094 has_vertical_scroll_bars is
1095 WINDOW_HAS_VERTICAL_SCROLL_BAR (window)
1096 and frame_cols = FRAME_COLS (XFRAME (window->frame))
1098 Or you can let window_body_cols do this all for you, and write:
1099 window_body_cols (w) - 1
1101 The `-1' accounts for the continuation-line backslashes; the rest
1102 accounts for window borders if the window is split horizontally, and
1103 the scroll bars if they are turned on. */
1106 compute_motion (ptrdiff_t from
, EMACS_INT fromvpos
, EMACS_INT fromhpos
,
1107 bool did_motion
, ptrdiff_t to
,
1108 EMACS_INT tovpos
, EMACS_INT tohpos
, EMACS_INT width
,
1109 ptrdiff_t hscroll
, int tab_offset
, struct window
*win
)
1111 EMACS_INT hpos
= fromhpos
;
1112 EMACS_INT vpos
= fromvpos
;
1117 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
1118 bool ctl_arrow
= !NILP (BVAR (current_buffer
, ctl_arrow
));
1119 struct Lisp_Char_Table
*dp
= window_display_table (win
);
1121 = (INTEGERP (BVAR (current_buffer
, selective_display
))
1122 ? XINT (BVAR (current_buffer
, selective_display
))
1123 : !NILP (BVAR (current_buffer
, selective_display
)) ? -1 : 0);
1124 ptrdiff_t selective_rlen
1125 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
1126 ? ASIZE (DISP_INVIS_VECTOR (dp
)) : 0);
1127 /* The next location where the `invisible' property changes, or an
1128 overlay starts or ends. */
1129 ptrdiff_t next_boundary
= from
;
1131 /* For computing runs of characters with similar widths.
1132 Invariant: width_run_width is zero, or all the characters
1133 from width_run_start to width_run_end have a fixed width of
1135 ptrdiff_t width_run_start
= from
;
1136 ptrdiff_t width_run_end
= from
;
1137 ptrdiff_t width_run_width
= 0;
1138 Lisp_Object
*width_table
;
1140 /* The next buffer pos where we should consult the width run cache. */
1141 ptrdiff_t next_width_run
= from
;
1144 bool multibyte
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
1145 /* If previous char scanned was a wide character,
1146 this is the column where it ended. Otherwise, this is 0. */
1147 EMACS_INT wide_column_end_hpos
= 0;
1148 ptrdiff_t prev_pos
; /* Previous buffer position. */
1149 ptrdiff_t prev_pos_byte
; /* Previous buffer position. */
1150 EMACS_INT prev_hpos
= 0;
1151 EMACS_INT prev_vpos
= 0;
1152 EMACS_INT contin_hpos
; /* HPOS of last column of continued line. */
1153 int prev_tab_offset
; /* Previous tab offset. */
1154 int continuation_glyph_width
;
1156 struct composition_it cmp_it
;
1158 XSETWINDOW (window
, win
);
1160 width_run_cache_on_off ();
1161 if (dp
== buffer_display_table ())
1162 width_table
= (VECTORP (BVAR (current_buffer
, width_table
))
1163 ? XVECTOR (BVAR (current_buffer
, width_table
))->contents
1166 /* If the window has its own display table, we can't use the width
1167 run cache, because that's based on the buffer's display table. */
1170 /* Negative width means use all available text columns. */
1173 width
= window_body_cols (win
);
1174 /* We must make room for continuation marks if we don't have fringes. */
1175 #ifdef HAVE_WINDOW_SYSTEM
1176 if (!FRAME_WINDOW_P (XFRAME (win
->frame
)))
1181 continuation_glyph_width
= 1;
1182 #ifdef HAVE_WINDOW_SYSTEM
1183 if (FRAME_WINDOW_P (XFRAME (win
->frame
)))
1184 continuation_glyph_width
= 0; /* In the fringe. */
1190 pos
= prev_pos
= from
;
1191 pos_byte
= prev_pos_byte
= CHAR_TO_BYTE (from
);
1193 prev_tab_offset
= tab_offset
;
1194 memset (&cmp_it
, 0, sizeof cmp_it
);
1196 composition_compute_stop_pos (&cmp_it
, pos
, pos_byte
, to
, Qnil
);
1200 while (pos
== next_boundary
)
1202 ptrdiff_t pos_here
= pos
;
1205 /* Don't skip invisible if we are already at the margin. */
1206 if (vpos
> tovpos
|| (vpos
== tovpos
&& hpos
>= tohpos
))
1208 if (contin_hpos
&& prev_hpos
== 0
1210 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1211 { /* Line breaks because we can't put the character at the
1212 previous line any more. It is not the multi-column
1213 character continued in middle. Go back to previous
1214 buffer position, screen position, and set tab offset
1215 to previous value. It's the beginning of the
1218 pos_byte
= prev_pos_byte
;
1221 tab_offset
= prev_tab_offset
;
1226 /* If the caller says that the screen position came from an earlier
1227 call to compute_motion, then we've already accounted for the
1228 overlay strings at point. This is only true the first time
1229 through, so clear the flag after testing it. */
1231 /* We need to skip past the overlay strings. Currently those
1232 strings must not contain TAB;
1233 if we want to relax that restriction, something will have
1234 to be changed here. */
1236 unsigned char *ovstr
;
1237 ptrdiff_t ovlen
= overlay_strings (pos
, win
, &ovstr
);
1238 hpos
+= ((multibyte
&& ovlen
> 0)
1239 ? strwidth ((char *) ovstr
, ovlen
) : ovlen
);
1246 /* Advance POS past invisible characters
1247 (but not necessarily all that there are here),
1248 and store in next_boundary the next position where
1249 we need to call skip_invisible. */
1250 newpos
= skip_invisible (pos
, &next_boundary
, to
, window
);
1254 pos
= min (to
, newpos
);
1255 pos_byte
= CHAR_TO_BYTE (pos
);
1259 if (newpos
!= pos_here
)
1262 pos_byte
= CHAR_TO_BYTE (pos
);
1266 /* Handle right margin. */
1267 /* Note on a wide-column character.
1269 Characters are classified into the following three categories
1270 according to the width (columns occupied on screen).
1272 (1) single-column character: ex. `a'
1273 (2) multi-column character: ex. `^A', TAB, `\033'
1274 (3) wide-column character: ex. Japanese character, Chinese character
1275 (In the following example, `W_' stands for them.)
1277 Multi-column characters can be divided around the right margin,
1278 but wide-column characters cannot.
1282 (*) The cursor is placed on the next character after the point.
1286 j ^---- next after the point
1287 ^--- next char. after the point.
1289 In case of sigle-column character
1293 033 ^---- next after the point, next char. after the point.
1295 In case of multi-column character
1299 W_ ^---- next after the point
1300 ^---- next char. after the point.
1302 In case of wide-column character
1304 The problem here is continuation at a wide-column character.
1305 In this case, the line may shorter less than WIDTH.
1306 And we find the continuation AFTER it occurs.
1312 EMACS_INT total_width
= width
+ continuation_glyph_width
;
1315 if (!NILP (Vtruncate_partial_width_windows
)
1316 && (total_width
< FRAME_COLS (XFRAME (WINDOW_FRAME (win
)))))
1318 if (INTEGERP (Vtruncate_partial_width_windows
))
1320 = total_width
< XFASTINT (Vtruncate_partial_width_windows
);
1325 if (hscroll
|| truncate
1326 || !NILP (BVAR (current_buffer
, truncate_lines
)))
1328 /* Truncating: skip to newline, unless we are already past
1329 TO (we need to go back below). */
1332 pos
= find_before_next_newline (pos
, to
, 1);
1333 pos_byte
= CHAR_TO_BYTE (pos
);
1335 /* If we just skipped next_boundary,
1336 loop around in the main while
1338 if (pos
>= next_boundary
)
1339 next_boundary
= pos
+ 1;
1342 prev_tab_offset
= tab_offset
;
1348 /* Remember the previous value. */
1349 prev_tab_offset
= tab_offset
;
1351 if (wide_column_end_hpos
> width
)
1354 tab_offset
+= prev_hpos
;
1358 tab_offset
+= width
;
1362 contin_hpos
= prev_hpos
;
1368 /* Stop if past the target buffer position or screen position. */
1371 /* Go back to the previous position. */
1373 pos_byte
= prev_pos_byte
;
1376 tab_offset
= prev_tab_offset
;
1378 /* NOTE on contin_hpos, hpos, and prev_hpos.
1382 W_ ^---- contin_hpos
1388 if (contin_hpos
&& prev_hpos
== 0
1389 && contin_hpos
< width
&& !wide_column_end_hpos
)
1391 /* Line breaking occurs in the middle of multi-column
1392 character. Go back to previous line. */
1399 if (vpos
> tovpos
|| (vpos
== tovpos
&& hpos
>= tohpos
))
1401 if (contin_hpos
&& prev_hpos
== 0
1403 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1404 { /* Line breaks because we can't put the character at the
1405 previous line any more. It is not the multi-column
1406 character continued in middle. Go back to previous
1407 buffer position, screen position, and set tab offset
1408 to previous value. It's the beginning of the
1411 pos_byte
= prev_pos_byte
;
1414 tab_offset
= prev_tab_offset
;
1418 if (pos
== ZV
) /* We cannot go beyond ZV. Stop here. */
1424 prev_pos_byte
= pos_byte
;
1425 wide_column_end_hpos
= 0;
1427 /* Consult the width run cache to see if we can avoid inspecting
1428 the text character-by-character. */
1429 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
1433 = region_cache_forward (current_buffer
,
1434 current_buffer
->width_run_cache
,
1437 /* A width of zero means the character's width varies (like
1438 a tab), is meaningless (like a newline), or we just don't
1439 want to skip over it for some other reason. */
1440 if (common_width
!= 0)
1442 ptrdiff_t run_end_hpos
;
1444 /* Don't go past the final buffer posn the user
1449 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1451 /* Don't go past the final horizontal position the user
1453 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
1455 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
1456 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1459 /* Don't go past the margin. */
1460 if (run_end_hpos
>= width
)
1462 run_end
= pos
+ (width
- hpos
) / common_width
;
1463 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1466 hpos
= run_end_hpos
;
1468 prev_hpos
= hpos
- common_width
;
1472 pos_byte
= CHAR_TO_BYTE (pos
);
1476 next_width_run
= run_end
+ 1;
1479 /* We have to scan the text character-by-character. */
1483 Lisp_Object charvec
;
1485 /* Check composition sequence. */
1487 || (pos
== cmp_it
.stop_pos
1488 && composition_reseat_it (&cmp_it
, pos
, pos_byte
, to
, win
,
1490 composition_update_it (&cmp_it
, pos
, pos_byte
, Qnil
);
1493 pos
+= cmp_it
.nchars
;
1494 pos_byte
+= cmp_it
.nbytes
;
1495 hpos
+= cmp_it
.width
;
1496 if (cmp_it
.to
== cmp_it
.nglyphs
)
1499 composition_compute_stop_pos (&cmp_it
, pos
, pos_byte
, to
,
1503 cmp_it
.from
= cmp_it
.to
;
1507 c
= FETCH_BYTE (pos_byte
);
1510 /* Perhaps add some info to the width_run_cache. */
1511 if (current_buffer
->width_run_cache
)
1513 /* Is this character part of the current run? If so, extend
1515 if (pos
- 1 == width_run_end
1516 && XFASTINT (width_table
[c
]) == width_run_width
)
1517 width_run_end
= pos
;
1519 /* The previous run is over, since this is a character at a
1520 different position, or a different width. */
1523 /* Have we accumulated a run to put in the cache?
1524 (Currently, we only cache runs of width == 1). */
1525 if (width_run_start
< width_run_end
1526 && width_run_width
== 1)
1527 know_region_cache (current_buffer
,
1528 current_buffer
->width_run_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
;
1539 && ! (multibyte
&& LEADING_CODE_P (c
))
1540 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1542 charvec
= DISP_CHAR_VECTOR (dp
, c
);
1543 n
= ASIZE (charvec
);
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
);
1565 if (c
>= 040 && c
< 0177)
1569 int tem
= ((hpos
+ tab_offset
+ hscroll
- (hscroll
> 0))
1573 hpos
+= tab_width
- tem
;
1578 && indented_beyond_p (pos
, pos_byte
, selective
))
1580 /* If (pos == to), we don't have to take care of
1581 selective display. */
1584 /* Skip any number of invisible lines all at once */
1587 pos
= find_before_next_newline (pos
, to
, 1);
1590 pos_byte
= CHAR_TO_BYTE (pos
);
1593 && indented_beyond_p (pos
, pos_byte
,
1595 /* Allow for the " ..." that is displayed for them. */
1598 hpos
+= selective_rlen
;
1602 DEC_BOTH (pos
, pos_byte
);
1603 /* We have skipped the invis text, but not the
1609 /* A visible line. */
1613 /* Count the truncation glyph on column 0 */
1615 hpos
+= continuation_glyph_width
;
1620 else if (c
== CR
&& selective
< 0)
1622 /* In selective display mode,
1623 everything from a ^M to the end of the line is invisible.
1624 Stop *before* the real newline. */
1627 pos
= find_before_next_newline (pos
, to
, 1);
1628 pos_byte
= CHAR_TO_BYTE (pos
);
1630 /* If we just skipped next_boundary,
1631 loop around in the main while
1633 if (pos
> next_boundary
)
1634 next_boundary
= pos
;
1635 /* Allow for the " ..." that is displayed for them. */
1638 hpos
+= selective_rlen
;
1643 else if (multibyte
&& LEADING_CODE_P (c
))
1645 /* Start of multi-byte form. */
1647 int mb_bytes
, mb_width
;
1649 pos_byte
--; /* rewind POS_BYTE */
1650 ptr
= BYTE_POS_ADDR (pos_byte
);
1651 MULTIBYTE_BYTES_WIDTH (ptr
, dp
, mb_bytes
, mb_width
);
1652 pos_byte
+= mb_bytes
;
1653 if (mb_width
> 1 && BYTES_BY_CHAR_HEAD (*ptr
) == mb_bytes
)
1654 wide_column_end_hpos
= hpos
+ mb_width
;
1657 else if (VECTORP (charvec
))
1660 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
1667 /* Remember any final width run in the cache. */
1668 if (current_buffer
->width_run_cache
1669 && width_run_width
== 1
1670 && width_run_start
< width_run_end
)
1671 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
1672 width_run_start
, width_run_end
);
1674 val_compute_motion
.bufpos
= pos
;
1675 val_compute_motion
.bytepos
= pos_byte
;
1676 val_compute_motion
.hpos
= hpos
;
1677 val_compute_motion
.vpos
= vpos
;
1678 if (contin_hpos
&& prev_hpos
== 0)
1679 val_compute_motion
.prevhpos
= contin_hpos
;
1681 val_compute_motion
.prevhpos
= prev_hpos
;
1683 /* Nonzero if have just continued a line */
1684 val_compute_motion
.contin
= (contin_hpos
&& prev_hpos
== 0);
1687 return &val_compute_motion
;
1691 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
1692 doc
: /* Scan through the current buffer, calculating screen position.
1693 Scan the current buffer forward from offset FROM,
1694 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--
1695 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--
1696 and return the ending buffer position and screen location.
1698 If TOPOS is nil, the actual width and height of the window's
1701 There are three additional arguments:
1703 WIDTH is the number of columns available to display text;
1704 this affects handling of continuation lines. A value of nil
1705 corresponds to the actual number of available text columns.
1707 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).
1708 HSCROLL is the number of columns not being displayed at the left
1709 margin; this is usually taken from a window's hscroll member.
1710 TAB-OFFSET is the number of columns of the first tab that aren't
1711 being displayed, perhaps because the line was continued within it.
1712 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.
1714 WINDOW is the window to operate on. It is used to choose the display table;
1715 if it is showing the current buffer, it is used also for
1716 deciding which overlay properties apply.
1717 Note that `compute-motion' always operates on the current buffer.
1719 The value is a list of five elements:
1720 (POS HPOS VPOS PREVHPOS CONTIN)
1721 POS is the buffer position where the scan stopped.
1722 VPOS is the vertical position where the scan stopped.
1723 HPOS is the horizontal position where the scan stopped.
1725 PREVHPOS is the horizontal position one character back from POS.
1726 CONTIN is t if a line was continued after (or within) the previous character.
1728 For example, to find the buffer position of column COL of line LINE
1729 of a certain window, pass the window's starting location as FROM
1730 and the window's upper-left coordinates as FROMPOS.
1731 Pass the buffer's (point-max) as TO, to limit the scan to the end of the
1732 visible section of the buffer, and pass LINE and COL as TOPOS. */)
1733 (Lisp_Object from
, Lisp_Object frompos
, Lisp_Object to
, Lisp_Object topos
, Lisp_Object width
, Lisp_Object offsets
, Lisp_Object window
)
1736 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
;
1737 struct position
*pos
;
1741 CHECK_NUMBER_COERCE_MARKER (from
);
1742 CHECK_CONS (frompos
);
1743 CHECK_NUMBER_CAR (frompos
);
1744 CHECK_NUMBER_CDR (frompos
);
1745 CHECK_NUMBER_COERCE_MARKER (to
);
1749 CHECK_NUMBER_CAR (topos
);
1750 CHECK_NUMBER_CDR (topos
);
1753 CHECK_NUMBER (width
);
1755 if (!NILP (offsets
))
1757 CHECK_CONS (offsets
);
1758 CHECK_NUMBER_CAR (offsets
);
1759 CHECK_NUMBER_CDR (offsets
);
1760 if (! (0 <= XINT (XCAR (offsets
)) && XINT (XCAR (offsets
)) <= PTRDIFF_MAX
1761 && 0 <= XINT (XCDR (offsets
)) && XINT (XCDR (offsets
)) <= INT_MAX
))
1762 args_out_of_range (XCAR (offsets
), XCDR (offsets
));
1763 hscroll
= XINT (XCAR (offsets
));
1764 tab_offset
= XINT (XCDR (offsets
));
1767 hscroll
= tab_offset
= 0;
1770 window
= Fselected_window ();
1772 CHECK_LIVE_WINDOW (window
);
1773 w
= XWINDOW (window
);
1775 if (XINT (from
) < BEGV
|| XINT (from
) > ZV
)
1776 args_out_of_range_3 (from
, make_number (BEGV
), make_number (ZV
));
1777 if (XINT (to
) < BEGV
|| XINT (to
) > ZV
)
1778 args_out_of_range_3 (to
, make_number (BEGV
), make_number (ZV
));
1780 pos
= compute_motion (XINT (from
), XINT (XCDR (frompos
)),
1781 XINT (XCAR (frompos
)), 0,
1784 ? window_internal_height (w
)
1785 : XINT (XCDR (topos
))),
1787 ? (window_body_cols (w
)
1789 #ifdef HAVE_WINDOW_SYSTEM
1790 FRAME_WINDOW_P (XFRAME (w
->frame
)) ? 0 :
1793 : XINT (XCAR (topos
))),
1794 (NILP (width
) ? -1 : XINT (width
)),
1795 hscroll
, tab_offset
,
1798 XSETFASTINT (bufpos
, pos
->bufpos
);
1799 XSETINT (hpos
, pos
->hpos
);
1800 XSETINT (vpos
, pos
->vpos
);
1801 XSETINT (prevhpos
, pos
->prevhpos
);
1803 return Fcons (bufpos
,
1807 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
1811 /* Fvertical_motion and vmotion */
1813 static struct position val_vmotion
;
1816 vmotion (register ptrdiff_t from
, register EMACS_INT vtarget
, struct window
*w
)
1818 ptrdiff_t hscroll
= w
->hscroll
;
1819 struct position pos
;
1820 /* vpos is cumulative vertical position, changed as from is changed */
1821 register EMACS_INT vpos
= 0;
1823 register ptrdiff_t first
;
1824 ptrdiff_t from_byte
;
1825 ptrdiff_t lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1827 = (INTEGERP (BVAR (current_buffer
, selective_display
))
1828 ? clip_to_bounds (-1, XINT (BVAR (current_buffer
, selective_display
)),
1830 : !NILP (BVAR (current_buffer
, selective_display
)) ? -1 : 0);
1833 /* This is the object we use for fetching character properties. */
1834 Lisp_Object text_prop_object
;
1836 XSETWINDOW (window
, w
);
1838 /* If the window contains this buffer, use it for getting text properties.
1839 Otherwise use the current buffer as arg for doing that. */
1840 if (EQ (w
->buffer
, Fcurrent_buffer ()))
1841 text_prop_object
= window
;
1843 text_prop_object
= Fcurrent_buffer ();
1845 if (vpos
>= vtarget
)
1847 /* To move upward, go a line at a time until
1848 we have gone at least far enough. */
1852 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1854 Lisp_Object propval
;
1856 prevline
= find_next_newline_no_quit (from
- 1, -1);
1857 while (prevline
> BEGV
1859 && indented_beyond_p (prevline
,
1860 CHAR_TO_BYTE (prevline
),
1862 /* Watch out for newlines with `invisible' property.
1863 When moving upward, check the newline before. */
1864 || (propval
= Fget_char_property (make_number (prevline
- 1),
1867 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1868 prevline
= find_next_newline_no_quit (prevline
- 1, -1);
1869 pos
= *compute_motion (prevline
, 0,
1873 /* Don't care for VPOS... */
1874 1 << (BITS_PER_SHORT
- 1),
1876 1 << (BITS_PER_SHORT
- 1),
1885 /* If we made exactly the desired vertical distance,
1886 or if we hit beginning of buffer,
1887 return point found */
1888 if (vpos
>= vtarget
)
1890 val_vmotion
.bufpos
= from
;
1891 val_vmotion
.bytepos
= CHAR_TO_BYTE (from
);
1892 val_vmotion
.vpos
= vpos
;
1893 val_vmotion
.hpos
= lmargin
;
1894 val_vmotion
.contin
= 0;
1895 val_vmotion
.prevhpos
= 0;
1896 return &val_vmotion
;
1899 /* Otherwise find the correct spot by moving down */
1901 /* Moving downward is simple, but must calculate from beg of line
1902 to determine hpos of starting point */
1903 from_byte
= CHAR_TO_BYTE (from
);
1904 if (from
> BEGV
&& FETCH_BYTE (from_byte
- 1) != '\n')
1906 Lisp_Object propval
;
1908 prevline
= find_next_newline_no_quit (from
, -1);
1909 while (prevline
> BEGV
1911 && indented_beyond_p (prevline
,
1912 CHAR_TO_BYTE (prevline
),
1914 /* Watch out for newlines with `invisible' property.
1915 When moving downward, check the newline after. */
1916 || (propval
= Fget_char_property (make_number (prevline
),
1919 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1920 prevline
= find_next_newline_no_quit (prevline
- 1, -1);
1921 pos
= *compute_motion (prevline
, 0,
1925 /* Don't care for VPOS... */
1926 1 << (BITS_PER_SHORT
- 1),
1928 1 << (BITS_PER_SHORT
- 1),
1940 return compute_motion (from
, vpos
, pos
.hpos
, did_motion
,
1941 ZV
, vtarget
, - (1 << (BITS_PER_SHORT
- 1)),
1947 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
1948 doc
: /* Move point to start of the screen line LINES lines down.
1949 If LINES is negative, this means moving up.
1951 This function is an ordinary cursor motion function
1952 which calculates the new position based on how text would be displayed.
1953 The new position may be the start of a line,
1954 or just the start of a continuation line.
1955 The function returns number of screen lines moved over;
1956 that usually equals LINES, but may be closer to zero
1957 if beginning or end of buffer was reached.
1959 The optional second argument WINDOW specifies the window to use for
1960 parameters such as width, horizontal scrolling, and so on.
1961 The default is to use the selected window's parameters.
1963 LINES can optionally take the form (COLS . LINES), in which case
1964 the motion will not stop at the start of a screen line but on
1965 its column COLS (if such exists on that line, that is).
1967 `vertical-motion' always uses the current buffer,
1968 regardless of which buffer is displayed in WINDOW.
1969 This is consistent with other cursor motion functions
1970 and makes it possible to use `vertical-motion' in any buffer,
1971 whether or not it is currently displayed in some window. */)
1972 (Lisp_Object lines
, Lisp_Object window
)
1977 Lisp_Object old_buffer
;
1978 EMACS_INT old_charpos
IF_LINT (= 0), old_bytepos
IF_LINT (= 0);
1979 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1980 Lisp_Object lcols
= Qnil
;
1981 double cols
IF_LINT (= 0);
1982 void *itdata
= NULL
;
1984 /* Allow LINES to be of the form (HPOS . VPOS) aka (COLUMNS . LINES). */
1985 if (CONSP (lines
) && (NUMBERP (XCAR (lines
))))
1987 lcols
= XCAR (lines
);
1988 cols
= INTEGERP (lcols
) ? (double) XINT (lcols
) : XFLOAT_DATA (lcols
);
1989 lines
= XCDR (lines
);
1992 CHECK_NUMBER (lines
);
1993 if (! NILP (window
))
1994 CHECK_WINDOW (window
);
1996 window
= selected_window
;
1997 w
= XWINDOW (window
);
2000 GCPRO3 (old_buffer
, old_charpos
, old_bytepos
);
2001 if (XBUFFER (w
->buffer
) != current_buffer
)
2003 /* Set the window's buffer temporarily to the current buffer. */
2004 old_buffer
= w
->buffer
;
2005 old_charpos
= XMARKER (w
->pointm
)->charpos
;
2006 old_bytepos
= XMARKER (w
->pointm
)->bytepos
;
2007 wset_buffer (w
, Fcurrent_buffer ());
2008 set_marker_both (w
->pointm
, w
->buffer
,
2009 BUF_PT (current_buffer
), BUF_PT_BYTE (current_buffer
));
2014 struct position pos
;
2015 pos
= *vmotion (PT
, XINT (lines
), w
);
2016 SET_PT_BOTH (pos
.bufpos
, pos
.bytepos
);
2020 ptrdiff_t it_start
, it_overshoot_count
= 0;
2022 bool overshoot_handled
= 0;
2023 bool disp_string_at_start_p
= 0;
2025 itdata
= bidi_shelve_cache ();
2026 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
2027 start_display (&it
, w
, pt
);
2028 first_x
= it
.first_visible_x
;
2029 it_start
= IT_CHARPOS (it
);
2031 /* See comments below for why we calculate this. */
2032 if (it
.cmp_it
.id
>= 0)
2033 it_overshoot_count
= 0;
2034 else if (it
.method
== GET_FROM_STRING
)
2036 const char *s
= SSDATA (it
.string
);
2037 const char *e
= s
+ SBYTES (it
.string
);
2039 disp_string_at_start_p
= it
.string_from_display_prop_p
;
2043 it_overshoot_count
++;
2045 if (!it_overshoot_count
)
2046 it_overshoot_count
= -1;
2049 it_overshoot_count
=
2050 !(it
.method
== GET_FROM_IMAGE
|| it
.method
== GET_FROM_STRETCH
);
2052 /* Scan from the start of the line containing PT. If we don't
2053 do this, we start moving with IT->current_x == 0, while PT is
2054 really at some x > 0. */
2055 reseat_at_previous_visible_line_start (&it
);
2056 it
.current_x
= it
.hpos
= 0;
2057 if (IT_CHARPOS (it
) != PT
)
2058 /* We used to temporarily disable selective display here; the
2059 comment said this is "so we don't move too far" (2005-01-19
2060 checkin by kfs). But this does nothing useful that I can
2061 tell, and it causes Bug#2694 . -- cyd */
2062 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
2064 /* IT may move too far if truncate-lines is on and PT lies
2065 beyond the right margin. IT may also move too far if the
2066 starting point is on a Lisp string that has embedded
2067 newlines, or spans several screen lines. In these cases,
2069 if (IT_CHARPOS (it
) > it_start
)
2071 /* We need to backtrack also if the Lisp string contains no
2072 newlines, but there is a newline right after it. In this
2073 case, IT overshoots if there is an after-string just
2074 before the newline. */
2075 if (it_overshoot_count
< 0
2076 && it
.method
== GET_FROM_BUFFER
2078 it_overshoot_count
= 1;
2079 else if (disp_string_at_start_p
&& it
.vpos
> 0)
2081 /* This is the case of a display string that spans
2082 several screen lines. In that case, we end up at the
2083 end of the string, and it.vpos tells us how many
2084 screen lines we need to backtrack. */
2085 it_overshoot_count
= it
.vpos
;
2087 if (it_overshoot_count
> 0)
2088 move_it_by_lines (&it
, -it_overshoot_count
);
2090 overshoot_handled
= 1;
2092 if (XINT (lines
) <= 0)
2095 /* Do this even if LINES is 0, so that we move back to the
2096 beginning of the current line as we ought. */
2097 if (XINT (lines
) == 0 || IT_CHARPOS (it
) > 0)
2098 move_it_by_lines (&it
, max (PTRDIFF_MIN
, XINT (lines
)));
2100 else if (overshoot_handled
)
2103 move_it_by_lines (&it
, min (PTRDIFF_MAX
, XINT (lines
)));
2107 /* Otherwise, we are at the first row occupied by PT, which
2108 might span multiple screen lines (e.g., if it's on a
2109 multi-line display string). We want to start from the
2110 last line that it occupies. */
2113 while (IT_CHARPOS (it
) <= it_start
)
2116 move_it_by_lines (&it
, 1);
2118 if (XINT (lines
) > 1)
2119 move_it_by_lines (&it
, min (PTRDIFF_MAX
, XINT (lines
) - 1));
2124 move_it_by_lines (&it
, min (PTRDIFF_MAX
, XINT (lines
)));
2128 /* Move to the goal column, if one was specified. */
2131 /* If the window was originally hscrolled, move forward by
2132 the hscrolled amount first. */
2135 move_it_in_display_line (&it
, ZV
, first_x
, MOVE_TO_X
);
2138 move_it_in_display_line
2140 (int)(cols
* FRAME_COLUMN_WIDTH (XFRAME (w
->frame
)) + 0.5),
2144 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
2145 bidi_unshelve_cache (itdata
, 0);
2148 if (BUFFERP (old_buffer
))
2150 wset_buffer (w
, old_buffer
);
2151 set_marker_both (w
->pointm
, w
->buffer
,
2152 old_charpos
, old_bytepos
);
2155 RETURN_UNGCPRO (make_number (it
.vpos
));
2160 /* File's initialization. */
2163 syms_of_indent (void)
2165 DEFVAR_BOOL ("indent-tabs-mode", indent_tabs_mode
,
2166 doc
: /* Indentation can insert tabs if this is non-nil. */);
2167 indent_tabs_mode
= 1;
2169 defsubr (&Scurrent_indentation
);
2170 defsubr (&Sindent_to
);
2171 defsubr (&Scurrent_column
);
2172 defsubr (&Smove_to_column
);
2173 defsubr (&Svertical_motion
);
2174 defsubr (&Scompute_motion
);