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 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,
967 doc
: /* Move point to column COLUMN in the current line.
968 Interactively, COLUMN is the value of prefix numeric argument.
969 The column of a character is calculated by adding together the widths
970 as displayed of the previous characters in the line.
971 This function ignores line-continuation;
972 there is no upper limit on the column number a character can have
973 and horizontal scrolling has no effect.
975 If specified column is within a character, point goes after that character.
976 If it's past end of line, point goes to end of line.
978 Optional second argument FORCE non-nil means if COLUMN is in the
979 middle of a tab character, change it to spaces.
980 In addition, if FORCE is t, and the line is too short to reach
981 COLUMN, add spaces/tabs to get there.
983 The return value is the current column. */)
984 (Lisp_Object column
, Lisp_Object force
)
986 ptrdiff_t pos
, prev_col
;
990 CHECK_NATNUM (column
);
991 goal
= XINT (column
);
995 scan_for_column (&pos
, &col
, &prev_col
);
999 /* If a tab char made us overshoot, change it to spaces
1000 and scan through it again. */
1001 if (!NILP (force
) && col
> goal
)
1004 ptrdiff_t pos_byte
= PT_BYTE
;
1007 c
= FETCH_CHAR (pos_byte
);
1008 if (c
== '\t' && prev_col
< goal
)
1010 ptrdiff_t goal_pt
, goal_pt_byte
;
1012 /* Insert spaces in front of the tab to reach GOAL. Do this
1013 first so that a marker at the end of the tab gets
1015 SET_PT_BOTH (PT
- 1, PT_BYTE
- 1);
1016 Finsert_char (make_number (' '), make_number (goal
- prev_col
), Qt
);
1018 /* Now delete the tab, and indent to COL. */
1019 del_range (PT
, PT
+ 1);
1021 goal_pt_byte
= PT_BYTE
;
1022 Findent_to (make_number (col
), Qnil
);
1023 SET_PT_BOTH (goal_pt
, goal_pt_byte
);
1025 /* Set the last_known... vars consistently. */
1030 /* If line ends prematurely, add space to the end. */
1031 if (col
< goal
&& EQ (force
, Qt
))
1032 Findent_to (make_number (col
= goal
), Qnil
);
1034 last_known_column
= col
;
1035 last_known_column_point
= PT
;
1036 last_known_column_modified
= MODIFF
;
1038 return make_number (col
);
1041 /* compute_motion: compute buffer posn given screen posn and vice versa */
1043 static struct position val_compute_motion
;
1045 /* Scan the current buffer forward from offset FROM, pretending that
1046 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
1047 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
1048 and return the ending buffer position and screen location. If we
1049 can't hit the requested column exactly (because of a tab or other
1050 multi-column character), overshoot.
1052 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
1053 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
1054 earlier call to compute_motion. The other common case is that FROMHPOS
1055 is zero and FROM is a position that "belongs" at column zero, but might
1056 be shifted by overlay strings; in this case DID_MOTION should be 0.
1058 WIDTH is the number of columns available to display text;
1059 compute_motion uses this to handle continuation lines and such.
1060 If WIDTH is -1, use width of window's text area adjusted for
1061 continuation glyph when needed.
1063 HSCROLL is the number of columns not being displayed at the left
1064 margin; this is usually taken from a window's hscroll member.
1065 TAB_OFFSET is the number of columns of the first tab that aren't
1066 being displayed, perhaps because of a continuation line or
1069 compute_motion returns a pointer to a struct position. The bufpos
1070 member gives the buffer position at the end of the scan, and hpos
1071 and vpos give its cartesian location. prevhpos is the column at
1072 which the character before bufpos started, and contin is non-zero
1073 if we reached the current line by continuing the previous.
1075 Note that FROMHPOS and TOHPOS should be expressed in real screen
1076 columns, taking HSCROLL and the truncation glyph at the left margin
1077 into account. That is, beginning-of-line moves you to the hpos
1078 -HSCROLL + (HSCROLL > 0).
1080 For example, to find the buffer position of column COL of line LINE
1081 of a certain window, pass the window's starting location as FROM
1082 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
1083 Pass the buffer's ZV as TO, to limit the scan to the end of the
1084 visible section of the buffer, and pass LINE and COL as TOVPOS and
1087 When displaying in window w, a typical formula for WIDTH is:
1090 - (has_vertical_scroll_bars
1091 ? WINDOW_CONFIG_SCROLL_BAR_COLS (window)
1092 : (window_width + window_left != frame_cols))
1095 window_width is XFASTINT (w->total_cols),
1096 window_left is XFASTINT (w->left_col),
1097 has_vertical_scroll_bars is
1098 WINDOW_HAS_VERTICAL_SCROLL_BAR (window)
1099 and frame_cols = FRAME_COLS (XFRAME (window->frame))
1101 Or you can let window_body_cols do this all for you, and write:
1102 window_body_cols (w) - 1
1104 The `-1' accounts for the continuation-line backslashes; the rest
1105 accounts for window borders if the window is split horizontally, and
1106 the scroll bars if they are turned on. */
1109 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
)
1111 register EMACS_INT hpos
= fromhpos
;
1112 register EMACS_INT vpos
= fromvpos
;
1114 register ptrdiff_t pos
;
1117 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
1118 register int ctl_arrow
= !NILP (BVAR (current_buffer
, ctl_arrow
));
1119 register struct Lisp_Char_Table
*dp
= window_display_table (win
);
1121 = (INTEGERP (BVAR (current_buffer
, selective_display
))
1122 ? XINT (BVAR (current_buffer
, selective_display
))
1123 : !NILP (BVAR (current_buffer
, selective_display
)) ? -1 : 0);
1124 ptrdiff_t selective_rlen
1125 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
1126 ? ASIZE (DISP_INVIS_VECTOR (dp
)) : 0);
1127 /* The next location where the `invisible' property changes, or an
1128 overlay starts or ends. */
1129 ptrdiff_t next_boundary
= from
;
1131 /* For computing runs of characters with similar widths.
1132 Invariant: width_run_width is zero, or all the characters
1133 from width_run_start to width_run_end have a fixed width of
1135 ptrdiff_t width_run_start
= from
;
1136 ptrdiff_t width_run_end
= from
;
1137 ptrdiff_t width_run_width
= 0;
1138 Lisp_Object
*width_table
;
1140 /* The next buffer pos where we should consult the width run cache. */
1141 ptrdiff_t next_width_run
= from
;
1144 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 XSETWINDOW (window
, win
);
1160 width_run_cache_on_off ();
1161 if (dp
== buffer_display_table ())
1162 width_table
= (VECTORP (BVAR (current_buffer
, width_table
))
1163 ? XVECTOR (BVAR (current_buffer
, width_table
))->contents
1166 /* If the window has its own display table, we can't use the width
1167 run cache, because that's based on the buffer's display table. */
1170 /* Negative width means use all available text columns. */
1173 width
= window_body_cols (win
);
1174 /* We must make room for continuation marks if we don't have fringes. */
1175 #ifdef HAVE_WINDOW_SYSTEM
1176 if (!FRAME_WINDOW_P (XFRAME (win
->frame
)))
1181 continuation_glyph_width
= 1;
1182 #ifdef HAVE_WINDOW_SYSTEM
1183 if (FRAME_WINDOW_P (XFRAME (win
->frame
)))
1184 continuation_glyph_width
= 0; /* In the fringe. */
1190 pos
= prev_pos
= from
;
1191 pos_byte
= prev_pos_byte
= CHAR_TO_BYTE (from
);
1193 prev_tab_offset
= tab_offset
;
1194 memset (&cmp_it
, 0, sizeof cmp_it
);
1196 composition_compute_stop_pos (&cmp_it
, pos
, pos_byte
, to
, Qnil
);
1200 while (pos
== next_boundary
)
1202 ptrdiff_t pos_here
= pos
;
1205 /* Don't skip invisible if we are already at the margin. */
1206 if (vpos
> tovpos
|| (vpos
== tovpos
&& hpos
>= tohpos
))
1208 if (contin_hpos
&& prev_hpos
== 0
1210 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1211 { /* Line breaks because we can't put the character at the
1212 previous line any more. It is not the multi-column
1213 character continued in middle. Go back to previous
1214 buffer position, screen position, and set tab offset
1215 to previous value. It's the beginning of the
1218 pos_byte
= prev_pos_byte
;
1221 tab_offset
= prev_tab_offset
;
1226 /* If the caller says that the screen position came from an earlier
1227 call to compute_motion, then we've already accounted for the
1228 overlay strings at point. This is only true the first time
1229 through, so clear the flag after testing it. */
1231 /* We need to skip past the overlay strings. Currently those
1232 strings must not contain TAB;
1233 if we want to relax that restriction, something will have
1234 to be changed here. */
1236 unsigned char *ovstr
;
1237 ptrdiff_t ovlen
= overlay_strings (pos
, win
, &ovstr
);
1238 hpos
+= ((multibyte
&& ovlen
> 0)
1239 ? strwidth ((char *) ovstr
, ovlen
) : ovlen
);
1246 /* Advance POS past invisible characters
1247 (but not necessarily all that there are here),
1248 and store in next_boundary the next position where
1249 we need to call skip_invisible. */
1250 newpos
= skip_invisible (pos
, &next_boundary
, to
, window
);
1254 pos
= min (to
, newpos
);
1255 pos_byte
= CHAR_TO_BYTE (pos
);
1259 if (newpos
!= pos_here
)
1262 pos_byte
= CHAR_TO_BYTE (pos
);
1266 /* Handle right margin. */
1267 /* Note on a wide-column character.
1269 Characters are classified into the following three categories
1270 according to the width (columns occupied on screen).
1272 (1) single-column character: ex. `a'
1273 (2) multi-column character: ex. `^A', TAB, `\033'
1274 (3) wide-column character: ex. Japanese character, Chinese character
1275 (In the following example, `W_' stands for them.)
1277 Multi-column characters can be divided around the right margin,
1278 but wide-column characters cannot.
1282 (*) The cursor is placed on the next character after the point.
1286 j ^---- next after the point
1287 ^--- next char. after the point.
1289 In case of sigle-column character
1293 033 ^---- next after the point, next char. after the point.
1295 In case of multi-column character
1299 W_ ^---- next after the point
1300 ^---- next char. after the point.
1302 In case of wide-column character
1304 The problem here is continuation at a wide-column character.
1305 In this case, the line may shorter less than WIDTH.
1306 And we find the continuation AFTER it occurs.
1312 EMACS_INT total_width
= width
+ continuation_glyph_width
;
1315 if (!NILP (Vtruncate_partial_width_windows
)
1316 && (total_width
< FRAME_COLS (XFRAME (WINDOW_FRAME (win
)))))
1318 if (INTEGERP (Vtruncate_partial_width_windows
))
1320 = total_width
< XFASTINT (Vtruncate_partial_width_windows
);
1325 if (hscroll
|| truncate
1326 || !NILP (BVAR (current_buffer
, truncate_lines
)))
1328 /* Truncating: skip to newline, unless we are already past
1329 TO (we need to go back below). */
1332 pos
= find_before_next_newline (pos
, to
, 1);
1333 pos_byte
= CHAR_TO_BYTE (pos
);
1335 /* If we just skipped next_boundary,
1336 loop around in the main while
1338 if (pos
>= next_boundary
)
1339 next_boundary
= pos
+ 1;
1342 prev_tab_offset
= tab_offset
;
1348 /* Remember the previous value. */
1349 prev_tab_offset
= tab_offset
;
1351 if (wide_column_end_hpos
> width
)
1354 tab_offset
+= prev_hpos
;
1358 tab_offset
+= width
;
1362 contin_hpos
= prev_hpos
;
1368 /* Stop if past the target buffer position or screen position. */
1371 /* Go back to the previous position. */
1373 pos_byte
= prev_pos_byte
;
1376 tab_offset
= prev_tab_offset
;
1378 /* NOTE on contin_hpos, hpos, and prev_hpos.
1382 W_ ^---- contin_hpos
1388 if (contin_hpos
&& prev_hpos
== 0
1389 && contin_hpos
< width
&& !wide_column_end_hpos
)
1391 /* Line breaking occurs in the middle of multi-column
1392 character. Go back to previous line. */
1399 if (vpos
> tovpos
|| (vpos
== tovpos
&& hpos
>= tohpos
))
1401 if (contin_hpos
&& prev_hpos
== 0
1403 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1404 { /* Line breaks because we can't put the character at the
1405 previous line any more. It is not the multi-column
1406 character continued in middle. Go back to previous
1407 buffer position, screen position, and set tab offset
1408 to previous value. It's the beginning of the
1411 pos_byte
= prev_pos_byte
;
1414 tab_offset
= prev_tab_offset
;
1418 if (pos
== ZV
) /* We cannot go beyond ZV. Stop here. */
1424 prev_pos_byte
= pos_byte
;
1425 wide_column_end_hpos
= 0;
1427 /* Consult the width run cache to see if we can avoid inspecting
1428 the text character-by-character. */
1429 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
1433 = region_cache_forward (current_buffer
,
1434 current_buffer
->width_run_cache
,
1437 /* A width of zero means the character's width varies (like
1438 a tab), is meaningless (like a newline), or we just don't
1439 want to skip over it for some other reason. */
1440 if (common_width
!= 0)
1442 ptrdiff_t run_end_hpos
;
1444 /* Don't go past the final buffer posn the user
1449 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1451 /* Don't go past the final horizontal position the user
1453 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
1455 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
1456 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1459 /* Don't go past the margin. */
1460 if (run_end_hpos
>= width
)
1462 run_end
= pos
+ (width
- hpos
) / common_width
;
1463 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1466 hpos
= run_end_hpos
;
1468 prev_hpos
= hpos
- common_width
;
1472 pos_byte
= CHAR_TO_BYTE (pos
);
1476 next_width_run
= run_end
+ 1;
1479 /* We have to scan the text character-by-character. */
1483 Lisp_Object charvec
;
1485 /* Check composition sequence. */
1487 || (pos
== cmp_it
.stop_pos
1488 && composition_reseat_it (&cmp_it
, pos
, pos_byte
, to
, win
,
1490 composition_update_it (&cmp_it
, pos
, pos_byte
, Qnil
);
1493 pos
+= cmp_it
.nchars
;
1494 pos_byte
+= cmp_it
.nbytes
;
1495 hpos
+= cmp_it
.width
;
1496 if (cmp_it
.to
== cmp_it
.nglyphs
)
1499 composition_compute_stop_pos (&cmp_it
, pos
, pos_byte
, to
,
1503 cmp_it
.from
= cmp_it
.to
;
1507 c
= FETCH_BYTE (pos_byte
);
1510 /* Perhaps add some info to the width_run_cache. */
1511 if (current_buffer
->width_run_cache
)
1513 /* Is this character part of the current run? If so, extend
1515 if (pos
- 1 == width_run_end
1516 && XFASTINT (width_table
[c
]) == width_run_width
)
1517 width_run_end
= pos
;
1519 /* The previous run is over, since this is a character at a
1520 different position, or a different width. */
1523 /* Have we accumulated a run to put in the cache?
1524 (Currently, we only cache runs of width == 1). */
1525 if (width_run_start
< width_run_end
1526 && width_run_width
== 1)
1527 know_region_cache (current_buffer
,
1528 current_buffer
->width_run_cache
,
1529 width_run_start
, width_run_end
);
1531 /* Start recording a new width run. */
1532 width_run_width
= XFASTINT (width_table
[c
]);
1533 width_run_start
= pos
- 1;
1534 width_run_end
= pos
;
1539 && ! (multibyte
&& LEADING_CODE_P (c
))
1540 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1542 charvec
= DISP_CHAR_VECTOR (dp
, c
);
1543 n
= ASIZE (charvec
);
1551 for (i
= 0; i
< n
; ++i
)
1553 if (VECTORP (charvec
))
1555 /* This should be handled the same as
1556 next_element_from_display_vector does it. */
1557 Lisp_Object entry
= AREF (charvec
, i
);
1559 if (GLYPH_CODE_P (entry
))
1560 c
= GLYPH_CODE_CHAR (entry
);
1565 if (c
>= 040 && c
< 0177)
1569 int tem
= ((hpos
+ tab_offset
+ hscroll
- (hscroll
> 0))
1573 hpos
+= tab_width
- tem
;
1578 && indented_beyond_p (pos
, pos_byte
, selective
))
1580 /* If (pos == to), we don't have to take care of
1581 selective display. */
1584 /* Skip any number of invisible lines all at once */
1587 pos
= find_before_next_newline (pos
, to
, 1);
1590 pos_byte
= CHAR_TO_BYTE (pos
);
1593 && indented_beyond_p (pos
, pos_byte
,
1595 /* Allow for the " ..." that is displayed for them. */
1598 hpos
+= selective_rlen
;
1602 DEC_BOTH (pos
, pos_byte
);
1603 /* We have skipped the invis text, but not the
1609 /* A visible line. */
1613 /* Count the truncation glyph on column 0 */
1615 hpos
+= continuation_glyph_width
;
1620 else if (c
== CR
&& selective
< 0)
1622 /* In selective display mode,
1623 everything from a ^M to the end of the line is invisible.
1624 Stop *before* the real newline. */
1627 pos
= find_before_next_newline (pos
, to
, 1);
1628 pos_byte
= CHAR_TO_BYTE (pos
);
1630 /* If we just skipped next_boundary,
1631 loop around in the main while
1633 if (pos
> next_boundary
)
1634 next_boundary
= pos
;
1635 /* Allow for the " ..." that is displayed for them. */
1638 hpos
+= selective_rlen
;
1643 else if (multibyte
&& LEADING_CODE_P (c
))
1645 /* Start of multi-byte form. */
1647 int mb_bytes
, mb_width
;
1649 pos_byte
--; /* rewind POS_BYTE */
1650 ptr
= BYTE_POS_ADDR (pos_byte
);
1651 MULTIBYTE_BYTES_WIDTH (ptr
, dp
, mb_bytes
, mb_width
);
1652 pos_byte
+= mb_bytes
;
1653 if (mb_width
> 1 && BYTES_BY_CHAR_HEAD (*ptr
) == mb_bytes
)
1654 wide_column_end_hpos
= hpos
+ mb_width
;
1657 else if (VECTORP (charvec
))
1660 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
1667 /* Remember any final width run in the cache. */
1668 if (current_buffer
->width_run_cache
1669 && width_run_width
== 1
1670 && width_run_start
< width_run_end
)
1671 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
1672 width_run_start
, width_run_end
);
1674 val_compute_motion
.bufpos
= pos
;
1675 val_compute_motion
.bytepos
= pos_byte
;
1676 val_compute_motion
.hpos
= hpos
;
1677 val_compute_motion
.vpos
= vpos
;
1678 if (contin_hpos
&& prev_hpos
== 0)
1679 val_compute_motion
.prevhpos
= contin_hpos
;
1681 val_compute_motion
.prevhpos
= prev_hpos
;
1683 /* Nonzero if have just continued a line */
1684 val_compute_motion
.contin
= (contin_hpos
&& prev_hpos
== 0);
1687 return &val_compute_motion
;
1691 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
1692 doc
: /* Scan through the current buffer, calculating screen position.
1693 Scan the current buffer forward from offset FROM,
1694 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--
1695 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--
1696 and return the ending buffer position and screen location.
1698 If TOPOS is nil, the actual width and height of the window's
1701 There are three additional arguments:
1703 WIDTH is the number of columns available to display text;
1704 this affects handling of continuation lines. A value of nil
1705 corresponds to the actual number of available text columns.
1707 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).
1708 HSCROLL is the number of columns not being displayed at the left
1709 margin; this is usually taken from a window's hscroll member.
1710 TAB-OFFSET is the number of columns of the first tab that aren't
1711 being displayed, perhaps because the line was continued within it.
1712 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.
1714 WINDOW is the window to operate on. It is used to choose the display table;
1715 if it is showing the current buffer, it is used also for
1716 deciding which overlay properties apply.
1717 Note that `compute-motion' always operates on the current buffer.
1719 The value is a list of five elements:
1720 (POS HPOS VPOS PREVHPOS CONTIN)
1721 POS is the buffer position where the scan stopped.
1722 VPOS is the vertical position where the scan stopped.
1723 HPOS is the horizontal position where the scan stopped.
1725 PREVHPOS is the horizontal position one character back from POS.
1726 CONTIN is t if a line was continued after (or within) the previous character.
1728 For example, to find the buffer position of column COL of line LINE
1729 of a certain window, pass the window's starting location as FROM
1730 and the window's upper-left coordinates as FROMPOS.
1731 Pass the buffer's (point-max) as TO, to limit the scan to the end of the
1732 visible section of the buffer, and pass LINE and COL as TOPOS. */)
1733 (Lisp_Object from
, Lisp_Object frompos
, Lisp_Object to
, Lisp_Object topos
, Lisp_Object width
, Lisp_Object offsets
, Lisp_Object window
)
1736 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
;
1737 struct position
*pos
;
1741 CHECK_NUMBER_COERCE_MARKER (from
);
1742 CHECK_CONS (frompos
);
1743 CHECK_NUMBER_CAR (frompos
);
1744 CHECK_NUMBER_CDR (frompos
);
1745 CHECK_NUMBER_COERCE_MARKER (to
);
1749 CHECK_NUMBER_CAR (topos
);
1750 CHECK_NUMBER_CDR (topos
);
1753 CHECK_NUMBER (width
);
1755 if (!NILP (offsets
))
1757 CHECK_CONS (offsets
);
1758 CHECK_NUMBER_CAR (offsets
);
1759 CHECK_NUMBER_CDR (offsets
);
1760 if (! (0 <= XINT (XCAR (offsets
)) && XINT (XCAR (offsets
)) <= PTRDIFF_MAX
1761 && 0 <= XINT (XCDR (offsets
)) && XINT (XCDR (offsets
)) <= INT_MAX
))
1762 args_out_of_range (XCAR (offsets
), XCDR (offsets
));
1763 hscroll
= XINT (XCAR (offsets
));
1764 tab_offset
= XINT (XCDR (offsets
));
1767 hscroll
= tab_offset
= 0;
1770 window
= Fselected_window ();
1772 CHECK_LIVE_WINDOW (window
);
1773 w
= XWINDOW (window
);
1775 if (XINT (from
) < BEGV
|| XINT (from
) > ZV
)
1776 args_out_of_range_3 (from
, make_number (BEGV
), make_number (ZV
));
1777 if (XINT (to
) < BEGV
|| XINT (to
) > ZV
)
1778 args_out_of_range_3 (to
, make_number (BEGV
), make_number (ZV
));
1780 pos
= compute_motion (XINT (from
), XINT (XCDR (frompos
)),
1781 XINT (XCAR (frompos
)), 0,
1784 ? window_internal_height (w
)
1785 : XINT (XCDR (topos
))),
1787 ? (window_body_cols (w
)
1789 #ifdef HAVE_WINDOW_SYSTEM
1790 FRAME_WINDOW_P (XFRAME (w
->frame
)) ? 0 :
1793 : XINT (XCAR (topos
))),
1794 (NILP (width
) ? -1 : XINT (width
)),
1795 hscroll
, tab_offset
,
1798 XSETFASTINT (bufpos
, pos
->bufpos
);
1799 XSETINT (hpos
, pos
->hpos
);
1800 XSETINT (vpos
, pos
->vpos
);
1801 XSETINT (prevhpos
, pos
->prevhpos
);
1803 return Fcons (bufpos
,
1807 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
1811 /* Fvertical_motion and vmotion */
1813 static struct position val_vmotion
;
1816 vmotion (register ptrdiff_t from
, register EMACS_INT vtarget
, struct window
*w
)
1818 ptrdiff_t hscroll
= w
->hscroll
;
1819 struct position pos
;
1820 /* vpos is cumulative vertical position, changed as from is changed */
1821 register EMACS_INT vpos
= 0;
1823 register ptrdiff_t first
;
1824 ptrdiff_t from_byte
;
1825 ptrdiff_t lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1827 = (INTEGERP (BVAR (current_buffer
, selective_display
))
1828 ? clip_to_bounds (-1, XINT (BVAR (current_buffer
, selective_display
)),
1830 : !NILP (BVAR (current_buffer
, selective_display
)) ? -1 : 0);
1833 /* This is the object we use for fetching character properties. */
1834 Lisp_Object text_prop_object
;
1836 XSETWINDOW (window
, w
);
1838 /* If the window contains this buffer, use it for getting text properties.
1839 Otherwise use the current buffer as arg for doing that. */
1840 if (EQ (w
->buffer
, Fcurrent_buffer ()))
1841 text_prop_object
= window
;
1843 text_prop_object
= Fcurrent_buffer ();
1845 if (vpos
>= vtarget
)
1847 /* To move upward, go a line at a time until
1848 we have gone at least far enough. */
1852 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1854 Lisp_Object propval
;
1856 prevline
= find_next_newline_no_quit (from
- 1, -1);
1857 while (prevline
> BEGV
1859 && indented_beyond_p (prevline
,
1860 CHAR_TO_BYTE (prevline
),
1862 /* Watch out for newlines with `invisible' property.
1863 When moving upward, check the newline before. */
1864 || (propval
= Fget_char_property (make_number (prevline
- 1),
1867 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1868 prevline
= find_next_newline_no_quit (prevline
- 1, -1);
1869 pos
= *compute_motion (prevline
, 0,
1873 /* Don't care for VPOS... */
1874 1 << (BITS_PER_SHORT
- 1),
1876 1 << (BITS_PER_SHORT
- 1),
1885 /* If we made exactly the desired vertical distance,
1886 or if we hit beginning of buffer,
1887 return point found */
1888 if (vpos
>= vtarget
)
1890 val_vmotion
.bufpos
= from
;
1891 val_vmotion
.bytepos
= CHAR_TO_BYTE (from
);
1892 val_vmotion
.vpos
= vpos
;
1893 val_vmotion
.hpos
= lmargin
;
1894 val_vmotion
.contin
= 0;
1895 val_vmotion
.prevhpos
= 0;
1896 return &val_vmotion
;
1899 /* Otherwise find the correct spot by moving down */
1901 /* Moving downward is simple, but must calculate from beg of line
1902 to determine hpos of starting point */
1903 from_byte
= CHAR_TO_BYTE (from
);
1904 if (from
> BEGV
&& FETCH_BYTE (from_byte
- 1) != '\n')
1906 Lisp_Object propval
;
1908 prevline
= find_next_newline_no_quit (from
, -1);
1909 while (prevline
> BEGV
1911 && indented_beyond_p (prevline
,
1912 CHAR_TO_BYTE (prevline
),
1914 /* Watch out for newlines with `invisible' property.
1915 When moving downward, check the newline after. */
1916 || (propval
= Fget_char_property (make_number (prevline
),
1919 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1920 prevline
= find_next_newline_no_quit (prevline
- 1, -1);
1921 pos
= *compute_motion (prevline
, 0,
1925 /* Don't care for VPOS... */
1926 1 << (BITS_PER_SHORT
- 1),
1928 1 << (BITS_PER_SHORT
- 1),
1940 return compute_motion (from
, vpos
, pos
.hpos
, did_motion
,
1941 ZV
, vtarget
, - (1 << (BITS_PER_SHORT
- 1)),
1947 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
1948 doc
: /* Move point to start of the screen line LINES lines down.
1949 If LINES is negative, this means moving up.
1951 This function is an ordinary cursor motion function
1952 which calculates the new position based on how text would be displayed.
1953 The new position may be the start of a line,
1954 or just the start of a continuation line.
1955 The function returns number of screen lines moved over;
1956 that usually equals LINES, but may be closer to zero
1957 if beginning or end of buffer was reached.
1959 The optional second argument WINDOW specifies the window to use for
1960 parameters such as width, horizontal scrolling, and so on.
1961 The default is to use the selected window's parameters.
1963 LINES can optionally take the form (COLS . LINES), in which case
1964 the motion will not stop at the start of a screen line but on
1965 its column COLS (if such exists on that line, that is).
1967 `vertical-motion' always uses the current buffer,
1968 regardless of which buffer is displayed in WINDOW.
1969 This is consistent with other cursor motion functions
1970 and makes it possible to use `vertical-motion' in any buffer,
1971 whether or not it is currently displayed in some window. */)
1972 (Lisp_Object lines
, Lisp_Object window
)
1977 Lisp_Object old_buffer
;
1978 EMACS_INT old_charpos
IF_LINT (= 0), old_bytepos
IF_LINT (= 0);
1979 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1980 Lisp_Object lcols
= Qnil
;
1981 double cols
IF_LINT (= 0);
1982 void *itdata
= NULL
;
1984 /* Allow LINES to be of the form (HPOS . VPOS) aka (COLUMNS . LINES). */
1985 if (CONSP (lines
) && (NUMBERP (XCAR (lines
))))
1987 lcols
= XCAR (lines
);
1988 cols
= INTEGERP (lcols
) ? (double) XINT (lcols
) : XFLOAT_DATA (lcols
);
1989 lines
= XCDR (lines
);
1992 CHECK_NUMBER (lines
);
1993 if (! NILP (window
))
1994 CHECK_WINDOW (window
);
1996 window
= selected_window
;
1997 w
= XWINDOW (window
);
2000 GCPRO3 (old_buffer
, old_charpos
, old_bytepos
);
2001 if (XBUFFER (w
->buffer
) != current_buffer
)
2003 /* Set the window's buffer temporarily to the current buffer. */
2004 old_buffer
= w
->buffer
;
2005 old_charpos
= XMARKER (w
->pointm
)->charpos
;
2006 old_bytepos
= XMARKER (w
->pointm
)->bytepos
;
2007 WSET (w
, buffer
, Fcurrent_buffer ());
2008 set_marker_both (w
->pointm
, w
->buffer
,
2009 BUF_PT (current_buffer
), BUF_PT_BYTE (current_buffer
));
2014 struct position pos
;
2015 pos
= *vmotion (PT
, XINT (lines
), w
);
2016 SET_PT_BOTH (pos
.bufpos
, pos
.bytepos
);
2020 ptrdiff_t it_start
, it_overshoot_count
= 0;
2022 int overshoot_handled
= 0;
2023 int disp_string_at_start_p
= 0;
2025 itdata
= bidi_shelve_cache ();
2026 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
2027 start_display (&it
, w
, pt
);
2028 first_x
= it
.first_visible_x
;
2029 it_start
= IT_CHARPOS (it
);
2031 /* See comments below for why we calculate this. */
2032 if (it
.cmp_it
.id
>= 0)
2033 it_overshoot_count
= 0;
2034 else if (it
.method
== GET_FROM_STRING
)
2036 const char *s
= SSDATA (it
.string
);
2037 const char *e
= s
+ SBYTES (it
.string
);
2039 disp_string_at_start_p
= it
.string_from_display_prop_p
;
2043 it_overshoot_count
++;
2045 if (!it_overshoot_count
)
2046 it_overshoot_count
= -1;
2049 it_overshoot_count
=
2050 !(it
.method
== GET_FROM_IMAGE
|| it
.method
== GET_FROM_STRETCH
);
2052 /* Scan from the start of the line containing PT. If we don't
2053 do this, we start moving with IT->current_x == 0, while PT is
2054 really at some x > 0. */
2055 reseat_at_previous_visible_line_start (&it
);
2056 it
.current_x
= it
.hpos
= 0;
2057 if (IT_CHARPOS (it
) != PT
)
2058 /* We used to temporarily disable selective display here; the
2059 comment said this is "so we don't move too far" (2005-01-19
2060 checkin by kfs). But this does nothing useful that I can
2061 tell, and it causes Bug#2694 . -- cyd */
2062 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
2064 /* IT may move too far if truncate-lines is on and PT lies
2065 beyond the right margin. IT may also move too far if the
2066 starting point is on a Lisp string that has embedded
2067 newlines, or spans several screen lines. In these cases,
2069 if (IT_CHARPOS (it
) > it_start
)
2071 /* We need to backtrack also if the Lisp string contains no
2072 newlines, but there is a newline right after it. In this
2073 case, IT overshoots if there is an after-string just
2074 before the newline. */
2075 if (it_overshoot_count
< 0
2076 && it
.method
== GET_FROM_BUFFER
2078 it_overshoot_count
= 1;
2079 else if (disp_string_at_start_p
&& it
.vpos
> 0)
2081 /* This is the case of a display string that spans
2082 several screen lines. In that case, we end up at the
2083 end of the string, and it.vpos tells us how many
2084 screen lines we need to backtrack. */
2085 it_overshoot_count
= it
.vpos
;
2087 if (it_overshoot_count
> 0)
2088 move_it_by_lines (&it
, -it_overshoot_count
);
2090 overshoot_handled
= 1;
2092 if (XINT (lines
) <= 0)
2095 /* Do this even if LINES is 0, so that we move back to the
2096 beginning of the current line as we ought. */
2097 if (XINT (lines
) == 0 || IT_CHARPOS (it
) > 0)
2098 move_it_by_lines (&it
, max (PTRDIFF_MIN
, XINT (lines
)));
2100 else if (overshoot_handled
)
2103 move_it_by_lines (&it
, min (PTRDIFF_MAX
, XINT (lines
)));
2107 /* Otherwise, we are at the first row occupied by PT, which
2108 might span multiple screen lines (e.g., if it's on a
2109 multi-line display string). We want to start from the
2110 last line that it occupies. */
2113 while (IT_CHARPOS (it
) <= it_start
)
2116 move_it_by_lines (&it
, 1);
2118 if (XINT (lines
) > 1)
2119 move_it_by_lines (&it
, min (PTRDIFF_MAX
, XINT (lines
) - 1));
2124 move_it_by_lines (&it
, min (PTRDIFF_MAX
, XINT (lines
)));
2128 /* Move to the goal column, if one was specified. */
2131 /* If the window was originally hscrolled, move forward by
2132 the hscrolled amount first. */
2135 move_it_in_display_line (&it
, ZV
, first_x
, MOVE_TO_X
);
2138 move_it_in_display_line
2140 (int)(cols
* FRAME_COLUMN_WIDTH (XFRAME (w
->frame
)) + 0.5),
2144 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
2145 bidi_unshelve_cache (itdata
, 0);
2148 if (BUFFERP (old_buffer
))
2150 WSET (w
, buffer
, old_buffer
);
2151 set_marker_both (w
->pointm
, w
->buffer
,
2152 old_charpos
, old_bytepos
);
2155 RETURN_UNGCPRO (make_number (it
.vpos
));
2160 /* File's initialization. */
2163 syms_of_indent (void)
2165 DEFVAR_BOOL ("indent-tabs-mode", indent_tabs_mode
,
2166 doc
: /* Indentation can insert tabs if this is non-nil. */);
2167 indent_tabs_mode
= 1;
2169 defsubr (&Scurrent_indentation
);
2170 defsubr (&Sindent_to
);
2171 defsubr (&Scurrent_column
);
2172 defsubr (&Smove_to_column
);
2173 defsubr (&Svertical_motion
);
2174 defsubr (&Scompute_motion
);