1 /* Indentation functions.
2 Copyright (C) 1985-1988, 1993-1995, 1998, 2000-2011
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/>. */
26 #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 BVAR (buf
, width_table
) = 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 BVAR (current_buffer
, width_table
) = 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 (BUF_INTERVALS (current_buffer
)
340 || current_buffer
->overlays_before
341 || current_buffer
->overlays_after
343 return current_column_1 ();
345 /* Scan backwards from point to the previous newline,
346 counting width. Tab characters are the only complicated case. */
348 /* Make a pointer for decrementing through the chars before point. */
349 ptr
= BYTE_POS_ADDR (PT_BYTE
- 1) + 1;
350 /* Make a pointer to where consecutive chars leave off,
351 going backwards from point. */
354 else if (PT
<= GPT
|| BEGV
> GPT
)
359 col
= 0, tab_seen
= 0, post_tab
= 0;
368 /* We stopped either for the beginning of the buffer
370 if (ptr
== BEGV_ADDR
)
373 /* It was the gap. Jump back over it. */
377 /* Check whether that brings us to beginning of buffer. */
384 if (dp
&& VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
386 charvec
= DISP_CHAR_VECTOR (dp
, c
);
395 for (i
= n
- 1; i
>= 0; --i
)
397 if (VECTORP (charvec
))
399 /* This should be handled the same as
400 next_element_from_display_vector does it. */
401 Lisp_Object entry
= AREF (charvec
, i
);
403 if (GLYPH_CODE_P (entry
))
404 c
= GLYPH_CODE_CHAR (entry
);
409 if (c
>= 040 && c
< 0177)
413 && EQ (BVAR (current_buffer
, selective_display
), Qt
)))
416 goto start_of_line_found
;
421 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
427 else if (VECTORP (charvec
))
428 /* With a display table entry, C is displayed as is, and
429 not displayed as \NNN or as ^N. If C is a single-byte
430 character, it takes one column. If C is multi-byte in
431 an unibyte buffer, it's translated to unibyte, so it
432 also takes one column. */
435 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
443 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
447 if (ptr
== BEGV_ADDR
)
448 current_column_bol_cache
= BEGV
;
450 current_column_bol_cache
= BYTE_TO_CHAR (PTR_BYTE_POS (ptr
));
452 last_known_column
= col
;
453 last_known_column_point
= PT
;
454 last_known_column_modified
= MODIFF
;
460 /* Check the presence of a display property and compute its width.
461 If a property was found and its width was found as well, return
462 its width (>= 0) and set the position of the end of the property
464 Otherwise just return -1. */
466 check_display_width (ptrdiff_t pos
, ptrdiff_t col
, ptrdiff_t *endpos
)
468 Lisp_Object val
, overlay
;
470 if (CONSP (val
= get_char_property_and_overlay
471 (make_number (pos
), Qdisplay
, Qnil
, &overlay
))
472 && EQ (Qspace
, XCAR (val
)))
473 { /* FIXME: Use calc_pixel_width_or_height. */
474 Lisp_Object plist
= XCDR (val
), prop
;
476 EMACS_INT align_to_max
=
477 (col
< MOST_POSITIVE_FIXNUM
- INT_MAX
478 ? (EMACS_INT
) INT_MAX
+ col
479 : MOST_POSITIVE_FIXNUM
);
481 if ((prop
= Fplist_get (plist
, QCwidth
),
482 RANGED_INTEGERP (0, prop
, INT_MAX
)))
484 else if (FLOATP (prop
) && 0 <= XFLOAT_DATA (prop
)
485 && XFLOAT_DATA (prop
) <= INT_MAX
)
486 width
= (int)(XFLOAT_DATA (prop
) + 0.5);
487 else if ((prop
= Fplist_get (plist
, QCalign_to
),
488 RANGED_INTEGERP (col
, prop
, align_to_max
)))
489 width
= XINT (prop
) - col
;
490 else if (FLOATP (prop
) && col
<= XFLOAT_DATA (prop
)
491 && (XFLOAT_DATA (prop
) <= align_to_max
))
492 width
= (int)(XFLOAT_DATA (prop
) + 0.5) - col
;
497 if (OVERLAYP (overlay
))
498 *endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
500 get_property_and_range (pos
, Qdisplay
, &val
, &start
, endpos
, Qnil
);
507 /* Scanning from the beginning of the current line, stop at the buffer
508 position ENDPOS or at the column GOALCOL or at the end of line, whichever
510 Return the resulting buffer position and column in ENDPOS and GOALCOL.
511 PREVCOL gets set to the column of the previous position (it's always
512 strictly smaller than the goal column). */
514 scan_for_column (ptrdiff_t *endpos
, EMACS_INT
*goalcol
, ptrdiff_t *prevcol
)
516 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
517 register int ctl_arrow
= !NILP (BVAR (current_buffer
, ctl_arrow
));
518 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
519 int multibyte
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
520 struct composition_it cmp_it
;
524 /* Start the scan at the beginning of this line with column number 0. */
525 register ptrdiff_t col
= 0, prev_col
= 0;
526 EMACS_INT goal
= goalcol
? *goalcol
: MOST_POSITIVE_FIXNUM
;
527 ptrdiff_t end
= endpos
? *endpos
: PT
;
528 ptrdiff_t scan
, scan_byte
;
529 ptrdiff_t next_boundary
;
531 ptrdiff_t opoint
= PT
, opoint_byte
= PT_BYTE
;
532 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
533 current_column_bol_cache
= PT
;
534 scan
= PT
, scan_byte
= PT_BYTE
;
535 SET_PT_BOTH (opoint
, opoint_byte
);
536 next_boundary
= scan
;
539 window
= Fget_buffer_window (Fcurrent_buffer (), Qnil
);
540 w
= ! NILP (window
) ? XWINDOW (window
) : NULL
;
542 memset (&cmp_it
, 0, sizeof cmp_it
);
544 composition_compute_stop_pos (&cmp_it
, scan
, scan_byte
, end
, Qnil
);
546 /* Scan forward to the target position. */
551 /* Occasionally we may need to skip invisible text. */
552 while (scan
== next_boundary
)
554 ptrdiff_t old_scan
= scan
;
555 /* This updates NEXT_BOUNDARY to the next place
556 where we might need to skip more invisible text. */
557 scan
= skip_invisible (scan
, &next_boundary
, end
, Qnil
);
558 if (scan
!= old_scan
)
559 scan_byte
= CHAR_TO_BYTE (scan
);
564 /* Test reaching the goal column. We do this after skipping
565 invisible characters, so that we put point before the
566 character on which the cursor will appear. */
571 { /* Check display property. */
573 int width
= check_display_width (scan
, col
, &endp
);
577 if (endp
> scan
) /* Avoid infinite loops with 0-width overlays. */
579 scan
= endp
; scan_byte
= charpos_to_bytepos (scan
);
585 /* Check composition sequence. */
587 || (scan
== cmp_it
.stop_pos
588 && composition_reseat_it (&cmp_it
, scan
, scan_byte
, end
,
590 composition_update_it (&cmp_it
, scan
, scan_byte
, Qnil
);
593 scan
+= cmp_it
.nchars
;
594 scan_byte
+= cmp_it
.nbytes
;
597 if (cmp_it
.to
== cmp_it
.nglyphs
)
600 composition_compute_stop_pos (&cmp_it
, scan
, scan_byte
, end
,
604 cmp_it
.from
= cmp_it
.to
;
608 c
= FETCH_BYTE (scan_byte
);
610 /* See if there is a display table and it relates
611 to this character. */
614 && ! (multibyte
&& LEADING_CODE_P (c
))
615 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
620 /* This character is displayed using a vector of glyphs.
621 Update the column/position based on those glyphs. */
623 charvec
= DISP_CHAR_VECTOR (dp
, c
);
626 for (i
= 0; i
< n
; i
++)
628 /* This should be handled the same as
629 next_element_from_display_vector does it. */
630 Lisp_Object entry
= AREF (charvec
, i
);
632 if (GLYPH_CODE_P (entry
))
633 c
= GLYPH_CODE_CHAR (entry
);
639 if (c
== '\r' && EQ (BVAR (current_buffer
, selective_display
), Qt
))
644 col
= col
/ tab_width
* tab_width
;
652 /* The display table doesn't affect this character;
653 it displays as itself. */
657 if (c
== '\r' && EQ (BVAR (current_buffer
, selective_display
), Qt
))
662 col
= col
/ tab_width
* tab_width
;
664 else if (multibyte
&& LEADING_CODE_P (c
))
666 /* Start of multi-byte form. */
670 ptr
= BYTE_POS_ADDR (scan_byte
);
671 MULTIBYTE_BYTES_WIDTH (ptr
, dp
, bytes
, width
);
672 /* Subtract one to compensate for the increment
673 that is going to happen below. */
674 scan_byte
+= bytes
- 1;
677 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
679 else if (c
< 040 || c
>= 0177)
690 last_known_column
= col
;
691 last_known_column_point
= PT
;
692 last_known_column_modified
= MODIFF
;
702 /* Return the column number of position POS
703 by scanning forward from the beginning of the line.
704 This function handles characters that are invisible
705 due to text properties or overlays. */
708 current_column_1 (void)
710 EMACS_INT col
= MOST_POSITIVE_FIXNUM
;
711 ptrdiff_t opoint
= PT
;
713 scan_for_column (&opoint
, &col
, NULL
);
718 #if 0 /* Not used. */
720 /* Return the width in columns of the part of STRING from BEG to END.
721 If BEG is nil, that stands for the beginning of STRING.
722 If END is nil, that stands for the end of STRING. */
725 string_display_width (Lisp_Object string
, Lisp_Object beg
, Lisp_Object end
)
728 register unsigned char *ptr
, *stop
;
729 register int tab_seen
;
732 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
733 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
734 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
753 /* Make a pointer for decrementing through the chars before point. */
754 ptr
= SDATA (string
) + e
;
755 /* Make a pointer to where consecutive chars leave off,
756 going backwards from point. */
757 stop
= SDATA (string
) + b
;
759 col
= 0, tab_seen
= 0, post_tab
= 0;
767 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
768 col
+= ASIZE (DISP_CHAR_VECTOR (dp
, c
));
769 else if (c
>= 040 && c
< 0177)
776 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
783 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
788 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
798 DEFUN ("indent-to", Findent_to
, Sindent_to
, 1, 2, "NIndent to column: ",
799 doc
: /* Indent from point with tabs and spaces until COLUMN is reached.
800 Optional second argument MINIMUM says always do at least MINIMUM spaces
801 even if that goes past COLUMN; by default, MINIMUM is zero.
803 The return value is COLUMN. */)
804 (Lisp_Object column
, Lisp_Object minimum
)
807 register ptrdiff_t fromcol
;
808 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
810 CHECK_NUMBER (column
);
812 XSETFASTINT (minimum
, 0);
813 CHECK_NUMBER (minimum
);
815 fromcol
= current_column ();
816 mincol
= fromcol
+ XINT (minimum
);
817 if (mincol
< XINT (column
)) mincol
= XINT (column
);
819 if (fromcol
== mincol
)
820 return make_number (mincol
);
822 if (indent_tabs_mode
)
825 XSETFASTINT (n
, mincol
/ tab_width
- fromcol
/ tab_width
);
826 if (XFASTINT (n
) != 0)
828 Finsert_char (make_number ('\t'), n
, Qt
);
830 fromcol
= (mincol
/ tab_width
) * tab_width
;
834 XSETFASTINT (column
, mincol
- fromcol
);
835 Finsert_char (make_number (' '), column
, Qt
);
837 last_known_column
= mincol
;
838 last_known_column_point
= PT
;
839 last_known_column_modified
= MODIFF
;
841 XSETINT (column
, mincol
);
846 DEFUN ("current-indentation", Fcurrent_indentation
, Scurrent_indentation
,
848 doc
: /* Return the indentation of the current line.
849 This is the horizontal position of the character
850 following any initial whitespace. */)
854 ptrdiff_t opoint
= PT
, opoint_byte
= PT_BYTE
;
856 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
858 XSETFASTINT (val
, position_indentation (PT_BYTE
));
859 SET_PT_BOTH (opoint
, opoint_byte
);
864 position_indentation (ptrdiff_t pos_byte
)
866 register ptrdiff_t column
= 0;
867 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
868 register unsigned char *p
;
869 register unsigned char *stop
;
870 unsigned char *start
;
871 ptrdiff_t next_boundary_byte
= pos_byte
;
872 ptrdiff_t ceiling
= next_boundary_byte
;
874 p
= BYTE_POS_ADDR (pos_byte
);
875 /* STOP records the value of P at which we will need
876 to think about the gap, or about invisible text,
877 or about the end of the buffer. */
879 /* START records the starting value of P. */
885 ptrdiff_t stop_pos_byte
;
887 /* If we have updated P, set POS_BYTE to match.
888 The first time we enter the loop, POS_BYTE is already right. */
890 pos_byte
= PTR_BYTE_POS (p
);
891 /* Consider the various reasons STOP might have been set here. */
892 if (pos_byte
== ZV_BYTE
)
894 if (pos_byte
== next_boundary_byte
)
896 ptrdiff_t next_boundary
;
897 ptrdiff_t pos
= BYTE_TO_CHAR (pos_byte
);
898 pos
= skip_invisible (pos
, &next_boundary
, ZV
, Qnil
);
899 pos_byte
= CHAR_TO_BYTE (pos
);
900 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
902 if (pos_byte
>= ceiling
)
903 ceiling
= BUFFER_CEILING_OF (pos_byte
) + 1;
904 /* Compute the next place we need to stop and think,
905 and set STOP accordingly. */
906 stop_pos_byte
= min (ceiling
, next_boundary_byte
);
907 /* The -1 and +1 arrange to point at the first byte of gap
908 (if STOP_POS_BYTE is the position of the gap)
909 rather than at the data after the gap. */
911 stop
= BYTE_POS_ADDR (stop_pos_byte
- 1) + 1;
912 p
= BYTE_POS_ADDR (pos_byte
);
917 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
923 column
+= tab_width
- column
% tab_width
;
926 if (ASCII_BYTE_P (p
[-1])
927 || NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
931 pos_byte
= PTR_BYTE_POS (p
- 1);
932 c
= FETCH_MULTIBYTE_CHAR (pos_byte
);
933 if (CHAR_HAS_CATEGORY (c
, ' '))
937 p
= BYTE_POS_ADDR (pos_byte
);
946 /* Test whether the line beginning at POS is indented beyond COLUMN.
947 Blank lines are treated as if they had the same indentation as the
951 indented_beyond_p (ptrdiff_t pos
, ptrdiff_t pos_byte
, EMACS_INT column
)
954 ptrdiff_t opoint
= PT
, opoint_byte
= PT_BYTE
;
956 SET_PT_BOTH (pos
, pos_byte
);
957 while (PT
> BEGV
&& FETCH_BYTE (PT_BYTE
) == '\n')
958 scan_newline (PT
- 1, PT_BYTE
- 1, BEGV
, BEGV_BYTE
, -1, 0);
960 val
= position_indentation (PT_BYTE
);
961 SET_PT_BOTH (opoint
, opoint_byte
);
962 return val
>= column
;
965 DEFUN ("move-to-column", Fmove_to_column
, Smove_to_column
, 1, 2, "p",
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
;
1140 /* The next buffer pos where we should consult the width run cache. */
1141 ptrdiff_t next_width_run
= from
;
1144 int 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 XSETBUFFER (buffer
, current_buffer
);
1159 XSETWINDOW (window
, win
);
1161 width_run_cache_on_off ();
1162 if (dp
== buffer_display_table ())
1163 width_table
= (VECTORP (BVAR (current_buffer
, width_table
))
1164 ? XVECTOR (BVAR (current_buffer
, width_table
))->contents
1167 /* If the window has its own display table, we can't use the width
1168 run cache, because that's based on the buffer's display table. */
1171 /* Negative width means use all available text columns. */
1174 width
= window_body_cols (win
);
1175 /* We must make room for continuation marks if we don't have fringes. */
1176 #ifdef HAVE_WINDOW_SYSTEM
1177 if (!FRAME_WINDOW_P (XFRAME (win
->frame
)))
1182 continuation_glyph_width
= 1;
1183 #ifdef HAVE_WINDOW_SYSTEM
1184 if (FRAME_WINDOW_P (XFRAME (win
->frame
)))
1185 continuation_glyph_width
= 0; /* In the fringe. */
1191 pos
= prev_pos
= from
;
1192 pos_byte
= prev_pos_byte
= CHAR_TO_BYTE (from
);
1194 prev_tab_offset
= tab_offset
;
1195 memset (&cmp_it
, 0, sizeof cmp_it
);
1197 composition_compute_stop_pos (&cmp_it
, pos
, pos_byte
, to
, Qnil
);
1201 while (pos
== next_boundary
)
1203 ptrdiff_t pos_here
= pos
;
1206 /* Don't skip invisible if we are already at the margin. */
1207 if (vpos
> tovpos
|| (vpos
== tovpos
&& hpos
>= tohpos
))
1209 if (contin_hpos
&& prev_hpos
== 0
1211 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1212 { /* Line breaks because we can't put the character at the
1213 previous line any more. It is not the multi-column
1214 character continued in middle. Go back to previous
1215 buffer position, screen position, and set tab offset
1216 to previous value. It's the beginning of the
1219 pos_byte
= prev_pos_byte
;
1222 tab_offset
= prev_tab_offset
;
1227 /* If the caller says that the screen position came from an earlier
1228 call to compute_motion, then we've already accounted for the
1229 overlay strings at point. This is only true the first time
1230 through, so clear the flag after testing it. */
1232 /* We need to skip past the overlay strings. Currently those
1233 strings must not contain TAB;
1234 if we want to relax that restriction, something will have
1235 to be changed here. */
1237 unsigned char *ovstr
;
1238 ptrdiff_t ovlen
= overlay_strings (pos
, win
, &ovstr
);
1239 hpos
+= ((multibyte
&& ovlen
> 0)
1240 ? strwidth ((char *) ovstr
, ovlen
) : ovlen
);
1247 /* Advance POS past invisible characters
1248 (but not necessarily all that there are here),
1249 and store in next_boundary the next position where
1250 we need to call skip_invisible. */
1251 newpos
= skip_invisible (pos
, &next_boundary
, to
, window
);
1255 pos
= min (to
, newpos
);
1256 pos_byte
= CHAR_TO_BYTE (pos
);
1260 if (newpos
!= pos_here
)
1263 pos_byte
= CHAR_TO_BYTE (pos
);
1267 /* Handle right margin. */
1268 /* Note on a wide-column character.
1270 Characters are classified into the following three categories
1271 according to the width (columns occupied on screen).
1273 (1) single-column character: ex. `a'
1274 (2) multi-column character: ex. `^A', TAB, `\033'
1275 (3) wide-column character: ex. Japanese character, Chinese character
1276 (In the following example, `W_' stands for them.)
1278 Multi-column characters can be divided around the right margin,
1279 but wide-column characters cannot.
1283 (*) The cursor is placed on the next character after the point.
1287 j ^---- next after the point
1288 ^--- next char. after the point.
1290 In case of sigle-column character
1294 033 ^---- next after the point, next char. after the point.
1296 In case of multi-column character
1300 W_ ^---- next after the point
1301 ^---- next char. after the point.
1303 In case of wide-column character
1305 The problem here is continuation at a wide-column character.
1306 In this case, the line may shorter less than WIDTH.
1307 And we find the continuation AFTER it occurs.
1313 EMACS_INT total_width
= width
+ continuation_glyph_width
;
1316 if (!NILP (Vtruncate_partial_width_windows
)
1317 && (total_width
< FRAME_COLS (XFRAME (WINDOW_FRAME (win
)))))
1319 if (INTEGERP (Vtruncate_partial_width_windows
))
1321 = total_width
< XFASTINT (Vtruncate_partial_width_windows
);
1326 if (hscroll
|| truncate
1327 || !NILP (BVAR (current_buffer
, truncate_lines
)))
1329 /* Truncating: skip to newline, unless we are already past
1330 TO (we need to go back below). */
1333 pos
= find_before_next_newline (pos
, to
, 1);
1334 pos_byte
= CHAR_TO_BYTE (pos
);
1336 /* If we just skipped next_boundary,
1337 loop around in the main while
1339 if (pos
>= next_boundary
)
1340 next_boundary
= pos
+ 1;
1343 prev_tab_offset
= tab_offset
;
1349 /* Remember the previous value. */
1350 prev_tab_offset
= tab_offset
;
1352 if (wide_column_end_hpos
> width
)
1355 tab_offset
+= prev_hpos
;
1359 tab_offset
+= width
;
1363 contin_hpos
= prev_hpos
;
1369 /* Stop if past the target buffer position or screen position. */
1372 /* Go back to the previous position. */
1374 pos_byte
= prev_pos_byte
;
1377 tab_offset
= prev_tab_offset
;
1379 /* NOTE on contin_hpos, hpos, and prev_hpos.
1383 W_ ^---- contin_hpos
1389 if (contin_hpos
&& prev_hpos
== 0
1390 && contin_hpos
< width
&& !wide_column_end_hpos
)
1392 /* Line breaking occurs in the middle of multi-column
1393 character. Go back to previous line. */
1400 if (vpos
> tovpos
|| (vpos
== tovpos
&& hpos
>= tohpos
))
1402 if (contin_hpos
&& prev_hpos
== 0
1404 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1405 { /* Line breaks because we can't put the character at the
1406 previous line any more. It is not the multi-column
1407 character continued in middle. Go back to previous
1408 buffer position, screen position, and set tab offset
1409 to previous value. It's the beginning of the
1412 pos_byte
= prev_pos_byte
;
1415 tab_offset
= prev_tab_offset
;
1419 if (pos
== ZV
) /* We cannot go beyond ZV. Stop here. */
1425 prev_pos_byte
= pos_byte
;
1426 wide_column_end_hpos
= 0;
1428 /* Consult the width run cache to see if we can avoid inspecting
1429 the text character-by-character. */
1430 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
1434 = region_cache_forward (current_buffer
,
1435 current_buffer
->width_run_cache
,
1438 /* A width of zero means the character's width varies (like
1439 a tab), is meaningless (like a newline), or we just don't
1440 want to skip over it for some other reason. */
1441 if (common_width
!= 0)
1443 ptrdiff_t run_end_hpos
;
1445 /* Don't go past the final buffer posn the user
1450 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1452 /* Don't go past the final horizontal position the user
1454 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
1456 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
1457 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1460 /* Don't go past the margin. */
1461 if (run_end_hpos
>= width
)
1463 run_end
= pos
+ (width
- hpos
) / common_width
;
1464 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1467 hpos
= run_end_hpos
;
1469 prev_hpos
= hpos
- common_width
;
1473 pos_byte
= CHAR_TO_BYTE (pos
);
1477 next_width_run
= run_end
+ 1;
1480 /* We have to scan the text character-by-character. */
1484 Lisp_Object charvec
;
1486 /* Check composition sequence. */
1488 || (pos
== cmp_it
.stop_pos
1489 && composition_reseat_it (&cmp_it
, pos
, pos_byte
, to
, win
,
1491 composition_update_it (&cmp_it
, pos
, pos_byte
, Qnil
);
1494 pos
+= cmp_it
.nchars
;
1495 pos_byte
+= cmp_it
.nbytes
;
1496 hpos
+= cmp_it
.width
;
1497 if (cmp_it
.to
== cmp_it
.nglyphs
)
1500 composition_compute_stop_pos (&cmp_it
, pos
, pos_byte
, to
,
1504 cmp_it
.from
= cmp_it
.to
;
1508 c
= FETCH_BYTE (pos_byte
);
1511 /* Perhaps add some info to the width_run_cache. */
1512 if (current_buffer
->width_run_cache
)
1514 /* Is this character part of the current run? If so, extend
1516 if (pos
- 1 == width_run_end
1517 && XFASTINT (width_table
[c
]) == width_run_width
)
1518 width_run_end
= pos
;
1520 /* The previous run is over, since this is a character at a
1521 different position, or a different width. */
1524 /* Have we accumulated a run to put in the cache?
1525 (Currently, we only cache runs of width == 1). */
1526 if (width_run_start
< width_run_end
1527 && width_run_width
== 1)
1528 know_region_cache (current_buffer
,
1529 current_buffer
->width_run_cache
,
1530 width_run_start
, width_run_end
);
1532 /* Start recording a new width run. */
1533 width_run_width
= XFASTINT (width_table
[c
]);
1534 width_run_start
= pos
- 1;
1535 width_run_end
= pos
;
1540 && ! (multibyte
&& LEADING_CODE_P (c
))
1541 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1543 charvec
= DISP_CHAR_VECTOR (dp
, c
);
1544 n
= ASIZE (charvec
);
1552 for (i
= 0; i
< n
; ++i
)
1554 if (VECTORP (charvec
))
1556 /* This should be handled the same as
1557 next_element_from_display_vector does it. */
1558 Lisp_Object entry
= AREF (charvec
, i
);
1560 if (GLYPH_CODE_P (entry
))
1561 c
= GLYPH_CODE_CHAR (entry
);
1566 if (c
>= 040 && c
< 0177)
1570 int tem
= ((hpos
+ tab_offset
+ hscroll
- (hscroll
> 0))
1574 hpos
+= tab_width
- tem
;
1579 && indented_beyond_p (pos
, pos_byte
, selective
))
1581 /* If (pos == to), we don't have to take care of
1582 selective display. */
1585 /* Skip any number of invisible lines all at once */
1588 pos
= find_before_next_newline (pos
, to
, 1);
1591 pos_byte
= CHAR_TO_BYTE (pos
);
1594 && indented_beyond_p (pos
, pos_byte
,
1596 /* Allow for the " ..." that is displayed for them. */
1599 hpos
+= selective_rlen
;
1603 DEC_BOTH (pos
, pos_byte
);
1604 /* We have skipped the invis text, but not the
1610 /* A visible line. */
1614 /* Count the truncation glyph on column 0 */
1616 hpos
+= continuation_glyph_width
;
1621 else if (c
== CR
&& selective
< 0)
1623 /* In selective display mode,
1624 everything from a ^M to the end of the line is invisible.
1625 Stop *before* the real newline. */
1628 pos
= find_before_next_newline (pos
, to
, 1);
1629 pos_byte
= CHAR_TO_BYTE (pos
);
1631 /* If we just skipped next_boundary,
1632 loop around in the main while
1634 if (pos
> next_boundary
)
1635 next_boundary
= pos
;
1636 /* Allow for the " ..." that is displayed for them. */
1639 hpos
+= selective_rlen
;
1644 else if (multibyte
&& LEADING_CODE_P (c
))
1646 /* Start of multi-byte form. */
1648 int mb_bytes
, mb_width
;
1650 pos_byte
--; /* rewind POS_BYTE */
1651 ptr
= BYTE_POS_ADDR (pos_byte
);
1652 MULTIBYTE_BYTES_WIDTH (ptr
, dp
, mb_bytes
, mb_width
);
1653 pos_byte
+= mb_bytes
;
1654 if (mb_width
> 1 && BYTES_BY_CHAR_HEAD (*ptr
) == mb_bytes
)
1655 wide_column_end_hpos
= hpos
+ mb_width
;
1658 else if (VECTORP (charvec
))
1661 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
1668 /* Remember any final width run in the cache. */
1669 if (current_buffer
->width_run_cache
1670 && width_run_width
== 1
1671 && width_run_start
< width_run_end
)
1672 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
1673 width_run_start
, width_run_end
);
1675 val_compute_motion
.bufpos
= pos
;
1676 val_compute_motion
.bytepos
= pos_byte
;
1677 val_compute_motion
.hpos
= hpos
;
1678 val_compute_motion
.vpos
= vpos
;
1679 if (contin_hpos
&& prev_hpos
== 0)
1680 val_compute_motion
.prevhpos
= contin_hpos
;
1682 val_compute_motion
.prevhpos
= prev_hpos
;
1684 /* Nonzero if have just continued a line */
1685 val_compute_motion
.contin
= (contin_hpos
&& prev_hpos
== 0);
1688 return &val_compute_motion
;
1692 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
1693 doc
: /* Scan through the current buffer, calculating screen position.
1694 Scan the current buffer forward from offset FROM,
1695 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--
1696 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--
1697 and return the ending buffer position and screen location.
1699 If TOPOS is nil, the actual width and height of the window's
1702 There are three additional arguments:
1704 WIDTH is the number of columns available to display text;
1705 this affects handling of continuation lines. A value of nil
1706 corresponds to the actual number of available text columns.
1708 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).
1709 HSCROLL is the number of columns not being displayed at the left
1710 margin; this is usually taken from a window's hscroll member.
1711 TAB-OFFSET is the number of columns of the first tab that aren't
1712 being displayed, perhaps because the line was continued within it.
1713 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.
1715 WINDOW is the window to operate on. It is used to choose the display table;
1716 if it is showing the current buffer, it is used also for
1717 deciding which overlay properties apply.
1718 Note that `compute-motion' always operates on the current buffer.
1720 The value is a list of five elements:
1721 (POS HPOS VPOS PREVHPOS CONTIN)
1722 POS is the buffer position where the scan stopped.
1723 VPOS is the vertical position where the scan stopped.
1724 HPOS is the horizontal position where the scan stopped.
1726 PREVHPOS is the horizontal position one character back from POS.
1727 CONTIN is t if a line was continued after (or within) the previous character.
1729 For example, to find the buffer position of column COL of line LINE
1730 of a certain window, pass the window's starting location as FROM
1731 and the window's upper-left coordinates as FROMPOS.
1732 Pass the buffer's (point-max) as TO, to limit the scan to the end of the
1733 visible section of the buffer, and pass LINE and COL as TOPOS. */)
1734 (Lisp_Object from
, Lisp_Object frompos
, Lisp_Object to
, Lisp_Object topos
, Lisp_Object width
, Lisp_Object offsets
, Lisp_Object window
)
1737 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
;
1738 struct position
*pos
;
1742 CHECK_NUMBER_COERCE_MARKER (from
);
1743 CHECK_CONS (frompos
);
1744 CHECK_NUMBER_CAR (frompos
);
1745 CHECK_NUMBER_CDR (frompos
);
1746 CHECK_NUMBER_COERCE_MARKER (to
);
1750 CHECK_NUMBER_CAR (topos
);
1751 CHECK_NUMBER_CDR (topos
);
1754 CHECK_NUMBER (width
);
1756 if (!NILP (offsets
))
1758 CHECK_CONS (offsets
);
1759 CHECK_NUMBER_CAR (offsets
);
1760 CHECK_NUMBER_CDR (offsets
);
1761 if (! (0 <= XINT (XCAR (offsets
)) && XINT (XCAR (offsets
)) <= PTRDIFF_MAX
1762 && 0 <= XINT (XCDR (offsets
)) && XINT (XCDR (offsets
)) <= INT_MAX
))
1763 args_out_of_range (XCAR (offsets
), XCDR (offsets
));
1764 hscroll
= XINT (XCAR (offsets
));
1765 tab_offset
= XINT (XCDR (offsets
));
1768 hscroll
= tab_offset
= 0;
1771 window
= Fselected_window ();
1773 CHECK_LIVE_WINDOW (window
);
1774 w
= XWINDOW (window
);
1776 if (XINT (from
) < BEGV
|| XINT (from
) > ZV
)
1777 args_out_of_range_3 (from
, make_number (BEGV
), make_number (ZV
));
1778 if (XINT (to
) < BEGV
|| XINT (to
) > ZV
)
1779 args_out_of_range_3 (to
, make_number (BEGV
), make_number (ZV
));
1781 pos
= compute_motion (XINT (from
), XINT (XCDR (frompos
)),
1782 XINT (XCAR (frompos
)), 0,
1785 ? window_internal_height (w
)
1786 : XINT (XCDR (topos
))),
1788 ? (window_body_cols (w
)
1790 #ifdef HAVE_WINDOW_SYSTEM
1791 FRAME_WINDOW_P (XFRAME (w
->frame
)) ? 0 :
1794 : XINT (XCAR (topos
))),
1795 (NILP (width
) ? -1 : XINT (width
)),
1796 hscroll
, tab_offset
,
1799 XSETFASTINT (bufpos
, pos
->bufpos
);
1800 XSETINT (hpos
, pos
->hpos
);
1801 XSETINT (vpos
, pos
->vpos
);
1802 XSETINT (prevhpos
, pos
->prevhpos
);
1804 return Fcons (bufpos
,
1808 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
1812 /* Fvertical_motion and vmotion */
1814 static struct position val_vmotion
;
1817 vmotion (register ptrdiff_t from
, register EMACS_INT vtarget
, struct window
*w
)
1819 ptrdiff_t hscroll
= XINT (w
->hscroll
);
1820 struct position pos
;
1821 /* vpos is cumulative vertical position, changed as from is changed */
1822 register EMACS_INT vpos
= 0;
1824 register ptrdiff_t first
;
1825 ptrdiff_t from_byte
;
1826 ptrdiff_t lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1828 = (INTEGERP (BVAR (current_buffer
, selective_display
))
1829 ? clip_to_bounds (-1, XINT (BVAR (current_buffer
, selective_display
)),
1831 : !NILP (BVAR (current_buffer
, selective_display
)) ? -1 : 0);
1834 /* This is the object we use for fetching character properties. */
1835 Lisp_Object text_prop_object
;
1837 XSETWINDOW (window
, w
);
1839 /* If the window contains this buffer, use it for getting text properties.
1840 Otherwise use the current buffer as arg for doing that. */
1841 if (EQ (w
->buffer
, Fcurrent_buffer ()))
1842 text_prop_object
= window
;
1844 text_prop_object
= Fcurrent_buffer ();
1846 if (vpos
>= vtarget
)
1848 /* To move upward, go a line at a time until
1849 we have gone at least far enough. */
1853 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1855 Lisp_Object propval
;
1857 prevline
= find_next_newline_no_quit (from
- 1, -1);
1858 while (prevline
> BEGV
1860 && indented_beyond_p (prevline
,
1861 CHAR_TO_BYTE (prevline
),
1863 /* Watch out for newlines with `invisible' property.
1864 When moving upward, check the newline before. */
1865 || (propval
= Fget_char_property (make_number (prevline
- 1),
1868 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1869 prevline
= find_next_newline_no_quit (prevline
- 1, -1);
1870 pos
= *compute_motion (prevline
, 0,
1874 /* Don't care for VPOS... */
1875 1 << (BITS_PER_SHORT
- 1),
1877 1 << (BITS_PER_SHORT
- 1),
1886 /* If we made exactly the desired vertical distance,
1887 or if we hit beginning of buffer,
1888 return point found */
1889 if (vpos
>= vtarget
)
1891 val_vmotion
.bufpos
= from
;
1892 val_vmotion
.bytepos
= CHAR_TO_BYTE (from
);
1893 val_vmotion
.vpos
= vpos
;
1894 val_vmotion
.hpos
= lmargin
;
1895 val_vmotion
.contin
= 0;
1896 val_vmotion
.prevhpos
= 0;
1897 return &val_vmotion
;
1900 /* Otherwise find the correct spot by moving down */
1902 /* Moving downward is simple, but must calculate from beg of line
1903 to determine hpos of starting point */
1904 from_byte
= CHAR_TO_BYTE (from
);
1905 if (from
> BEGV
&& FETCH_BYTE (from_byte
- 1) != '\n')
1907 Lisp_Object propval
;
1909 prevline
= find_next_newline_no_quit (from
, -1);
1910 while (prevline
> BEGV
1912 && indented_beyond_p (prevline
,
1913 CHAR_TO_BYTE (prevline
),
1915 /* Watch out for newlines with `invisible' property.
1916 When moving downward, check the newline after. */
1917 || (propval
= Fget_char_property (make_number (prevline
),
1920 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1921 prevline
= find_next_newline_no_quit (prevline
- 1, -1);
1922 pos
= *compute_motion (prevline
, 0,
1926 /* Don't care for VPOS... */
1927 1 << (BITS_PER_SHORT
- 1),
1929 1 << (BITS_PER_SHORT
- 1),
1941 return compute_motion (from
, vpos
, pos
.hpos
, did_motion
,
1942 ZV
, vtarget
, - (1 << (BITS_PER_SHORT
- 1)),
1948 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
1949 doc
: /* Move point to start of the screen line LINES lines down.
1950 If LINES is negative, this means moving up.
1952 This function is an ordinary cursor motion function
1953 which calculates the new position based on how text would be displayed.
1954 The new position may be the start of a line,
1955 or just the start of a continuation line.
1956 The function returns number of screen lines moved over;
1957 that usually equals LINES, but may be closer to zero
1958 if beginning or end of buffer was reached.
1960 The optional second argument WINDOW specifies the window to use for
1961 parameters such as width, horizontal scrolling, and so on.
1962 The default is to use the selected window's parameters.
1964 LINES can optionally take the form (COLS . LINES), in which case
1965 the motion will not stop at the start of a screen line but on
1966 its column COLS (if such exists on that line, that is).
1968 `vertical-motion' always uses the current buffer,
1969 regardless of which buffer is displayed in WINDOW.
1970 This is consistent with other cursor motion functions
1971 and makes it possible to use `vertical-motion' in any buffer,
1972 whether or not it is currently displayed in some window. */)
1973 (Lisp_Object lines
, Lisp_Object window
)
1978 Lisp_Object old_buffer
;
1979 EMACS_INT old_charpos
IF_LINT (= 0), old_bytepos
IF_LINT (= 0);
1980 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1981 Lisp_Object lcols
= Qnil
;
1982 double cols
IF_LINT (= 0);
1983 void *itdata
= NULL
;
1985 /* Allow LINES to be of the form (HPOS . VPOS) aka (COLUMNS . LINES). */
1986 if (CONSP (lines
) && (NUMBERP (XCAR (lines
))))
1988 lcols
= XCAR (lines
);
1989 cols
= INTEGERP (lcols
) ? (double) XINT (lcols
) : XFLOAT_DATA (lcols
);
1990 lines
= XCDR (lines
);
1993 CHECK_NUMBER (lines
);
1994 if (! NILP (window
))
1995 CHECK_WINDOW (window
);
1997 window
= selected_window
;
1998 w
= XWINDOW (window
);
2001 GCPRO3 (old_buffer
, old_charpos
, old_bytepos
);
2002 if (XBUFFER (w
->buffer
) != current_buffer
)
2004 /* Set the window's buffer temporarily to the current buffer. */
2005 old_buffer
= w
->buffer
;
2006 old_charpos
= XMARKER (w
->pointm
)->charpos
;
2007 old_bytepos
= XMARKER (w
->pointm
)->bytepos
;
2008 XSETBUFFER (w
->buffer
, current_buffer
);
2010 (w
->pointm
, w
->buffer
, BUF_PT (current_buffer
), BUF_PT_BYTE (current_buffer
));
2015 struct position pos
;
2016 pos
= *vmotion (PT
, XINT (lines
), w
);
2017 SET_PT_BOTH (pos
.bufpos
, pos
.bytepos
);
2021 ptrdiff_t it_start
, it_overshoot_count
= 0;
2023 int overshoot_handled
= 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
);
2041 it_overshoot_count
++;
2043 if (!it_overshoot_count
)
2044 it_overshoot_count
= -1;
2047 it_overshoot_count
=
2048 !(it
.method
== GET_FROM_IMAGE
|| it
.method
== GET_FROM_STRETCH
);
2050 /* Scan from the start of the line containing PT. If we don't
2051 do this, we start moving with IT->current_x == 0, while PT is
2052 really at some x > 0. */
2053 reseat_at_previous_visible_line_start (&it
);
2054 it
.current_x
= it
.hpos
= 0;
2055 if (IT_CHARPOS (it
) != PT
)
2056 /* We used to temporarily disable selective display here; the
2057 comment said this is "so we don't move too far" (2005-01-19
2058 checkin by kfs). But this does nothing useful that I can
2059 tell, and it causes Bug#2694 . -- cyd */
2060 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
2062 /* IT may move too far if truncate-lines is on and PT lies
2063 beyond the right margin. IT may also move too far if the
2064 starting point is on a Lisp string that has embedded
2065 newlines. In these cases, backtrack. */
2066 if (IT_CHARPOS (it
) > it_start
)
2068 /* We need to backtrack also if the Lisp string contains no
2069 newlines, but there is a newline right after it. In this
2070 case, IT overshoots if there is an after-string just
2071 before the newline. */
2072 if (it_overshoot_count
< 0
2073 && it
.method
== GET_FROM_BUFFER
2075 it_overshoot_count
= 1;
2076 if (it_overshoot_count
> 0)
2077 move_it_by_lines (&it
, -it_overshoot_count
);
2079 overshoot_handled
= 1;
2081 if (XINT (lines
) <= 0)
2084 /* Do this even if LINES is 0, so that we move back to the
2085 beginning of the current line as we ought. */
2086 if (XINT (lines
) == 0 || IT_CHARPOS (it
) > 0)
2087 move_it_by_lines (&it
, max (PTRDIFF_MIN
, XINT (lines
)));
2089 else if (overshoot_handled
)
2092 move_it_by_lines (&it
, min (PTRDIFF_MAX
, XINT (lines
)));
2096 /* Otherwise, we are at the first row occupied by PT, which
2097 might span multiple screen lines (e.g., if it's on a
2098 multi-line display string). We want to start from the
2099 last line that it occupies. */
2102 while (IT_CHARPOS (it
) <= it_start
)
2105 move_it_by_lines (&it
, 1);
2107 if (XINT (lines
) > 1)
2108 move_it_by_lines (&it
, min (PTRDIFF_MAX
, XINT (lines
) - 1));
2113 move_it_by_lines (&it
, min (PTRDIFF_MAX
, XINT (lines
)));
2117 /* Move to the goal column, if one was specified. */
2120 /* If the window was originally hscrolled, move forward by
2121 the hscrolled amount first. */
2124 move_it_in_display_line (&it
, ZV
, first_x
, MOVE_TO_X
);
2127 move_it_in_display_line
2129 (int)(cols
* FRAME_COLUMN_WIDTH (XFRAME (w
->frame
)) + 0.5),
2133 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
2134 bidi_unshelve_cache (itdata
, 0);
2137 if (BUFFERP (old_buffer
))
2139 w
->buffer
= old_buffer
;
2140 set_marker_both (w
->pointm
, w
->buffer
, old_charpos
, old_bytepos
);
2143 RETURN_UNGCPRO (make_number (it
.vpos
));
2148 /* File's initialization. */
2151 syms_of_indent (void)
2153 DEFVAR_BOOL ("indent-tabs-mode", indent_tabs_mode
,
2154 doc
: /* *Indentation can insert tabs if this is non-nil. */);
2155 indent_tabs_mode
= 1;
2157 defsubr (&Scurrent_indentation
);
2158 defsubr (&Sindent_to
);
2159 defsubr (&Scurrent_column
);
2160 defsubr (&Smove_to_column
);
2161 defsubr (&Svertical_motion
);
2162 defsubr (&Scompute_motion
);