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/>. */
25 #include "character.h"
28 #include "composite.h"
36 #include "intervals.h"
37 #include "dispextern.h"
38 #include "region-cache.h"
42 /* These three values memorize the current column to avoid recalculation. */
44 /* Last value returned by current_column.
45 Some things in set last_known_column_point to -1
46 to mark the memorized value as invalid. */
48 static ptrdiff_t last_known_column
;
50 /* Value of point when current_column was called. */
52 ptrdiff_t last_known_column_point
;
54 /* Value of MODIFF when current_column was called. */
56 static EMACS_INT last_known_column_modified
;
58 static ptrdiff_t current_column_1 (void);
59 static ptrdiff_t position_indentation (ptrdiff_t);
61 /* Cache of beginning of line found by the last call of
64 static ptrdiff_t current_column_bol_cache
;
66 /* Get the display table to use for the current buffer. */
68 struct Lisp_Char_Table
*
69 buffer_display_table (void)
73 thisbuf
= BVAR (current_buffer
, display_table
);
74 if (DISP_TABLE_P (thisbuf
))
75 return XCHAR_TABLE (thisbuf
);
76 if (DISP_TABLE_P (Vstandard_display_table
))
77 return XCHAR_TABLE (Vstandard_display_table
);
81 /* Width run cache considerations. */
83 /* Return the width of character C under display table DP. */
86 character_width (int c
, struct Lisp_Char_Table
*dp
)
90 /* These width computations were determined by examining the cases
91 in display_text_line. */
93 /* Everything can be handled by the display table, if it's
94 present and the element is right. */
95 if (dp
&& (elt
= DISP_CHAR_VECTOR (dp
, c
), VECTORP (elt
)))
98 /* Some characters are special. */
99 if (c
== '\n' || c
== '\t' || c
== '\015')
102 /* Printing characters have width 1. */
103 else if (c
>= 040 && c
< 0177)
106 /* Everybody else (control characters, metacharacters) has other
107 widths. We could return their actual widths here, but they
108 depend on things like ctl_arrow and crud like that, and they're
109 not very common at all. So we'll just claim we don't know their
115 /* Return true if the display table DISPTAB specifies the same widths
116 for characters as WIDTHTAB. We use this to decide when to
117 invalidate the buffer's width_run_cache. */
120 disptab_matches_widthtab (struct Lisp_Char_Table
*disptab
, struct Lisp_Vector
*widthtab
)
124 if (widthtab
->header
.size
!= 256)
127 for (i
= 0; i
< 256; i
++)
128 if (character_width (i
, disptab
)
129 != XFASTINT (widthtab
->contents
[i
]))
135 /* Recompute BUF's width table, using the display table DISPTAB. */
138 recompute_width_table (struct buffer
*buf
, struct Lisp_Char_Table
*disptab
)
141 struct Lisp_Vector
*widthtab
;
143 if (!VECTORP (BVAR (buf
, width_table
)))
144 bset_width_table (buf
, Fmake_vector (make_number (256), make_number (0)));
145 widthtab
= XVECTOR (BVAR (buf
, width_table
));
146 if (widthtab
->header
.size
!= 256)
149 for (i
= 0; i
< 256; i
++)
150 XSETFASTINT (widthtab
->contents
[i
], character_width (i
, disptab
));
153 /* Allocate or free the width run cache, as requested by the current
154 state of current_buffer's cache_long_line_scans variable. */
157 width_run_cache_on_off (void)
159 if (NILP (BVAR (current_buffer
, cache_long_line_scans
))
160 /* And, for the moment, this feature doesn't work on multibyte
162 || !NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
164 /* It should be off. */
165 if (current_buffer
->width_run_cache
)
167 free_region_cache (current_buffer
->width_run_cache
);
168 current_buffer
->width_run_cache
= 0;
169 bset_width_table (current_buffer
, Qnil
);
174 /* It should be on. */
175 if (current_buffer
->width_run_cache
== 0)
177 current_buffer
->width_run_cache
= new_region_cache ();
178 recompute_width_table (current_buffer
, buffer_display_table ());
184 /* Skip some invisible characters starting from POS.
185 This includes characters invisible because of text properties
186 and characters invisible because of overlays.
188 If position POS is followed by invisible characters,
189 skip some of them and return the position after them.
190 Otherwise return POS itself.
192 Set *NEXT_BOUNDARY_P to the next position at which
193 it will be necessary to call this function again.
195 Don't scan past TO, and don't set *NEXT_BOUNDARY_P
196 to a value greater than TO.
198 If WINDOW is non-nil, and this buffer is displayed in WINDOW,
199 take account of overlays that apply only in WINDOW.
201 We don't necessarily skip all the invisible characters after POS
202 because that could take a long time. We skip a reasonable number
203 which can be skipped quickly. If there might be more invisible
204 characters immediately following, then *NEXT_BOUNDARY_P
205 will equal the return value. */
208 skip_invisible (ptrdiff_t pos
, ptrdiff_t *next_boundary_p
, ptrdiff_t to
, Lisp_Object window
)
210 Lisp_Object prop
, position
, overlay_limit
, proplimit
;
211 Lisp_Object buffer
, tmp
;
215 XSETFASTINT (position
, pos
);
216 XSETBUFFER (buffer
, current_buffer
);
218 /* Give faster response for overlay lookup near POS. */
219 recenter_overlay_lists (current_buffer
, pos
);
221 /* We must not advance farther than the next overlay change.
222 The overlay change might change the invisible property;
223 or there might be overlay strings to be displayed there. */
224 overlay_limit
= Fnext_overlay_change (position
);
225 /* As for text properties, this gives a lower bound
226 for where the invisible text property could change. */
227 proplimit
= Fnext_property_change (position
, buffer
, Qt
);
228 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
229 proplimit
= overlay_limit
;
230 /* PROPLIMIT is now a lower bound for the next change
231 in invisible status. If that is plenty far away,
232 use that lower bound. */
233 if (XFASTINT (proplimit
) > pos
+ 100 || XFASTINT (proplimit
) >= to
)
234 *next_boundary_p
= XFASTINT (proplimit
);
235 /* Otherwise, scan for the next `invisible' property change. */
238 /* Don't scan terribly far. */
239 XSETFASTINT (proplimit
, min (pos
+ 100, to
));
240 /* No matter what, don't go past next overlay change. */
241 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
242 proplimit
= overlay_limit
;
243 tmp
= Fnext_single_property_change (position
, Qinvisible
,
245 end
= XFASTINT (tmp
);
247 /* Don't put the boundary in the middle of multibyte form if
248 there is no actual property change. */
250 && !NILP (current_buffer
->enable_multibyte_characters
)
252 while (pos
< end
&& !CHAR_HEAD_P (POS_ADDR (end
)))
255 *next_boundary_p
= end
;
257 /* if the `invisible' property is set, we can skip to
258 the next property change */
259 prop
= Fget_char_property (position
, Qinvisible
,
261 && EQ (XWINDOW (window
)->buffer
, buffer
))
263 inv_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
264 /* When counting columns (window == nil), don't skip over ellipsis text. */
265 if (NILP (window
) ? inv_p
== 1 : inv_p
)
266 return *next_boundary_p
;
270 /* Set variables WIDTH and BYTES for a multibyte sequence starting at P.
272 DP is a display table or NULL.
274 This macro is used in scan_for_column and in
277 #define MULTIBYTE_BYTES_WIDTH(p, dp, bytes, width) \
281 ch = STRING_CHAR_AND_LENGTH (p, bytes); \
282 if (BYTES_BY_CHAR_HEAD (*p) != bytes) \
286 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, ch))) \
287 width = sanitize_char_width (ASIZE (DISP_CHAR_VECTOR (dp, ch))); \
289 width = CHAR_WIDTH (ch); \
294 DEFUN ("current-column", Fcurrent_column
, Scurrent_column
, 0, 0, 0,
295 doc
: /* Return the horizontal position of point. Beginning of line is column 0.
296 This is calculated by adding together the widths of all the displayed
297 representations of the character between the start of the previous line
298 and point (eg. control characters will have a width of 2 or 4, tabs
299 will have a variable width).
300 Ignores finite width of frame, which means that this function may return
301 values greater than (frame-width).
302 Whether the line is visible (if `selective-display' is t) has no effect;
303 however, ^M is treated as end of line when `selective-display' is t.
304 Text that has an invisible property is considered as having width 0, unless
305 `buffer-invisibility-spec' specifies that it is replaced by an ellipsis. */)
309 XSETFASTINT (temp
, current_column ());
313 /* Cancel any recorded value of the horizontal position. */
316 invalidate_current_column (void)
318 last_known_column_point
= 0;
322 current_column (void)
324 register ptrdiff_t col
;
325 register unsigned char *ptr
, *stop
;
326 register int tab_seen
;
329 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
330 int ctl_arrow
= !NILP (BVAR (current_buffer
, ctl_arrow
));
331 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
333 if (PT
== last_known_column_point
334 && MODIFF
== last_known_column_modified
)
335 return last_known_column
;
337 /* If the buffer has overlays, text properties,
338 or multibyte characters, use a more general algorithm. */
339 if (buffer_intervals (current_buffer
)
340 || buffer_has_overlays ()
342 return current_column_1 ();
344 /* Scan backwards from point to the previous newline,
345 counting width. Tab characters are the only complicated case. */
347 /* Make a pointer for decrementing through the chars before point. */
348 ptr
= BYTE_POS_ADDR (PT_BYTE
- 1) + 1;
349 /* Make a pointer to where consecutive chars leave off,
350 going backwards from point. */
353 else if (PT
<= GPT
|| BEGV
> GPT
)
358 col
= 0, tab_seen
= 0, post_tab
= 0;
367 /* We stopped either for the beginning of the buffer
369 if (ptr
== BEGV_ADDR
)
372 /* It was the gap. Jump back over it. */
376 /* Check whether that brings us to beginning of buffer. */
383 if (dp
&& VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
385 charvec
= DISP_CHAR_VECTOR (dp
, c
);
394 for (i
= n
- 1; i
>= 0; --i
)
396 if (VECTORP (charvec
))
398 /* This should be handled the same as
399 next_element_from_display_vector does it. */
400 Lisp_Object entry
= AREF (charvec
, i
);
402 if (GLYPH_CODE_P (entry
))
403 c
= GLYPH_CODE_CHAR (entry
);
408 if (c
>= 040 && c
< 0177)
412 && EQ (BVAR (current_buffer
, selective_display
), Qt
)))
415 goto start_of_line_found
;
420 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
426 else if (VECTORP (charvec
))
427 /* With a display table entry, C is displayed as is, and
428 not displayed as \NNN or as ^N. If C is a single-byte
429 character, it takes one column. If C is multi-byte in
430 an unibyte buffer, it's translated to unibyte, so it
431 also takes one column. */
434 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
442 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
446 if (ptr
== BEGV_ADDR
)
447 current_column_bol_cache
= BEGV
;
449 current_column_bol_cache
= BYTE_TO_CHAR (PTR_BYTE_POS (ptr
));
451 last_known_column
= col
;
452 last_known_column_point
= PT
;
453 last_known_column_modified
= MODIFF
;
459 /* Check the presence of a display property and compute its width.
460 If a property was found and its width was found as well, return
461 its width (>= 0) and set the position of the end of the property
463 Otherwise just return -1. */
465 check_display_width (ptrdiff_t pos
, ptrdiff_t col
, ptrdiff_t *endpos
)
467 Lisp_Object val
, overlay
;
469 if (CONSP (val
= get_char_property_and_overlay
470 (make_number (pos
), Qdisplay
, Qnil
, &overlay
))
471 && EQ (Qspace
, XCAR (val
)))
472 { /* FIXME: Use calc_pixel_width_or_height. */
473 Lisp_Object plist
= XCDR (val
), prop
;
475 EMACS_INT align_to_max
=
476 (col
< MOST_POSITIVE_FIXNUM
- INT_MAX
477 ? (EMACS_INT
) INT_MAX
+ col
478 : MOST_POSITIVE_FIXNUM
);
480 if ((prop
= Fplist_get (plist
, QCwidth
),
481 RANGED_INTEGERP (0, prop
, INT_MAX
)))
483 else if (FLOATP (prop
) && 0 <= XFLOAT_DATA (prop
)
484 && XFLOAT_DATA (prop
) <= INT_MAX
)
485 width
= (int)(XFLOAT_DATA (prop
) + 0.5);
486 else if ((prop
= Fplist_get (plist
, QCalign_to
),
487 RANGED_INTEGERP (col
, prop
, align_to_max
)))
488 width
= XINT (prop
) - col
;
489 else if (FLOATP (prop
) && col
<= XFLOAT_DATA (prop
)
490 && (XFLOAT_DATA (prop
) <= align_to_max
))
491 width
= (int)(XFLOAT_DATA (prop
) + 0.5) - col
;
496 if (OVERLAYP (overlay
))
497 *endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
499 get_property_and_range (pos
, Qdisplay
, &val
, &start
, endpos
, Qnil
);
506 /* Scanning from the beginning of the current line, stop at the buffer
507 position ENDPOS or at the column GOALCOL or at the end of line, whichever
509 Return the resulting buffer position and column in ENDPOS and GOALCOL.
510 PREVCOL gets set to the column of the previous position (it's always
511 strictly smaller than the goal column). */
513 scan_for_column (ptrdiff_t *endpos
, EMACS_INT
*goalcol
, ptrdiff_t *prevcol
)
515 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
516 register int ctl_arrow
= !NILP (BVAR (current_buffer
, ctl_arrow
));
517 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
518 int multibyte
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
519 struct composition_it cmp_it
;
523 /* Start the scan at the beginning of this line with column number 0. */
524 register ptrdiff_t col
= 0, prev_col
= 0;
525 EMACS_INT goal
= goalcol
? *goalcol
: MOST_POSITIVE_FIXNUM
;
526 ptrdiff_t end
= endpos
? *endpos
: PT
;
527 ptrdiff_t scan
, scan_byte
;
528 ptrdiff_t next_boundary
;
530 ptrdiff_t opoint
= PT
, opoint_byte
= PT_BYTE
;
531 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
532 current_column_bol_cache
= PT
;
533 scan
= PT
, scan_byte
= PT_BYTE
;
534 SET_PT_BOTH (opoint
, opoint_byte
);
535 next_boundary
= scan
;
538 window
= Fget_buffer_window (Fcurrent_buffer (), Qnil
);
539 w
= ! NILP (window
) ? XWINDOW (window
) : NULL
;
541 memset (&cmp_it
, 0, sizeof cmp_it
);
543 composition_compute_stop_pos (&cmp_it
, scan
, scan_byte
, end
, Qnil
);
545 /* Scan forward to the target position. */
550 /* Occasionally we may need to skip invisible text. */
551 while (scan
== next_boundary
)
553 ptrdiff_t old_scan
= scan
;
554 /* This updates NEXT_BOUNDARY to the next place
555 where we might need to skip more invisible text. */
556 scan
= skip_invisible (scan
, &next_boundary
, end
, Qnil
);
557 if (scan
!= old_scan
)
558 scan_byte
= CHAR_TO_BYTE (scan
);
563 /* Test reaching the goal column. We do this after skipping
564 invisible characters, so that we put point before the
565 character on which the cursor will appear. */
570 { /* Check display property. */
572 int width
= check_display_width (scan
, col
, &endp
);
576 if (endp
> scan
) /* Avoid infinite loops with 0-width overlays. */
578 scan
= endp
; scan_byte
= charpos_to_bytepos (scan
);
584 /* Check composition sequence. */
586 || (scan
== cmp_it
.stop_pos
587 && composition_reseat_it (&cmp_it
, scan
, scan_byte
, end
,
589 composition_update_it (&cmp_it
, scan
, scan_byte
, Qnil
);
592 scan
+= cmp_it
.nchars
;
593 scan_byte
+= cmp_it
.nbytes
;
596 if (cmp_it
.to
== cmp_it
.nglyphs
)
599 composition_compute_stop_pos (&cmp_it
, scan
, scan_byte
, end
,
603 cmp_it
.from
= cmp_it
.to
;
607 c
= FETCH_BYTE (scan_byte
);
609 /* See if there is a display table and it relates
610 to this character. */
613 && ! (multibyte
&& LEADING_CODE_P (c
))
614 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
619 /* This character is displayed using a vector of glyphs.
620 Update the column/position based on those glyphs. */
622 charvec
= DISP_CHAR_VECTOR (dp
, c
);
625 for (i
= 0; i
< n
; i
++)
627 /* This should be handled the same as
628 next_element_from_display_vector does it. */
629 Lisp_Object entry
= AREF (charvec
, i
);
631 if (GLYPH_CODE_P (entry
))
632 c
= GLYPH_CODE_CHAR (entry
);
638 if (c
== '\r' && EQ (BVAR (current_buffer
, selective_display
), Qt
))
643 col
= col
/ tab_width
* tab_width
;
651 /* The display table doesn't affect this character;
652 it displays as itself. */
656 if (c
== '\r' && EQ (BVAR (current_buffer
, selective_display
), Qt
))
661 col
= col
/ tab_width
* tab_width
;
663 else if (multibyte
&& LEADING_CODE_P (c
))
665 /* Start of multi-byte form. */
669 ptr
= BYTE_POS_ADDR (scan_byte
);
670 MULTIBYTE_BYTES_WIDTH (ptr
, dp
, bytes
, width
);
671 /* Subtract one to compensate for the increment
672 that is going to happen below. */
673 scan_byte
+= bytes
- 1;
676 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
678 else if (c
< 040 || c
>= 0177)
689 last_known_column
= col
;
690 last_known_column_point
= PT
;
691 last_known_column_modified
= MODIFF
;
701 /* Return the column number of position POS
702 by scanning forward from the beginning of the line.
703 This function handles characters that are invisible
704 due to text properties or overlays. */
707 current_column_1 (void)
709 EMACS_INT col
= MOST_POSITIVE_FIXNUM
;
710 ptrdiff_t opoint
= PT
;
712 scan_for_column (&opoint
, &col
, NULL
);
717 #if 0 /* Not used. */
719 /* Return the width in columns of the part of STRING from BEG to END.
720 If BEG is nil, that stands for the beginning of STRING.
721 If END is nil, that stands for the end of STRING. */
724 string_display_width (Lisp_Object string
, Lisp_Object beg
, Lisp_Object end
)
727 register unsigned char *ptr
, *stop
;
728 register int tab_seen
;
731 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
732 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
733 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
752 /* Make a pointer for decrementing through the chars before point. */
753 ptr
= SDATA (string
) + e
;
754 /* Make a pointer to where consecutive chars leave off,
755 going backwards from point. */
756 stop
= SDATA (string
) + b
;
758 col
= 0, tab_seen
= 0, post_tab
= 0;
766 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
767 col
+= ASIZE (DISP_CHAR_VECTOR (dp
, c
));
768 else if (c
>= 040 && c
< 0177)
775 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
782 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
787 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
797 DEFUN ("indent-to", Findent_to
, Sindent_to
, 1, 2, "NIndent to column: ",
798 doc
: /* Indent from point with tabs and spaces until COLUMN is reached.
799 Optional second argument MINIMUM says always do at least MINIMUM spaces
800 even if that goes past COLUMN; by default, MINIMUM is zero.
802 The return value is COLUMN. */)
803 (Lisp_Object column
, Lisp_Object minimum
)
806 register ptrdiff_t fromcol
;
807 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
809 CHECK_NUMBER (column
);
811 XSETFASTINT (minimum
, 0);
812 CHECK_NUMBER (minimum
);
814 fromcol
= current_column ();
815 mincol
= fromcol
+ XINT (minimum
);
816 if (mincol
< XINT (column
)) mincol
= XINT (column
);
818 if (fromcol
== mincol
)
819 return make_number (mincol
);
821 if (indent_tabs_mode
)
824 XSETFASTINT (n
, mincol
/ tab_width
- fromcol
/ tab_width
);
825 if (XFASTINT (n
) != 0)
827 Finsert_char (make_number ('\t'), n
, Qt
);
829 fromcol
= (mincol
/ tab_width
) * tab_width
;
833 XSETFASTINT (column
, mincol
- fromcol
);
834 Finsert_char (make_number (' '), column
, Qt
);
836 last_known_column
= mincol
;
837 last_known_column_point
= PT
;
838 last_known_column_modified
= MODIFF
;
840 XSETINT (column
, mincol
);
845 DEFUN ("current-indentation", Fcurrent_indentation
, Scurrent_indentation
,
847 doc
: /* Return the indentation of the current line.
848 This is the horizontal position of the character
849 following any initial whitespace. */)
853 ptrdiff_t opoint
= PT
, opoint_byte
= PT_BYTE
;
855 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
857 XSETFASTINT (val
, position_indentation (PT_BYTE
));
858 SET_PT_BOTH (opoint
, opoint_byte
);
863 position_indentation (ptrdiff_t pos_byte
)
865 register ptrdiff_t column
= 0;
866 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
867 register unsigned char *p
;
868 register unsigned char *stop
;
869 unsigned char *start
;
870 ptrdiff_t next_boundary_byte
= pos_byte
;
871 ptrdiff_t ceiling
= next_boundary_byte
;
873 p
= BYTE_POS_ADDR (pos_byte
);
874 /* STOP records the value of P at which we will need
875 to think about the gap, or about invisible text,
876 or about the end of the buffer. */
878 /* START records the starting value of P. */
884 ptrdiff_t stop_pos_byte
;
886 /* If we have updated P, set POS_BYTE to match.
887 The first time we enter the loop, POS_BYTE is already right. */
889 pos_byte
= PTR_BYTE_POS (p
);
890 /* Consider the various reasons STOP might have been set here. */
891 if (pos_byte
== ZV_BYTE
)
893 if (pos_byte
== next_boundary_byte
)
895 ptrdiff_t next_boundary
;
896 ptrdiff_t pos
= BYTE_TO_CHAR (pos_byte
);
897 pos
= skip_invisible (pos
, &next_boundary
, ZV
, Qnil
);
898 pos_byte
= CHAR_TO_BYTE (pos
);
899 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
901 if (pos_byte
>= ceiling
)
902 ceiling
= BUFFER_CEILING_OF (pos_byte
) + 1;
903 /* Compute the next place we need to stop and think,
904 and set STOP accordingly. */
905 stop_pos_byte
= min (ceiling
, next_boundary_byte
);
906 /* The -1 and +1 arrange to point at the first byte of gap
907 (if STOP_POS_BYTE is the position of the gap)
908 rather than at the data after the gap. */
910 stop
= BYTE_POS_ADDR (stop_pos_byte
- 1) + 1;
911 p
= BYTE_POS_ADDR (pos_byte
);
916 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
922 column
+= tab_width
- column
% tab_width
;
925 if (ASCII_BYTE_P (p
[-1])
926 || NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
930 pos_byte
= PTR_BYTE_POS (p
- 1);
931 c
= FETCH_MULTIBYTE_CHAR (pos_byte
);
932 if (CHAR_HAS_CATEGORY (c
, ' '))
936 p
= BYTE_POS_ADDR (pos_byte
);
945 /* Test whether the line beginning at POS is indented beyond COLUMN.
946 Blank lines are treated as if they had the same indentation as the
950 indented_beyond_p (ptrdiff_t pos
, ptrdiff_t pos_byte
, EMACS_INT column
)
953 ptrdiff_t opoint
= PT
, opoint_byte
= PT_BYTE
;
955 SET_PT_BOTH (pos
, pos_byte
);
956 while (PT
> BEGV
&& FETCH_BYTE (PT_BYTE
) == '\n')
957 scan_newline (PT
- 1, PT_BYTE
- 1, BEGV
, BEGV_BYTE
, -1, 0);
959 val
= position_indentation (PT_BYTE
);
960 SET_PT_BOTH (opoint
, opoint_byte
);
961 return val
>= column
;
964 DEFUN ("move-to-column", Fmove_to_column
, Smove_to_column
, 1, 2,
966 doc
: /* Move point to column COLUMN in the current line.
967 Interactively, COLUMN is the value of prefix numeric argument.
968 The column of a character is calculated by adding together the widths
969 as displayed of the previous characters in the line.
970 This function ignores line-continuation;
971 there is no upper limit on the column number a character can have
972 and horizontal scrolling has no effect.
974 If specified column is within a character, point goes after that character.
975 If it's past end of line, point goes to end of line.
977 Optional second argument FORCE non-nil means if COLUMN is in the
978 middle of a tab character, change it to spaces.
979 In addition, if FORCE is t, and the line is too short to reach
980 COLUMN, add spaces/tabs to get there.
982 The return value is the current column. */)
983 (Lisp_Object column
, Lisp_Object force
)
985 ptrdiff_t pos
, prev_col
;
989 CHECK_NATNUM (column
);
990 goal
= XINT (column
);
994 scan_for_column (&pos
, &col
, &prev_col
);
998 /* If a tab char made us overshoot, change it to spaces
999 and scan through it again. */
1000 if (!NILP (force
) && col
> goal
)
1003 ptrdiff_t pos_byte
= PT_BYTE
;
1006 c
= FETCH_CHAR (pos_byte
);
1007 if (c
== '\t' && prev_col
< goal
)
1009 ptrdiff_t goal_pt
, goal_pt_byte
;
1011 /* Insert spaces in front of the tab to reach GOAL. Do this
1012 first so that a marker at the end of the tab gets
1014 SET_PT_BOTH (PT
- 1, PT_BYTE
- 1);
1015 Finsert_char (make_number (' '), make_number (goal
- prev_col
), Qt
);
1017 /* Now delete the tab, and indent to COL. */
1018 del_range (PT
, PT
+ 1);
1020 goal_pt_byte
= PT_BYTE
;
1021 Findent_to (make_number (col
), Qnil
);
1022 SET_PT_BOTH (goal_pt
, goal_pt_byte
);
1024 /* Set the last_known... vars consistently. */
1029 /* If line ends prematurely, add space to the end. */
1030 if (col
< goal
&& EQ (force
, Qt
))
1031 Findent_to (make_number (col
= goal
), Qnil
);
1033 last_known_column
= col
;
1034 last_known_column_point
= PT
;
1035 last_known_column_modified
= MODIFF
;
1037 return make_number (col
);
1040 /* compute_motion: compute buffer posn given screen posn and vice versa */
1042 static struct position val_compute_motion
;
1044 /* Scan the current buffer forward from offset FROM, pretending that
1045 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
1046 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
1047 and return the ending buffer position and screen location. If we
1048 can't hit the requested column exactly (because of a tab or other
1049 multi-column character), overshoot.
1051 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
1052 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
1053 earlier call to compute_motion. The other common case is that FROMHPOS
1054 is zero and FROM is a position that "belongs" at column zero, but might
1055 be shifted by overlay strings; in this case DID_MOTION should be 0.
1057 WIDTH is the number of columns available to display text;
1058 compute_motion uses this to handle continuation lines and such.
1059 If WIDTH is -1, use width of window's text area adjusted for
1060 continuation glyph when needed.
1062 HSCROLL is the number of columns not being displayed at the left
1063 margin; this is usually taken from a window's hscroll member.
1064 TAB_OFFSET is the number of columns of the first tab that aren't
1065 being displayed, perhaps because of a continuation line or
1068 compute_motion returns a pointer to a struct position. The bufpos
1069 member gives the buffer position at the end of the scan, and hpos
1070 and vpos give its cartesian location. prevhpos is the column at
1071 which the character before bufpos started, and contin is non-zero
1072 if we reached the current line by continuing the previous.
1074 Note that FROMHPOS and TOHPOS should be expressed in real screen
1075 columns, taking HSCROLL and the truncation glyph at the left margin
1076 into account. That is, beginning-of-line moves you to the hpos
1077 -HSCROLL + (HSCROLL > 0).
1079 For example, to find the buffer position of column COL of line LINE
1080 of a certain window, pass the window's starting location as FROM
1081 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
1082 Pass the buffer's ZV as TO, to limit the scan to the end of the
1083 visible section of the buffer, and pass LINE and COL as TOVPOS and
1086 When displaying in window w, a typical formula for WIDTH is:
1089 - (has_vertical_scroll_bars
1090 ? WINDOW_CONFIG_SCROLL_BAR_COLS (window)
1091 : (window_width + window_left != frame_cols))
1094 window_width is XFASTINT (w->total_cols),
1095 window_left is XFASTINT (w->left_col),
1096 has_vertical_scroll_bars is
1097 WINDOW_HAS_VERTICAL_SCROLL_BAR (window)
1098 and frame_cols = FRAME_COLS (XFRAME (window->frame))
1100 Or you can let window_body_cols do this all for you, and write:
1101 window_body_cols (w) - 1
1103 The `-1' accounts for the continuation-line backslashes; the rest
1104 accounts for window borders if the window is split horizontally, and
1105 the scroll bars if they are turned on. */
1108 compute_motion (ptrdiff_t from
, EMACS_INT fromvpos
, EMACS_INT fromhpos
, int did_motion
, ptrdiff_t to
, EMACS_INT tovpos
, EMACS_INT tohpos
, EMACS_INT width
, ptrdiff_t hscroll
, int tab_offset
, struct window
*win
)
1110 register EMACS_INT hpos
= fromhpos
;
1111 register EMACS_INT vpos
= fromvpos
;
1113 register ptrdiff_t pos
;
1116 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
1117 register int ctl_arrow
= !NILP (BVAR (current_buffer
, ctl_arrow
));
1118 register struct Lisp_Char_Table
*dp
= window_display_table (win
);
1120 = (INTEGERP (BVAR (current_buffer
, selective_display
))
1121 ? XINT (BVAR (current_buffer
, selective_display
))
1122 : !NILP (BVAR (current_buffer
, selective_display
)) ? -1 : 0);
1123 ptrdiff_t selective_rlen
1124 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
1125 ? ASIZE (DISP_INVIS_VECTOR (dp
)) : 0);
1126 /* The next location where the `invisible' property changes, or an
1127 overlay starts or ends. */
1128 ptrdiff_t next_boundary
= from
;
1130 /* For computing runs of characters with similar widths.
1131 Invariant: width_run_width is zero, or all the characters
1132 from width_run_start to width_run_end have a fixed width of
1134 ptrdiff_t width_run_start
= from
;
1135 ptrdiff_t width_run_end
= from
;
1136 ptrdiff_t width_run_width
= 0;
1137 Lisp_Object
*width_table
;
1139 /* The next buffer pos where we should consult the width run cache. */
1140 ptrdiff_t next_width_run
= from
;
1143 int multibyte
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
1144 /* If previous char scanned was a wide character,
1145 this is the column where it ended. Otherwise, this is 0. */
1146 EMACS_INT wide_column_end_hpos
= 0;
1147 ptrdiff_t prev_pos
; /* Previous buffer position. */
1148 ptrdiff_t prev_pos_byte
; /* Previous buffer position. */
1149 EMACS_INT prev_hpos
= 0;
1150 EMACS_INT prev_vpos
= 0;
1151 EMACS_INT contin_hpos
; /* HPOS of last column of continued line. */
1152 int prev_tab_offset
; /* Previous tab offset. */
1153 int continuation_glyph_width
;
1155 struct composition_it cmp_it
;
1157 XSETWINDOW (window
, win
);
1159 width_run_cache_on_off ();
1160 if (dp
== buffer_display_table ())
1161 width_table
= (VECTORP (BVAR (current_buffer
, width_table
))
1162 ? XVECTOR (BVAR (current_buffer
, width_table
))->contents
1165 /* If the window has its own display table, we can't use the width
1166 run cache, because that's based on the buffer's display table. */
1169 /* Negative width means use all available text columns. */
1172 width
= window_body_cols (win
);
1173 /* We must make room for continuation marks if we don't have fringes. */
1174 #ifdef HAVE_WINDOW_SYSTEM
1175 if (!FRAME_WINDOW_P (XFRAME (win
->frame
)))
1180 continuation_glyph_width
= 1;
1181 #ifdef HAVE_WINDOW_SYSTEM
1182 if (FRAME_WINDOW_P (XFRAME (win
->frame
)))
1183 continuation_glyph_width
= 0; /* In the fringe. */
1189 pos
= prev_pos
= from
;
1190 pos_byte
= prev_pos_byte
= CHAR_TO_BYTE (from
);
1192 prev_tab_offset
= tab_offset
;
1193 memset (&cmp_it
, 0, sizeof cmp_it
);
1195 composition_compute_stop_pos (&cmp_it
, pos
, pos_byte
, to
, Qnil
);
1199 while (pos
== next_boundary
)
1201 ptrdiff_t pos_here
= pos
;
1204 /* Don't skip invisible if we are already at the margin. */
1205 if (vpos
> tovpos
|| (vpos
== tovpos
&& hpos
>= tohpos
))
1207 if (contin_hpos
&& prev_hpos
== 0
1209 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1210 { /* Line breaks because we can't put the character at the
1211 previous line any more. It is not the multi-column
1212 character continued in middle. Go back to previous
1213 buffer position, screen position, and set tab offset
1214 to previous value. It's the beginning of the
1217 pos_byte
= prev_pos_byte
;
1220 tab_offset
= prev_tab_offset
;
1225 /* If the caller says that the screen position came from an earlier
1226 call to compute_motion, then we've already accounted for the
1227 overlay strings at point. This is only true the first time
1228 through, so clear the flag after testing it. */
1230 /* We need to skip past the overlay strings. Currently those
1231 strings must not contain TAB;
1232 if we want to relax that restriction, something will have
1233 to be changed here. */
1235 unsigned char *ovstr
;
1236 ptrdiff_t ovlen
= overlay_strings (pos
, win
, &ovstr
);
1237 hpos
+= ((multibyte
&& ovlen
> 0)
1238 ? strwidth ((char *) ovstr
, ovlen
) : ovlen
);
1245 /* Advance POS past invisible characters
1246 (but not necessarily all that there are here),
1247 and store in next_boundary the next position where
1248 we need to call skip_invisible. */
1249 newpos
= skip_invisible (pos
, &next_boundary
, to
, window
);
1253 pos
= min (to
, newpos
);
1254 pos_byte
= CHAR_TO_BYTE (pos
);
1258 if (newpos
!= pos_here
)
1261 pos_byte
= CHAR_TO_BYTE (pos
);
1265 /* Handle right margin. */
1266 /* Note on a wide-column character.
1268 Characters are classified into the following three categories
1269 according to the width (columns occupied on screen).
1271 (1) single-column character: ex. `a'
1272 (2) multi-column character: ex. `^A', TAB, `\033'
1273 (3) wide-column character: ex. Japanese character, Chinese character
1274 (In the following example, `W_' stands for them.)
1276 Multi-column characters can be divided around the right margin,
1277 but wide-column characters cannot.
1281 (*) The cursor is placed on the next character after the point.
1285 j ^---- next after the point
1286 ^--- next char. after the point.
1288 In case of sigle-column character
1292 033 ^---- next after the point, next char. after the point.
1294 In case of multi-column character
1298 W_ ^---- next after the point
1299 ^---- next char. after the point.
1301 In case of wide-column character
1303 The problem here is continuation at a wide-column character.
1304 In this case, the line may shorter less than WIDTH.
1305 And we find the continuation AFTER it occurs.
1311 EMACS_INT total_width
= width
+ continuation_glyph_width
;
1314 if (!NILP (Vtruncate_partial_width_windows
)
1315 && (total_width
< FRAME_COLS (XFRAME (WINDOW_FRAME (win
)))))
1317 if (INTEGERP (Vtruncate_partial_width_windows
))
1319 = total_width
< XFASTINT (Vtruncate_partial_width_windows
);
1324 if (hscroll
|| truncate
1325 || !NILP (BVAR (current_buffer
, truncate_lines
)))
1327 /* Truncating: skip to newline, unless we are already past
1328 TO (we need to go back below). */
1331 pos
= find_before_next_newline (pos
, to
, 1);
1332 pos_byte
= CHAR_TO_BYTE (pos
);
1334 /* If we just skipped next_boundary,
1335 loop around in the main while
1337 if (pos
>= next_boundary
)
1338 next_boundary
= pos
+ 1;
1341 prev_tab_offset
= tab_offset
;
1347 /* Remember the previous value. */
1348 prev_tab_offset
= tab_offset
;
1350 if (wide_column_end_hpos
> width
)
1353 tab_offset
+= prev_hpos
;
1357 tab_offset
+= width
;
1361 contin_hpos
= prev_hpos
;
1367 /* Stop if past the target buffer position or screen position. */
1370 /* Go back to the previous position. */
1372 pos_byte
= prev_pos_byte
;
1375 tab_offset
= prev_tab_offset
;
1377 /* NOTE on contin_hpos, hpos, and prev_hpos.
1381 W_ ^---- contin_hpos
1387 if (contin_hpos
&& prev_hpos
== 0
1388 && contin_hpos
< width
&& !wide_column_end_hpos
)
1390 /* Line breaking occurs in the middle of multi-column
1391 character. Go back to previous line. */
1398 if (vpos
> tovpos
|| (vpos
== tovpos
&& hpos
>= tohpos
))
1400 if (contin_hpos
&& prev_hpos
== 0
1402 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1403 { /* Line breaks because we can't put the character at the
1404 previous line any more. It is not the multi-column
1405 character continued in middle. Go back to previous
1406 buffer position, screen position, and set tab offset
1407 to previous value. It's the beginning of the
1410 pos_byte
= prev_pos_byte
;
1413 tab_offset
= prev_tab_offset
;
1417 if (pos
== ZV
) /* We cannot go beyond ZV. Stop here. */
1423 prev_pos_byte
= pos_byte
;
1424 wide_column_end_hpos
= 0;
1426 /* Consult the width run cache to see if we can avoid inspecting
1427 the text character-by-character. */
1428 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
1432 = region_cache_forward (current_buffer
,
1433 current_buffer
->width_run_cache
,
1436 /* A width of zero means the character's width varies (like
1437 a tab), is meaningless (like a newline), or we just don't
1438 want to skip over it for some other reason. */
1439 if (common_width
!= 0)
1441 ptrdiff_t run_end_hpos
;
1443 /* Don't go past the final buffer posn the user
1448 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1450 /* Don't go past the final horizontal position the user
1452 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
1454 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
1455 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1458 /* Don't go past the margin. */
1459 if (run_end_hpos
>= width
)
1461 run_end
= pos
+ (width
- hpos
) / common_width
;
1462 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1465 hpos
= run_end_hpos
;
1467 prev_hpos
= hpos
- common_width
;
1471 pos_byte
= CHAR_TO_BYTE (pos
);
1475 next_width_run
= run_end
+ 1;
1478 /* We have to scan the text character-by-character. */
1482 Lisp_Object charvec
;
1484 /* Check composition sequence. */
1486 || (pos
== cmp_it
.stop_pos
1487 && composition_reseat_it (&cmp_it
, pos
, pos_byte
, to
, win
,
1489 composition_update_it (&cmp_it
, pos
, pos_byte
, Qnil
);
1492 pos
+= cmp_it
.nchars
;
1493 pos_byte
+= cmp_it
.nbytes
;
1494 hpos
+= cmp_it
.width
;
1495 if (cmp_it
.to
== cmp_it
.nglyphs
)
1498 composition_compute_stop_pos (&cmp_it
, pos
, pos_byte
, to
,
1502 cmp_it
.from
= cmp_it
.to
;
1506 c
= FETCH_BYTE (pos_byte
);
1509 /* Perhaps add some info to the width_run_cache. */
1510 if (current_buffer
->width_run_cache
)
1512 /* Is this character part of the current run? If so, extend
1514 if (pos
- 1 == width_run_end
1515 && XFASTINT (width_table
[c
]) == width_run_width
)
1516 width_run_end
= pos
;
1518 /* The previous run is over, since this is a character at a
1519 different position, or a different width. */
1522 /* Have we accumulated a run to put in the cache?
1523 (Currently, we only cache runs of width == 1). */
1524 if (width_run_start
< width_run_end
1525 && width_run_width
== 1)
1526 know_region_cache (current_buffer
,
1527 current_buffer
->width_run_cache
,
1528 width_run_start
, width_run_end
);
1530 /* Start recording a new width run. */
1531 width_run_width
= XFASTINT (width_table
[c
]);
1532 width_run_start
= pos
- 1;
1533 width_run_end
= pos
;
1538 && ! (multibyte
&& LEADING_CODE_P (c
))
1539 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1541 charvec
= DISP_CHAR_VECTOR (dp
, c
);
1542 n
= ASIZE (charvec
);
1550 for (i
= 0; i
< n
; ++i
)
1552 if (VECTORP (charvec
))
1554 /* This should be handled the same as
1555 next_element_from_display_vector does it. */
1556 Lisp_Object entry
= AREF (charvec
, i
);
1558 if (GLYPH_CODE_P (entry
))
1559 c
= GLYPH_CODE_CHAR (entry
);
1564 if (c
>= 040 && c
< 0177)
1568 int tem
= ((hpos
+ tab_offset
+ hscroll
- (hscroll
> 0))
1572 hpos
+= tab_width
- tem
;
1577 && indented_beyond_p (pos
, pos_byte
, selective
))
1579 /* If (pos == to), we don't have to take care of
1580 selective display. */
1583 /* Skip any number of invisible lines all at once */
1586 pos
= find_before_next_newline (pos
, to
, 1);
1589 pos_byte
= CHAR_TO_BYTE (pos
);
1592 && indented_beyond_p (pos
, pos_byte
,
1594 /* Allow for the " ..." that is displayed for them. */
1597 hpos
+= selective_rlen
;
1601 DEC_BOTH (pos
, pos_byte
);
1602 /* We have skipped the invis text, but not the
1608 /* A visible line. */
1612 /* Count the truncation glyph on column 0 */
1614 hpos
+= continuation_glyph_width
;
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. */
1626 pos
= find_before_next_newline (pos
, to
, 1);
1627 pos_byte
= CHAR_TO_BYTE (pos
);
1629 /* If we just skipped next_boundary,
1630 loop around in the main while
1632 if (pos
> next_boundary
)
1633 next_boundary
= pos
;
1634 /* Allow for the " ..." that is displayed for them. */
1637 hpos
+= selective_rlen
;
1642 else if (multibyte
&& LEADING_CODE_P (c
))
1644 /* Start of multi-byte form. */
1646 int mb_bytes
, mb_width
;
1648 pos_byte
--; /* rewind POS_BYTE */
1649 ptr
= BYTE_POS_ADDR (pos_byte
);
1650 MULTIBYTE_BYTES_WIDTH (ptr
, dp
, mb_bytes
, mb_width
);
1651 pos_byte
+= mb_bytes
;
1652 if (mb_width
> 1 && BYTES_BY_CHAR_HEAD (*ptr
) == mb_bytes
)
1653 wide_column_end_hpos
= hpos
+ mb_width
;
1656 else if (VECTORP (charvec
))
1659 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
1666 /* Remember any final width run in the cache. */
1667 if (current_buffer
->width_run_cache
1668 && width_run_width
== 1
1669 && width_run_start
< width_run_end
)
1670 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
1671 width_run_start
, width_run_end
);
1673 val_compute_motion
.bufpos
= pos
;
1674 val_compute_motion
.bytepos
= pos_byte
;
1675 val_compute_motion
.hpos
= hpos
;
1676 val_compute_motion
.vpos
= vpos
;
1677 if (contin_hpos
&& prev_hpos
== 0)
1678 val_compute_motion
.prevhpos
= contin_hpos
;
1680 val_compute_motion
.prevhpos
= prev_hpos
;
1682 /* Nonzero if have just continued a line */
1683 val_compute_motion
.contin
= (contin_hpos
&& prev_hpos
== 0);
1686 return &val_compute_motion
;
1690 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
1691 doc
: /* Scan through the current buffer, calculating screen position.
1692 Scan the current buffer forward from offset FROM,
1693 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--
1694 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--
1695 and return the ending buffer position and screen location.
1697 If TOPOS is nil, the actual width and height of the window's
1700 There are three additional arguments:
1702 WIDTH is the number of columns available to display text;
1703 this affects handling of continuation lines. A value of nil
1704 corresponds to the actual number of available text columns.
1706 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).
1707 HSCROLL is the number of columns not being displayed at the left
1708 margin; this is usually taken from a window's hscroll member.
1709 TAB-OFFSET is the number of columns of the first tab that aren't
1710 being displayed, perhaps because the line was continued within it.
1711 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.
1713 WINDOW is the window to operate on. It is used to choose the display table;
1714 if it is showing the current buffer, it is used also for
1715 deciding which overlay properties apply.
1716 Note that `compute-motion' always operates on the current buffer.
1718 The value is a list of five elements:
1719 (POS HPOS VPOS PREVHPOS CONTIN)
1720 POS is the buffer position where the scan stopped.
1721 VPOS is the vertical position where the scan stopped.
1722 HPOS is the horizontal position where the scan stopped.
1724 PREVHPOS is the horizontal position one character back from POS.
1725 CONTIN is t if a line was continued after (or within) the previous character.
1727 For example, to find the buffer position of column COL of line LINE
1728 of a certain window, pass the window's starting location as FROM
1729 and the window's upper-left coordinates as FROMPOS.
1730 Pass the buffer's (point-max) as TO, to limit the scan to the end of the
1731 visible section of the buffer, and pass LINE and COL as TOPOS. */)
1732 (Lisp_Object from
, Lisp_Object frompos
, Lisp_Object to
, Lisp_Object topos
, Lisp_Object width
, Lisp_Object offsets
, Lisp_Object window
)
1735 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
;
1736 struct position
*pos
;
1740 CHECK_NUMBER_COERCE_MARKER (from
);
1741 CHECK_CONS (frompos
);
1742 CHECK_NUMBER_CAR (frompos
);
1743 CHECK_NUMBER_CDR (frompos
);
1744 CHECK_NUMBER_COERCE_MARKER (to
);
1748 CHECK_NUMBER_CAR (topos
);
1749 CHECK_NUMBER_CDR (topos
);
1752 CHECK_NUMBER (width
);
1754 if (!NILP (offsets
))
1756 CHECK_CONS (offsets
);
1757 CHECK_NUMBER_CAR (offsets
);
1758 CHECK_NUMBER_CDR (offsets
);
1759 if (! (0 <= XINT (XCAR (offsets
)) && XINT (XCAR (offsets
)) <= PTRDIFF_MAX
1760 && 0 <= XINT (XCDR (offsets
)) && XINT (XCDR (offsets
)) <= INT_MAX
))
1761 args_out_of_range (XCAR (offsets
), XCDR (offsets
));
1762 hscroll
= XINT (XCAR (offsets
));
1763 tab_offset
= XINT (XCDR (offsets
));
1766 hscroll
= tab_offset
= 0;
1769 window
= Fselected_window ();
1771 CHECK_LIVE_WINDOW (window
);
1772 w
= XWINDOW (window
);
1774 if (XINT (from
) < BEGV
|| XINT (from
) > ZV
)
1775 args_out_of_range_3 (from
, make_number (BEGV
), make_number (ZV
));
1776 if (XINT (to
) < BEGV
|| XINT (to
) > ZV
)
1777 args_out_of_range_3 (to
, make_number (BEGV
), make_number (ZV
));
1779 pos
= compute_motion (XINT (from
), XINT (XCDR (frompos
)),
1780 XINT (XCAR (frompos
)), 0,
1783 ? window_internal_height (w
)
1784 : XINT (XCDR (topos
))),
1786 ? (window_body_cols (w
)
1788 #ifdef HAVE_WINDOW_SYSTEM
1789 FRAME_WINDOW_P (XFRAME (w
->frame
)) ? 0 :
1792 : XINT (XCAR (topos
))),
1793 (NILP (width
) ? -1 : XINT (width
)),
1794 hscroll
, tab_offset
,
1797 XSETFASTINT (bufpos
, pos
->bufpos
);
1798 XSETINT (hpos
, pos
->hpos
);
1799 XSETINT (vpos
, pos
->vpos
);
1800 XSETINT (prevhpos
, pos
->prevhpos
);
1802 return Fcons (bufpos
,
1806 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
1810 /* Fvertical_motion and vmotion */
1812 static struct position val_vmotion
;
1815 vmotion (register ptrdiff_t from
, register EMACS_INT vtarget
, struct window
*w
)
1817 ptrdiff_t hscroll
= w
->hscroll
;
1818 struct position pos
;
1819 /* vpos is cumulative vertical position, changed as from is changed */
1820 register EMACS_INT vpos
= 0;
1822 register ptrdiff_t first
;
1823 ptrdiff_t from_byte
;
1824 ptrdiff_t lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1826 = (INTEGERP (BVAR (current_buffer
, selective_display
))
1827 ? clip_to_bounds (-1, XINT (BVAR (current_buffer
, selective_display
)),
1829 : !NILP (BVAR (current_buffer
, selective_display
)) ? -1 : 0);
1832 /* This is the object we use for fetching character properties. */
1833 Lisp_Object text_prop_object
;
1835 XSETWINDOW (window
, w
);
1837 /* If the window contains this buffer, use it for getting text properties.
1838 Otherwise use the current buffer as arg for doing that. */
1839 if (EQ (w
->buffer
, Fcurrent_buffer ()))
1840 text_prop_object
= window
;
1842 text_prop_object
= Fcurrent_buffer ();
1844 if (vpos
>= vtarget
)
1846 /* To move upward, go a line at a time until
1847 we have gone at least far enough. */
1851 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1853 Lisp_Object propval
;
1855 prevline
= find_next_newline_no_quit (from
- 1, -1);
1856 while (prevline
> BEGV
1858 && indented_beyond_p (prevline
,
1859 CHAR_TO_BYTE (prevline
),
1861 /* Watch out for newlines with `invisible' property.
1862 When moving upward, check the newline before. */
1863 || (propval
= Fget_char_property (make_number (prevline
- 1),
1866 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1867 prevline
= find_next_newline_no_quit (prevline
- 1, -1);
1868 pos
= *compute_motion (prevline
, 0,
1872 /* Don't care for VPOS... */
1873 1 << (BITS_PER_SHORT
- 1),
1875 1 << (BITS_PER_SHORT
- 1),
1884 /* If we made exactly the desired vertical distance,
1885 or if we hit beginning of buffer,
1886 return point found */
1887 if (vpos
>= vtarget
)
1889 val_vmotion
.bufpos
= from
;
1890 val_vmotion
.bytepos
= CHAR_TO_BYTE (from
);
1891 val_vmotion
.vpos
= vpos
;
1892 val_vmotion
.hpos
= lmargin
;
1893 val_vmotion
.contin
= 0;
1894 val_vmotion
.prevhpos
= 0;
1895 return &val_vmotion
;
1898 /* Otherwise find the correct spot by moving down */
1900 /* Moving downward is simple, but must calculate from beg of line
1901 to determine hpos of starting point */
1902 from_byte
= CHAR_TO_BYTE (from
);
1903 if (from
> BEGV
&& FETCH_BYTE (from_byte
- 1) != '\n')
1905 Lisp_Object propval
;
1907 prevline
= find_next_newline_no_quit (from
, -1);
1908 while (prevline
> BEGV
1910 && indented_beyond_p (prevline
,
1911 CHAR_TO_BYTE (prevline
),
1913 /* Watch out for newlines with `invisible' property.
1914 When moving downward, check the newline after. */
1915 || (propval
= Fget_char_property (make_number (prevline
),
1918 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1919 prevline
= find_next_newline_no_quit (prevline
- 1, -1);
1920 pos
= *compute_motion (prevline
, 0,
1924 /* Don't care for VPOS... */
1925 1 << (BITS_PER_SHORT
- 1),
1927 1 << (BITS_PER_SHORT
- 1),
1939 return compute_motion (from
, vpos
, pos
.hpos
, did_motion
,
1940 ZV
, vtarget
, - (1 << (BITS_PER_SHORT
- 1)),
1946 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
1947 doc
: /* Move point to start of the screen line LINES lines down.
1948 If LINES is negative, this means moving up.
1950 This function is an ordinary cursor motion function
1951 which calculates the new position based on how text would be displayed.
1952 The new position may be the start of a line,
1953 or just the start of a continuation line.
1954 The function returns number of screen lines moved over;
1955 that usually equals LINES, but may be closer to zero
1956 if beginning or end of buffer was reached.
1958 The optional second argument WINDOW specifies the window to use for
1959 parameters such as width, horizontal scrolling, and so on.
1960 The default is to use the selected window's parameters.
1962 LINES can optionally take the form (COLS . LINES), in which case
1963 the motion will not stop at the start of a screen line but on
1964 its column COLS (if such exists on that line, that is).
1966 `vertical-motion' always uses the current buffer,
1967 regardless of which buffer is displayed in WINDOW.
1968 This is consistent with other cursor motion functions
1969 and makes it possible to use `vertical-motion' in any buffer,
1970 whether or not it is currently displayed in some window. */)
1971 (Lisp_Object lines
, Lisp_Object window
)
1976 Lisp_Object old_buffer
;
1977 EMACS_INT old_charpos
IF_LINT (= 0), old_bytepos
IF_LINT (= 0);
1978 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1979 Lisp_Object lcols
= Qnil
;
1980 double cols
IF_LINT (= 0);
1981 void *itdata
= NULL
;
1983 /* Allow LINES to be of the form (HPOS . VPOS) aka (COLUMNS . LINES). */
1984 if (CONSP (lines
) && (NUMBERP (XCAR (lines
))))
1986 lcols
= XCAR (lines
);
1987 cols
= INTEGERP (lcols
) ? (double) XINT (lcols
) : XFLOAT_DATA (lcols
);
1988 lines
= XCDR (lines
);
1991 CHECK_NUMBER (lines
);
1992 if (! NILP (window
))
1993 CHECK_WINDOW (window
);
1995 window
= selected_window
;
1996 w
= XWINDOW (window
);
1999 GCPRO3 (old_buffer
, old_charpos
, old_bytepos
);
2000 if (XBUFFER (w
->buffer
) != current_buffer
)
2002 /* Set the window's buffer temporarily to the current buffer. */
2003 old_buffer
= w
->buffer
;
2004 old_charpos
= XMARKER (w
->pointm
)->charpos
;
2005 old_bytepos
= XMARKER (w
->pointm
)->bytepos
;
2006 wset_buffer (w
, Fcurrent_buffer ());
2007 set_marker_both (w
->pointm
, w
->buffer
,
2008 BUF_PT (current_buffer
), BUF_PT_BYTE (current_buffer
));
2013 struct position pos
;
2014 pos
= *vmotion (PT
, XINT (lines
), w
);
2015 SET_PT_BOTH (pos
.bufpos
, pos
.bytepos
);
2019 ptrdiff_t it_start
, it_overshoot_count
= 0;
2021 int overshoot_handled
= 0;
2022 int disp_string_at_start_p
= 0;
2024 itdata
= bidi_shelve_cache ();
2025 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
2026 start_display (&it
, w
, pt
);
2027 first_x
= it
.first_visible_x
;
2028 it_start
= IT_CHARPOS (it
);
2030 /* See comments below for why we calculate this. */
2031 if (it
.cmp_it
.id
>= 0)
2032 it_overshoot_count
= 0;
2033 else if (it
.method
== GET_FROM_STRING
)
2035 const char *s
= SSDATA (it
.string
);
2036 const char *e
= s
+ SBYTES (it
.string
);
2038 disp_string_at_start_p
= it
.string_from_display_prop_p
;
2042 it_overshoot_count
++;
2044 if (!it_overshoot_count
)
2045 it_overshoot_count
= -1;
2048 it_overshoot_count
=
2049 !(it
.method
== GET_FROM_IMAGE
|| it
.method
== GET_FROM_STRETCH
);
2051 /* Scan from the start of the line containing PT. If we don't
2052 do this, we start moving with IT->current_x == 0, while PT is
2053 really at some x > 0. */
2054 reseat_at_previous_visible_line_start (&it
);
2055 it
.current_x
= it
.hpos
= 0;
2056 if (IT_CHARPOS (it
) != PT
)
2057 /* We used to temporarily disable selective display here; the
2058 comment said this is "so we don't move too far" (2005-01-19
2059 checkin by kfs). But this does nothing useful that I can
2060 tell, and it causes Bug#2694 . -- cyd */
2061 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
2063 /* IT may move too far if truncate-lines is on and PT lies
2064 beyond the right margin. IT may also move too far if the
2065 starting point is on a Lisp string that has embedded
2066 newlines, or spans several screen lines. In these cases,
2068 if (IT_CHARPOS (it
) > it_start
)
2070 /* We need to backtrack also if the Lisp string contains no
2071 newlines, but there is a newline right after it. In this
2072 case, IT overshoots if there is an after-string just
2073 before the newline. */
2074 if (it_overshoot_count
< 0
2075 && it
.method
== GET_FROM_BUFFER
2077 it_overshoot_count
= 1;
2078 else if (disp_string_at_start_p
&& it
.vpos
> 0)
2080 /* This is the case of a display string that spans
2081 several screen lines. In that case, we end up at the
2082 end of the string, and it.vpos tells us how many
2083 screen lines we need to backtrack. */
2084 it_overshoot_count
= it
.vpos
;
2086 if (it_overshoot_count
> 0)
2087 move_it_by_lines (&it
, -it_overshoot_count
);
2089 overshoot_handled
= 1;
2091 if (XINT (lines
) <= 0)
2094 /* Do this even if LINES is 0, so that we move back to the
2095 beginning of the current line as we ought. */
2096 if (XINT (lines
) == 0 || IT_CHARPOS (it
) > 0)
2097 move_it_by_lines (&it
, max (PTRDIFF_MIN
, XINT (lines
)));
2099 else if (overshoot_handled
)
2102 move_it_by_lines (&it
, min (PTRDIFF_MAX
, XINT (lines
)));
2106 /* Otherwise, we are at the first row occupied by PT, which
2107 might span multiple screen lines (e.g., if it's on a
2108 multi-line display string). We want to start from the
2109 last line that it occupies. */
2112 while (IT_CHARPOS (it
) <= it_start
)
2115 move_it_by_lines (&it
, 1);
2117 if (XINT (lines
) > 1)
2118 move_it_by_lines (&it
, min (PTRDIFF_MAX
, XINT (lines
) - 1));
2123 move_it_by_lines (&it
, min (PTRDIFF_MAX
, XINT (lines
)));
2127 /* Move to the goal column, if one was specified. */
2130 /* If the window was originally hscrolled, move forward by
2131 the hscrolled amount first. */
2134 move_it_in_display_line (&it
, ZV
, first_x
, MOVE_TO_X
);
2137 move_it_in_display_line
2139 (int)(cols
* FRAME_COLUMN_WIDTH (XFRAME (w
->frame
)) + 0.5),
2143 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
2144 bidi_unshelve_cache (itdata
, 0);
2147 if (BUFFERP (old_buffer
))
2149 wset_buffer (w
, old_buffer
);
2150 set_marker_both (w
->pointm
, w
->buffer
,
2151 old_charpos
, old_bytepos
);
2154 RETURN_UNGCPRO (make_number (it
.vpos
));
2159 /* File's initialization. */
2162 syms_of_indent (void)
2164 DEFVAR_BOOL ("indent-tabs-mode", indent_tabs_mode
,
2165 doc
: /* Indentation can insert tabs if this is non-nil. */);
2166 indent_tabs_mode
= 1;
2168 defsubr (&Scurrent_indentation
);
2169 defsubr (&Sindent_to
);
2170 defsubr (&Scurrent_column
);
2171 defsubr (&Smove_to_column
);
2172 defsubr (&Svertical_motion
);
2173 defsubr (&Scompute_motion
);