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/>. */
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 EMACS_INT last_known_column
;
50 /* Value of point when current_column was called. */
52 EMACS_INT last_known_column_point
;
54 /* Value of MODIFF when current_column was called. */
56 static int last_known_column_modified
;
58 static EMACS_INT
current_column_1 (void);
59 static EMACS_INT
position_indentation (ptrdiff_t);
61 /* Cache of beginning of line found by the last call of
64 static EMACS_INT 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 (EMACS_INT pos
, EMACS_INT
*next_boundary_p
, EMACS_INT 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 EMACS_INT 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 && GLYPH_CODE_CHAR_VALID_P (entry
))
405 c
= GLYPH_CODE_CHAR (entry
);
410 if (c
>= 040 && c
< 0177)
414 && EQ (BVAR (current_buffer
, selective_display
), Qt
)))
417 goto start_of_line_found
;
422 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
428 else if (VECTORP (charvec
))
429 /* With a display table entry, C is displayed as is, and
430 not displayed as \NNN or as ^N. If C is a single-byte
431 character, it takes one column. If C is multi-byte in
432 an unibyte buffer, it's translated to unibyte, so it
433 also takes one column. */
436 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
444 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
448 if (ptr
== BEGV_ADDR
)
449 current_column_bol_cache
= BEGV
;
451 current_column_bol_cache
= BYTE_TO_CHAR (PTR_BYTE_POS (ptr
));
453 last_known_column
= col
;
454 last_known_column_point
= PT
;
455 last_known_column_modified
= MODIFF
;
461 /* Check the presence of a display property and compute its width.
462 If a property was found and its width was found as well, return
463 its width (>= 0) and set the position of the end of the property
465 Otherwise just return -1. */
467 check_display_width (EMACS_INT pos
, EMACS_INT col
, EMACS_INT
*endpos
)
469 Lisp_Object val
, overlay
;
471 if (CONSP (val
= get_char_property_and_overlay
472 (make_number (pos
), Qdisplay
, Qnil
, &overlay
))
473 && EQ (Qspace
, XCAR (val
)))
474 { /* FIXME: Use calc_pixel_width_or_height. */
475 Lisp_Object plist
= XCDR (val
), prop
;
478 if ((prop
= Fplist_get (plist
, QCwidth
), NATNUMP (prop
)))
480 else if (FLOATP (prop
))
481 width
= (int)(XFLOAT_DATA (prop
) + 0.5);
482 else if ((prop
= Fplist_get (plist
, QCalign_to
), NATNUMP (prop
)))
483 width
= XINT (prop
) - col
;
484 else if (FLOATP (prop
))
485 width
= (int)(XFLOAT_DATA (prop
) + 0.5) - col
;
490 if (OVERLAYP (overlay
))
491 *endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
493 get_property_and_range (pos
, Qdisplay
, &val
, &start
, endpos
, Qnil
);
500 /* Scanning from the beginning of the current line, stop at the buffer
501 position ENDPOS or at the column GOALCOL or at the end of line, whichever
503 Return the resulting buffer position and column in ENDPOS and GOALCOL.
504 PREVCOL gets set to the column of the previous position (it's always
505 strictly smaller than the goal column). */
507 scan_for_column (EMACS_INT
*endpos
, EMACS_INT
*goalcol
, EMACS_INT
*prevcol
)
509 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
510 register int ctl_arrow
= !NILP (BVAR (current_buffer
, ctl_arrow
));
511 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
512 int multibyte
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
513 struct composition_it cmp_it
;
517 /* Start the scan at the beginning of this line with column number 0. */
518 register EMACS_INT col
= 0, prev_col
= 0;
519 EMACS_INT goal
= goalcol
? *goalcol
: MOST_POSITIVE_FIXNUM
;
520 EMACS_INT end
= endpos
? *endpos
: PT
;
521 EMACS_INT scan
, scan_byte
;
522 EMACS_INT next_boundary
;
524 EMACS_INT opoint
= PT
, opoint_byte
= PT_BYTE
;
525 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
526 current_column_bol_cache
= PT
;
527 scan
= PT
, scan_byte
= PT_BYTE
;
528 SET_PT_BOTH (opoint
, opoint_byte
);
529 next_boundary
= scan
;
532 window
= Fget_buffer_window (Fcurrent_buffer (), Qnil
);
533 w
= ! NILP (window
) ? XWINDOW (window
) : NULL
;
535 memset (&cmp_it
, 0, sizeof cmp_it
);
537 composition_compute_stop_pos (&cmp_it
, scan
, scan_byte
, end
, Qnil
);
539 /* Scan forward to the target position. */
544 /* Occasionally we may need to skip invisible text. */
545 while (scan
== next_boundary
)
547 EMACS_INT old_scan
= scan
;
548 /* This updates NEXT_BOUNDARY to the next place
549 where we might need to skip more invisible text. */
550 scan
= skip_invisible (scan
, &next_boundary
, end
, Qnil
);
551 if (scan
!= old_scan
)
552 scan_byte
= CHAR_TO_BYTE (scan
);
557 /* Test reaching the goal column. We do this after skipping
558 invisible characters, so that we put point before the
559 character on which the cursor will appear. */
564 { /* Check display property. */
566 int width
= check_display_width (scan
, col
, &endp
);
570 if (endp
> scan
) /* Avoid infinite loops with 0-width overlays. */
572 scan
= endp
; scan_byte
= charpos_to_bytepos (scan
);
578 /* Check composition sequence. */
580 || (scan
== cmp_it
.stop_pos
581 && composition_reseat_it (&cmp_it
, scan
, scan_byte
, end
,
583 composition_update_it (&cmp_it
, scan
, scan_byte
, Qnil
);
586 scan
+= cmp_it
.nchars
;
587 scan_byte
+= cmp_it
.nbytes
;
590 if (cmp_it
.to
== cmp_it
.nglyphs
)
593 composition_compute_stop_pos (&cmp_it
, scan
, scan_byte
, end
,
597 cmp_it
.from
= cmp_it
.to
;
601 c
= FETCH_BYTE (scan_byte
);
603 /* See if there is a display table and it relates
604 to this character. */
607 && ! (multibyte
&& LEADING_CODE_P (c
))
608 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
613 /* This character is displayed using a vector of glyphs.
614 Update the column/position based on those glyphs. */
616 charvec
= DISP_CHAR_VECTOR (dp
, c
);
619 for (i
= 0; i
< n
; i
++)
621 /* This should be handled the same as
622 next_element_from_display_vector does it. */
623 Lisp_Object entry
= AREF (charvec
, i
);
625 if (GLYPH_CODE_P (entry
)
626 && GLYPH_CODE_CHAR_VALID_P (entry
))
627 c
= GLYPH_CODE_CHAR (entry
);
633 if (c
== '\r' && EQ (BVAR (current_buffer
, selective_display
), Qt
))
638 col
= col
/ tab_width
* tab_width
;
646 /* The display table doesn't affect this character;
647 it displays as itself. */
651 if (c
== '\r' && EQ (BVAR (current_buffer
, selective_display
), Qt
))
656 col
= col
/ tab_width
* tab_width
;
658 else if (multibyte
&& LEADING_CODE_P (c
))
660 /* Start of multi-byte form. */
664 ptr
= BYTE_POS_ADDR (scan_byte
);
665 MULTIBYTE_BYTES_WIDTH (ptr
, dp
, bytes
, width
);
666 /* Subtract one to compensate for the increment
667 that is going to happen below. */
668 scan_byte
+= bytes
- 1;
671 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
673 else if (c
< 040 || c
>= 0177)
684 last_known_column
= col
;
685 last_known_column_point
= PT
;
686 last_known_column_modified
= MODIFF
;
696 /* Return the column number of position POS
697 by scanning forward from the beginning of the line.
698 This function handles characters that are invisible
699 due to text properties or overlays. */
702 current_column_1 (void)
704 EMACS_INT col
= MOST_POSITIVE_FIXNUM
;
705 EMACS_INT opoint
= PT
;
707 scan_for_column (&opoint
, &col
, NULL
);
712 #if 0 /* Not used. */
714 /* Return the width in columns of the part of STRING from BEG to END.
715 If BEG is nil, that stands for the beginning of STRING.
716 If END is nil, that stands for the end of STRING. */
719 string_display_width (Lisp_Object string
, Lisp_Object beg
, Lisp_Object end
)
722 register unsigned char *ptr
, *stop
;
723 register int tab_seen
;
726 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
727 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
728 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
747 /* Make a pointer for decrementing through the chars before point. */
748 ptr
= SDATA (string
) + e
;
749 /* Make a pointer to where consecutive chars leave off,
750 going backwards from point. */
751 stop
= SDATA (string
) + b
;
753 col
= 0, tab_seen
= 0, post_tab
= 0;
761 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
762 col
+= ASIZE (DISP_CHAR_VECTOR (dp
, c
));
763 else if (c
>= 040 && c
< 0177)
770 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
777 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
782 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
792 DEFUN ("indent-to", Findent_to
, Sindent_to
, 1, 2, "NIndent to column: ",
793 doc
: /* Indent from point with tabs and spaces until COLUMN is reached.
794 Optional second argument MINIMUM says always do at least MINIMUM spaces
795 even if that goes past COLUMN; by default, MINIMUM is zero.
797 The return value is COLUMN. */)
798 (Lisp_Object column
, Lisp_Object minimum
)
801 register EMACS_INT fromcol
;
802 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
804 CHECK_NUMBER (column
);
806 XSETFASTINT (minimum
, 0);
807 CHECK_NUMBER (minimum
);
809 fromcol
= current_column ();
810 mincol
= fromcol
+ XINT (minimum
);
811 if (mincol
< XINT (column
)) mincol
= XINT (column
);
813 if (fromcol
== mincol
)
814 return make_number (mincol
);
816 if (indent_tabs_mode
)
819 XSETFASTINT (n
, mincol
/ tab_width
- fromcol
/ tab_width
);
820 if (XFASTINT (n
) != 0)
822 Finsert_char (make_number ('\t'), n
, Qt
);
824 fromcol
= (mincol
/ tab_width
) * tab_width
;
828 XSETFASTINT (column
, mincol
- fromcol
);
829 Finsert_char (make_number (' '), column
, Qt
);
831 last_known_column
= mincol
;
832 last_known_column_point
= PT
;
833 last_known_column_modified
= MODIFF
;
835 XSETINT (column
, mincol
);
840 DEFUN ("current-indentation", Fcurrent_indentation
, Scurrent_indentation
,
842 doc
: /* Return the indentation of the current line.
843 This is the horizontal position of the character
844 following any initial whitespace. */)
848 EMACS_INT opoint
= PT
, opoint_byte
= PT_BYTE
;
850 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
852 XSETFASTINT (val
, position_indentation (PT_BYTE
));
853 SET_PT_BOTH (opoint
, opoint_byte
);
858 position_indentation (ptrdiff_t pos_byte
)
860 register EMACS_INT column
= 0;
861 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
862 register unsigned char *p
;
863 register unsigned char *stop
;
864 unsigned char *start
;
865 EMACS_INT next_boundary_byte
= pos_byte
;
866 EMACS_INT ceiling
= next_boundary_byte
;
868 p
= BYTE_POS_ADDR (pos_byte
);
869 /* STOP records the value of P at which we will need
870 to think about the gap, or about invisible text,
871 or about the end of the buffer. */
873 /* START records the starting value of P. */
879 EMACS_INT stop_pos_byte
;
881 /* If we have updated P, set POS_BYTE to match.
882 The first time we enter the loop, POS_BYTE is already right. */
884 pos_byte
= PTR_BYTE_POS (p
);
885 /* Consider the various reasons STOP might have been set here. */
886 if (pos_byte
== ZV_BYTE
)
888 if (pos_byte
== next_boundary_byte
)
890 EMACS_INT next_boundary
;
891 EMACS_INT pos
= BYTE_TO_CHAR (pos_byte
);
892 pos
= skip_invisible (pos
, &next_boundary
, ZV
, Qnil
);
893 pos_byte
= CHAR_TO_BYTE (pos
);
894 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
896 if (pos_byte
>= ceiling
)
897 ceiling
= BUFFER_CEILING_OF (pos_byte
) + 1;
898 /* Compute the next place we need to stop and think,
899 and set STOP accordingly. */
900 stop_pos_byte
= min (ceiling
, next_boundary_byte
);
901 /* The -1 and +1 arrange to point at the first byte of gap
902 (if STOP_POS_BYTE is the position of the gap)
903 rather than at the data after the gap. */
905 stop
= BYTE_POS_ADDR (stop_pos_byte
- 1) + 1;
906 p
= BYTE_POS_ADDR (pos_byte
);
911 if (! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
917 column
+= tab_width
- column
% tab_width
;
920 if (ASCII_BYTE_P (p
[-1])
921 || NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
925 pos_byte
= PTR_BYTE_POS (p
- 1);
926 c
= FETCH_MULTIBYTE_CHAR (pos_byte
);
927 if (CHAR_HAS_CATEGORY (c
, ' '))
931 p
= BYTE_POS_ADDR (pos_byte
);
940 /* Test whether the line beginning at POS is indented beyond COLUMN.
941 Blank lines are treated as if they had the same indentation as the
945 indented_beyond_p (EMACS_INT pos
, EMACS_INT pos_byte
, EMACS_INT column
)
948 EMACS_INT opoint
= PT
, opoint_byte
= PT_BYTE
;
950 SET_PT_BOTH (pos
, pos_byte
);
951 while (PT
> BEGV
&& FETCH_BYTE (PT_BYTE
) == '\n')
952 scan_newline (PT
- 1, PT_BYTE
- 1, BEGV
, BEGV_BYTE
, -1, 0);
954 val
= position_indentation (PT_BYTE
);
955 SET_PT_BOTH (opoint
, opoint_byte
);
956 return val
>= column
;
959 DEFUN ("move-to-column", Fmove_to_column
, Smove_to_column
, 1, 2,
961 doc
: /* Move point to column COLUMN in the current line.
962 Interactively, COLUMN is the value of prefix numeric argument.
963 The column of a character is calculated by adding together the widths
964 as displayed of the previous characters in the line.
965 This function ignores line-continuation;
966 there is no upper limit on the column number a character can have
967 and horizontal scrolling has no effect.
969 If specified column is within a character, point goes after that character.
970 If it's past end of line, point goes to end of line.
972 Optional second argument FORCE non-nil means if COLUMN is in the
973 middle of a tab character, change it to spaces.
974 In addition, if FORCE is t, and the line is too short to reach
975 COLUMN, add spaces/tabs to get there.
977 The return value is the current column. */)
978 (Lisp_Object column
, Lisp_Object force
)
981 EMACS_INT col
, prev_col
;
984 CHECK_NATNUM (column
);
985 goal
= XINT (column
);
989 scan_for_column (&pos
, &col
, &prev_col
);
993 /* If a tab char made us overshoot, change it to spaces
994 and scan through it again. */
995 if (!NILP (force
) && col
> goal
)
998 EMACS_INT pos_byte
= PT_BYTE
;
1001 c
= FETCH_CHAR (pos_byte
);
1002 if (c
== '\t' && prev_col
< goal
)
1004 EMACS_INT goal_pt
, goal_pt_byte
;
1006 /* Insert spaces in front of the tab to reach GOAL. Do this
1007 first so that a marker at the end of the tab gets
1009 SET_PT_BOTH (PT
- 1, PT_BYTE
- 1);
1010 Finsert_char (make_number (' '), make_number (goal
- prev_col
), Qt
);
1012 /* Now delete the tab, and indent to COL. */
1013 del_range (PT
, PT
+ 1);
1015 goal_pt_byte
= PT_BYTE
;
1016 Findent_to (make_number (col
), Qnil
);
1017 SET_PT_BOTH (goal_pt
, goal_pt_byte
);
1019 /* Set the last_known... vars consistently. */
1024 /* If line ends prematurely, add space to the end. */
1025 if (col
< goal
&& EQ (force
, Qt
))
1026 Findent_to (make_number (col
= goal
), Qnil
);
1028 last_known_column
= col
;
1029 last_known_column_point
= PT
;
1030 last_known_column_modified
= MODIFF
;
1032 return make_number (col
);
1035 /* compute_motion: compute buffer posn given screen posn and vice versa */
1037 static struct position val_compute_motion
;
1039 /* Scan the current buffer forward from offset FROM, pretending that
1040 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
1041 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
1042 and return the ending buffer position and screen location. If we
1043 can't hit the requested column exactly (because of a tab or other
1044 multi-column character), overshoot.
1046 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
1047 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
1048 earlier call to compute_motion. The other common case is that FROMHPOS
1049 is zero and FROM is a position that "belongs" at column zero, but might
1050 be shifted by overlay strings; in this case DID_MOTION should be 0.
1052 WIDTH is the number of columns available to display text;
1053 compute_motion uses this to handle continuation lines and such.
1054 If WIDTH is -1, use width of window's text area adjusted for
1055 continuation glyph when needed.
1057 HSCROLL is the number of columns not being displayed at the left
1058 margin; this is usually taken from a window's hscroll member.
1059 TAB_OFFSET is the number of columns of the first tab that aren't
1060 being displayed, perhaps because of a continuation line or
1063 compute_motion returns a pointer to a struct position. The bufpos
1064 member gives the buffer position at the end of the scan, and hpos
1065 and vpos give its cartesian location. prevhpos is the column at
1066 which the character before bufpos started, and contin is non-zero
1067 if we reached the current line by continuing the previous.
1069 Note that FROMHPOS and TOHPOS should be expressed in real screen
1070 columns, taking HSCROLL and the truncation glyph at the left margin
1071 into account. That is, beginning-of-line moves you to the hpos
1072 -HSCROLL + (HSCROLL > 0).
1074 For example, to find the buffer position of column COL of line LINE
1075 of a certain window, pass the window's starting location as FROM
1076 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
1077 Pass the buffer's ZV as TO, to limit the scan to the end of the
1078 visible section of the buffer, and pass LINE and COL as TOVPOS and
1081 When displaying in window w, a typical formula for WIDTH is:
1084 - (has_vertical_scroll_bars
1085 ? WINDOW_CONFIG_SCROLL_BAR_COLS (window)
1086 : (window_width + window_left != frame_cols))
1089 window_width is XFASTINT (w->total_cols),
1090 window_left is XFASTINT (w->left_col),
1091 has_vertical_scroll_bars is
1092 WINDOW_HAS_VERTICAL_SCROLL_BAR (window)
1093 and frame_cols = FRAME_COLS (XFRAME (window->frame))
1095 Or you can let window_body_cols do this all for you, and write:
1096 window_body_cols (w) - 1
1098 The `-1' accounts for the continuation-line backslashes; the rest
1099 accounts for window borders if the window is split horizontally, and
1100 the scroll bars if they are turned on. */
1103 compute_motion (EMACS_INT from
, EMACS_INT fromvpos
, EMACS_INT fromhpos
, int did_motion
, EMACS_INT to
, EMACS_INT tovpos
, EMACS_INT tohpos
, EMACS_INT width
, EMACS_INT hscroll
, EMACS_INT tab_offset
, struct window
*win
)
1105 register EMACS_INT hpos
= fromhpos
;
1106 register EMACS_INT vpos
= fromvpos
;
1108 register EMACS_INT pos
;
1111 int tab_width
= SANE_TAB_WIDTH (current_buffer
);
1112 register int ctl_arrow
= !NILP (BVAR (current_buffer
, ctl_arrow
));
1113 register struct Lisp_Char_Table
*dp
= window_display_table (win
);
1115 = (INTEGERP (BVAR (current_buffer
, selective_display
))
1116 ? XINT (BVAR (current_buffer
, selective_display
))
1117 : !NILP (BVAR (current_buffer
, selective_display
)) ? -1 : 0);
1119 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
1120 ? ASIZE (DISP_INVIS_VECTOR (dp
)) : 0);
1121 /* The next location where the `invisible' property changes, or an
1122 overlay starts or ends. */
1123 EMACS_INT next_boundary
= from
;
1125 /* For computing runs of characters with similar widths.
1126 Invariant: width_run_width is zero, or all the characters
1127 from width_run_start to width_run_end have a fixed width of
1129 EMACS_INT width_run_start
= from
;
1130 EMACS_INT width_run_end
= from
;
1131 EMACS_INT width_run_width
= 0;
1132 Lisp_Object
*width_table
;
1135 /* The next buffer pos where we should consult the width run cache. */
1136 EMACS_INT next_width_run
= from
;
1139 int multibyte
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
1140 /* If previous char scanned was a wide character,
1141 this is the column where it ended. Otherwise, this is 0. */
1142 EMACS_INT wide_column_end_hpos
= 0;
1143 EMACS_INT prev_pos
; /* Previous buffer position. */
1144 EMACS_INT prev_pos_byte
; /* Previous buffer position. */
1145 EMACS_INT prev_hpos
= 0;
1146 EMACS_INT prev_vpos
= 0;
1147 EMACS_INT contin_hpos
; /* HPOS of last column of continued line. */
1148 EMACS_INT prev_tab_offset
; /* Previous tab offset. */
1149 EMACS_INT continuation_glyph_width
;
1151 struct composition_it cmp_it
;
1153 XSETBUFFER (buffer
, current_buffer
);
1154 XSETWINDOW (window
, win
);
1156 width_run_cache_on_off ();
1157 if (dp
== buffer_display_table ())
1158 width_table
= (VECTORP (BVAR (current_buffer
, width_table
))
1159 ? XVECTOR (BVAR (current_buffer
, width_table
))->contents
1162 /* If the window has its own display table, we can't use the width
1163 run cache, because that's based on the buffer's display table. */
1166 /* Negative width means use all available text columns. */
1169 width
= window_body_cols (win
);
1170 /* We must make room for continuation marks if we don't have fringes. */
1171 #ifdef HAVE_WINDOW_SYSTEM
1172 if (!FRAME_WINDOW_P (XFRAME (win
->frame
)))
1177 continuation_glyph_width
= 1;
1178 #ifdef HAVE_WINDOW_SYSTEM
1179 if (FRAME_WINDOW_P (XFRAME (win
->frame
)))
1180 continuation_glyph_width
= 0; /* In the fringe. */
1186 pos
= prev_pos
= from
;
1187 pos_byte
= prev_pos_byte
= CHAR_TO_BYTE (from
);
1189 prev_tab_offset
= tab_offset
;
1190 memset (&cmp_it
, 0, sizeof cmp_it
);
1192 composition_compute_stop_pos (&cmp_it
, pos
, pos_byte
, to
, Qnil
);
1196 while (pos
== next_boundary
)
1198 EMACS_INT pos_here
= pos
;
1201 /* Don't skip invisible if we are already at the margin. */
1202 if (vpos
> tovpos
|| (vpos
== tovpos
&& hpos
>= tohpos
))
1204 if (contin_hpos
&& prev_hpos
== 0
1206 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1207 { /* Line breaks because we can't put the character at the
1208 previous line any more. It is not the multi-column
1209 character continued in middle. Go back to previous
1210 buffer position, screen position, and set tab offset
1211 to previous value. It's the beginning of the
1214 pos_byte
= prev_pos_byte
;
1217 tab_offset
= prev_tab_offset
;
1222 /* If the caller says that the screen position came from an earlier
1223 call to compute_motion, then we've already accounted for the
1224 overlay strings at point. This is only true the first time
1225 through, so clear the flag after testing it. */
1227 /* We need to skip past the overlay strings. Currently those
1228 strings must not contain TAB;
1229 if we want to relax that restriction, something will have
1230 to be changed here. */
1232 unsigned char *ovstr
;
1233 EMACS_INT ovlen
= overlay_strings (pos
, win
, &ovstr
);
1234 hpos
+= ((multibyte
&& ovlen
> 0)
1235 ? strwidth ((char *) ovstr
, ovlen
) : ovlen
);
1242 /* Advance POS past invisible characters
1243 (but not necessarily all that there are here),
1244 and store in next_boundary the next position where
1245 we need to call skip_invisible. */
1246 newpos
= skip_invisible (pos
, &next_boundary
, to
, window
);
1250 pos
= min (to
, newpos
);
1251 pos_byte
= CHAR_TO_BYTE (pos
);
1255 if (newpos
!= pos_here
)
1258 pos_byte
= CHAR_TO_BYTE (pos
);
1262 /* Handle right margin. */
1263 /* Note on a wide-column character.
1265 Characters are classified into the following three categories
1266 according to the width (columns occupied on screen).
1268 (1) single-column character: ex. `a'
1269 (2) multi-column character: ex. `^A', TAB, `\033'
1270 (3) wide-column character: ex. Japanese character, Chinese character
1271 (In the following example, `W_' stands for them.)
1273 Multi-column characters can be divided around the right margin,
1274 but wide-column characters cannot.
1278 (*) The cursor is placed on the next character after the point.
1282 j ^---- next after the point
1283 ^--- next char. after the point.
1285 In case of sigle-column character
1289 033 ^---- next after the point, next char. after the point.
1291 In case of multi-column character
1295 W_ ^---- next after the point
1296 ^---- next char. after the point.
1298 In case of wide-column character
1300 The problem here is continuation at a wide-column character.
1301 In this case, the line may shorter less than WIDTH.
1302 And we find the continuation AFTER it occurs.
1308 int total_width
= width
+ continuation_glyph_width
;
1311 if (!NILP (Vtruncate_partial_width_windows
)
1312 && (total_width
< FRAME_COLS (XFRAME (WINDOW_FRAME (win
)))))
1314 if (INTEGERP (Vtruncate_partial_width_windows
))
1316 = total_width
< XFASTINT (Vtruncate_partial_width_windows
);
1321 if (hscroll
|| truncate
1322 || !NILP (BVAR (current_buffer
, truncate_lines
)))
1324 /* Truncating: skip to newline, unless we are already past
1325 TO (we need to go back below). */
1328 pos
= find_before_next_newline (pos
, to
, 1);
1329 pos_byte
= CHAR_TO_BYTE (pos
);
1331 /* If we just skipped next_boundary,
1332 loop around in the main while
1334 if (pos
>= next_boundary
)
1335 next_boundary
= pos
+ 1;
1338 prev_tab_offset
= tab_offset
;
1344 /* Remember the previous value. */
1345 prev_tab_offset
= tab_offset
;
1347 if (wide_column_end_hpos
> width
)
1350 tab_offset
+= prev_hpos
;
1354 tab_offset
+= width
;
1358 contin_hpos
= prev_hpos
;
1364 /* Stop if past the target buffer position or screen position. */
1367 /* Go back to the previous position. */
1369 pos_byte
= prev_pos_byte
;
1372 tab_offset
= prev_tab_offset
;
1374 /* NOTE on contin_hpos, hpos, and prev_hpos.
1378 W_ ^---- contin_hpos
1384 if (contin_hpos
&& prev_hpos
== 0
1385 && contin_hpos
< width
&& !wide_column_end_hpos
)
1387 /* Line breaking occurs in the middle of multi-column
1388 character. Go back to previous line. */
1395 if (vpos
> tovpos
|| (vpos
== tovpos
&& hpos
>= tohpos
))
1397 if (contin_hpos
&& prev_hpos
== 0
1399 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1400 { /* Line breaks because we can't put the character at the
1401 previous line any more. It is not the multi-column
1402 character continued in middle. Go back to previous
1403 buffer position, screen position, and set tab offset
1404 to previous value. It's the beginning of the
1407 pos_byte
= prev_pos_byte
;
1410 tab_offset
= prev_tab_offset
;
1414 if (pos
== ZV
) /* We cannot go beyond ZV. Stop here. */
1420 prev_pos_byte
= pos_byte
;
1421 wide_column_end_hpos
= 0;
1423 /* Consult the width run cache to see if we can avoid inspecting
1424 the text character-by-character. */
1425 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
1429 = region_cache_forward (current_buffer
,
1430 current_buffer
->width_run_cache
,
1433 /* A width of zero means the character's width varies (like
1434 a tab), is meaningless (like a newline), or we just don't
1435 want to skip over it for some other reason. */
1436 if (common_width
!= 0)
1438 EMACS_INT run_end_hpos
;
1440 /* Don't go past the final buffer posn the user
1445 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1447 /* Don't go past the final horizontal position the user
1449 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
1451 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
1452 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1455 /* Don't go past the margin. */
1456 if (run_end_hpos
>= width
)
1458 run_end
= pos
+ (width
- hpos
) / common_width
;
1459 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1462 hpos
= run_end_hpos
;
1464 prev_hpos
= hpos
- common_width
;
1468 pos_byte
= CHAR_TO_BYTE (pos
);
1472 next_width_run
= run_end
+ 1;
1475 /* We have to scan the text character-by-character. */
1479 Lisp_Object charvec
;
1481 /* Check composition sequence. */
1483 || (pos
== cmp_it
.stop_pos
1484 && composition_reseat_it (&cmp_it
, pos
, pos_byte
, to
, win
,
1486 composition_update_it (&cmp_it
, pos
, pos_byte
, Qnil
);
1489 pos
+= cmp_it
.nchars
;
1490 pos_byte
+= cmp_it
.nbytes
;
1491 hpos
+= cmp_it
.width
;
1492 if (cmp_it
.to
== cmp_it
.nglyphs
)
1495 composition_compute_stop_pos (&cmp_it
, pos
, pos_byte
, to
,
1499 cmp_it
.from
= cmp_it
.to
;
1503 c
= FETCH_BYTE (pos_byte
);
1506 /* Perhaps add some info to the width_run_cache. */
1507 if (current_buffer
->width_run_cache
)
1509 /* Is this character part of the current run? If so, extend
1511 if (pos
- 1 == width_run_end
1512 && XFASTINT (width_table
[c
]) == width_run_width
)
1513 width_run_end
= pos
;
1515 /* The previous run is over, since this is a character at a
1516 different position, or a different width. */
1519 /* Have we accumulated a run to put in the cache?
1520 (Currently, we only cache runs of width == 1). */
1521 if (width_run_start
< width_run_end
1522 && width_run_width
== 1)
1523 know_region_cache (current_buffer
,
1524 current_buffer
->width_run_cache
,
1525 width_run_start
, width_run_end
);
1527 /* Start recording a new width run. */
1528 width_run_width
= XFASTINT (width_table
[c
]);
1529 width_run_start
= pos
- 1;
1530 width_run_end
= pos
;
1535 && ! (multibyte
&& LEADING_CODE_P (c
))
1536 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1538 charvec
= DISP_CHAR_VECTOR (dp
, c
);
1539 n
= ASIZE (charvec
);
1547 for (i
= 0; i
< n
; ++i
)
1549 if (VECTORP (charvec
))
1551 /* This should be handled the same as
1552 next_element_from_display_vector does it. */
1553 Lisp_Object entry
= AREF (charvec
, i
);
1555 if (GLYPH_CODE_P (entry
)
1556 && GLYPH_CODE_CHAR_VALID_P (entry
))
1557 c
= GLYPH_CODE_CHAR (entry
);
1562 if (c
>= 040 && c
< 0177)
1566 int tem
= ((hpos
+ tab_offset
+ hscroll
- (hscroll
> 0))
1570 hpos
+= tab_width
- tem
;
1575 && indented_beyond_p (pos
, pos_byte
, selective
))
1577 /* If (pos == to), we don't have to take care of
1578 selective display. */
1581 /* Skip any number of invisible lines all at once */
1584 pos
= find_before_next_newline (pos
, to
, 1);
1587 pos_byte
= CHAR_TO_BYTE (pos
);
1590 && indented_beyond_p (pos
, pos_byte
,
1592 /* Allow for the " ..." that is displayed for them. */
1595 hpos
+= selective_rlen
;
1599 DEC_BOTH (pos
, pos_byte
);
1600 /* We have skipped the invis text, but not the
1606 /* A visible line. */
1610 /* Count the truncation glyph on column 0 */
1612 hpos
+= continuation_glyph_width
;
1617 else if (c
== CR
&& selective
< 0)
1619 /* In selective display mode,
1620 everything from a ^M to the end of the line is invisible.
1621 Stop *before* the real newline. */
1624 pos
= find_before_next_newline (pos
, to
, 1);
1625 pos_byte
= CHAR_TO_BYTE (pos
);
1627 /* If we just skipped next_boundary,
1628 loop around in the main while
1630 if (pos
> next_boundary
)
1631 next_boundary
= pos
;
1632 /* Allow for the " ..." that is displayed for them. */
1635 hpos
+= selective_rlen
;
1640 else if (multibyte
&& LEADING_CODE_P (c
))
1642 /* Start of multi-byte form. */
1644 int mb_bytes
, mb_width
;
1646 pos_byte
--; /* rewind POS_BYTE */
1647 ptr
= BYTE_POS_ADDR (pos_byte
);
1648 MULTIBYTE_BYTES_WIDTH (ptr
, dp
, mb_bytes
, mb_width
);
1649 pos_byte
+= mb_bytes
;
1650 if (mb_width
> 1 && BYTES_BY_CHAR_HEAD (*ptr
) == mb_bytes
)
1651 wide_column_end_hpos
= hpos
+ mb_width
;
1654 else if (VECTORP (charvec
))
1657 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
1664 /* Remember any final width run in the cache. */
1665 if (current_buffer
->width_run_cache
1666 && width_run_width
== 1
1667 && width_run_start
< width_run_end
)
1668 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
1669 width_run_start
, width_run_end
);
1671 val_compute_motion
.bufpos
= pos
;
1672 val_compute_motion
.bytepos
= pos_byte
;
1673 val_compute_motion
.hpos
= hpos
;
1674 val_compute_motion
.vpos
= vpos
;
1675 if (contin_hpos
&& prev_hpos
== 0)
1676 val_compute_motion
.prevhpos
= contin_hpos
;
1678 val_compute_motion
.prevhpos
= prev_hpos
;
1679 /* We always handle all of them here; none of them remain to do. */
1680 val_compute_motion
.ovstring_chars_done
= 0;
1682 /* Nonzero if have just continued a line */
1683 val_compute_motion
.contin
= (contin_hpos
&& prev_hpos
== 0);
1686 return &val_compute_motion
;
1690 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
1691 doc
: /* Scan through the current buffer, calculating screen position.
1692 Scan the current buffer forward from offset FROM,
1693 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--
1694 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--
1695 and return the ending buffer position and screen location.
1697 If TOPOS is nil, the actual width and height of the window's
1700 There are three additional arguments:
1702 WIDTH is the number of columns available to display text;
1703 this affects handling of continuation lines. A value of nil
1704 corresponds to the actual number of available text columns.
1706 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).
1707 HSCROLL is the number of columns not being displayed at the left
1708 margin; this is usually taken from a window's hscroll member.
1709 TAB-OFFSET is the number of columns of the first tab that aren't
1710 being displayed, perhaps because the line was continued within it.
1711 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.
1713 WINDOW is the window to operate on. It is used to choose the display table;
1714 if it is showing the current buffer, it is used also for
1715 deciding which overlay properties apply.
1716 Note that `compute-motion' always operates on the current buffer.
1718 The value is a list of five elements:
1719 (POS HPOS VPOS PREVHPOS CONTIN)
1720 POS is the buffer position where the scan stopped.
1721 VPOS is the vertical position where the scan stopped.
1722 HPOS is the horizontal position where the scan stopped.
1724 PREVHPOS is the horizontal position one character back from POS.
1725 CONTIN is t if a line was continued after (or within) the previous character.
1727 For example, to find the buffer position of column COL of line LINE
1728 of a certain window, pass the window's starting location as FROM
1729 and the window's upper-left coordinates as FROMPOS.
1730 Pass the buffer's (point-max) as TO, to limit the scan to the end of the
1731 visible section of the buffer, and pass LINE and COL as TOPOS. */)
1732 (Lisp_Object from
, Lisp_Object frompos
, Lisp_Object to
, Lisp_Object topos
, Lisp_Object width
, Lisp_Object offsets
, Lisp_Object window
)
1735 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
;
1736 struct position
*pos
;
1737 EMACS_INT hscroll
, tab_offset
;
1739 CHECK_NUMBER_COERCE_MARKER (from
);
1740 CHECK_CONS (frompos
);
1741 CHECK_NUMBER_CAR (frompos
);
1742 CHECK_NUMBER_CDR (frompos
);
1743 CHECK_NUMBER_COERCE_MARKER (to
);
1747 CHECK_NUMBER_CAR (topos
);
1748 CHECK_NUMBER_CDR (topos
);
1751 CHECK_NUMBER (width
);
1753 if (!NILP (offsets
))
1755 CHECK_CONS (offsets
);
1756 CHECK_NUMBER_CAR (offsets
);
1757 CHECK_NUMBER_CDR (offsets
);
1758 hscroll
= XINT (XCAR (offsets
));
1759 tab_offset
= XINT (XCDR (offsets
));
1762 hscroll
= tab_offset
= 0;
1765 window
= Fselected_window ();
1767 CHECK_LIVE_WINDOW (window
);
1768 w
= XWINDOW (window
);
1770 if (XINT (from
) < BEGV
|| XINT (from
) > ZV
)
1771 args_out_of_range_3 (from
, make_number (BEGV
), make_number (ZV
));
1772 if (XINT (to
) < BEGV
|| XINT (to
) > ZV
)
1773 args_out_of_range_3 (to
, make_number (BEGV
), make_number (ZV
));
1775 pos
= compute_motion (XINT (from
), XINT (XCDR (frompos
)),
1776 XINT (XCAR (frompos
)), 0,
1779 ? window_internal_height (w
)
1780 : XINT (XCDR (topos
))),
1782 ? (window_body_cols (w
)
1784 #ifdef HAVE_WINDOW_SYSTEM
1785 FRAME_WINDOW_P (XFRAME (w
->frame
)) ? 0 :
1788 : XINT (XCAR (topos
))),
1789 (NILP (width
) ? -1 : XINT (width
)),
1790 hscroll
, tab_offset
,
1793 XSETFASTINT (bufpos
, pos
->bufpos
);
1794 XSETINT (hpos
, pos
->hpos
);
1795 XSETINT (vpos
, pos
->vpos
);
1796 XSETINT (prevhpos
, pos
->prevhpos
);
1798 return Fcons (bufpos
,
1802 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
1806 /* Fvertical_motion and vmotion */
1808 static struct position val_vmotion
;
1811 vmotion (register EMACS_INT from
, register EMACS_INT vtarget
, struct window
*w
)
1813 EMACS_INT hscroll
= XINT (w
->hscroll
);
1814 struct position pos
;
1815 /* vpos is cumulative vertical position, changed as from is changed */
1816 register int vpos
= 0;
1818 register EMACS_INT first
;
1819 EMACS_INT from_byte
;
1820 EMACS_INT lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1822 = (INTEGERP (BVAR (current_buffer
, selective_display
))
1823 ? XINT (BVAR (current_buffer
, selective_display
))
1824 : !NILP (BVAR (current_buffer
, selective_display
)) ? -1 : 0);
1826 EMACS_INT start_hpos
= 0;
1828 /* This is the object we use for fetching character properties. */
1829 Lisp_Object text_prop_object
;
1831 XSETWINDOW (window
, w
);
1833 /* If the window contains this buffer, use it for getting text properties.
1834 Otherwise use the current buffer as arg for doing that. */
1835 if (EQ (w
->buffer
, Fcurrent_buffer ()))
1836 text_prop_object
= window
;
1838 text_prop_object
= Fcurrent_buffer ();
1840 if (vpos
>= vtarget
)
1842 /* To move upward, go a line at a time until
1843 we have gone at least far enough. */
1847 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1849 Lisp_Object propval
;
1851 prevline
= find_next_newline_no_quit (from
- 1, -1);
1852 while (prevline
> BEGV
1854 && indented_beyond_p (prevline
,
1855 CHAR_TO_BYTE (prevline
),
1857 /* Watch out for newlines with `invisible' property.
1858 When moving upward, check the newline before. */
1859 || (propval
= Fget_char_property (make_number (prevline
- 1),
1862 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1863 prevline
= find_next_newline_no_quit (prevline
- 1, -1);
1864 pos
= *compute_motion (prevline
, 0,
1865 lmargin
+ (prevline
== BEG
? start_hpos
: 0),
1868 /* Don't care for VPOS... */
1869 1 << (BITS_PER_SHORT
- 1),
1871 1 << (BITS_PER_SHORT
- 1),
1873 /* This compensates for start_hpos
1874 so that a tab as first character
1875 still occupies 8 columns. */
1876 (prevline
== BEG
? -start_hpos
: 0),
1883 /* If we made exactly the desired vertical distance,
1884 or if we hit beginning of buffer,
1885 return point found */
1886 if (vpos
>= vtarget
)
1888 val_vmotion
.bufpos
= from
;
1889 val_vmotion
.bytepos
= CHAR_TO_BYTE (from
);
1890 val_vmotion
.vpos
= vpos
;
1891 val_vmotion
.hpos
= lmargin
;
1892 val_vmotion
.contin
= 0;
1893 val_vmotion
.prevhpos
= 0;
1894 val_vmotion
.ovstring_chars_done
= 0;
1895 val_vmotion
.tab_offset
= 0; /* For accumulating tab offset. */
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,
1922 lmargin
+ (prevline
== BEG
1926 /* Don't care for VPOS... */
1927 1 << (BITS_PER_SHORT
- 1),
1929 1 << (BITS_PER_SHORT
- 1),
1931 (prevline
== BEG
? -start_hpos
: 0),
1937 pos
.hpos
= lmargin
+ (from
== BEG
? start_hpos
: 0);
1942 return compute_motion (from
, vpos
, pos
.hpos
, did_motion
,
1943 ZV
, vtarget
, - (1 << (BITS_PER_SHORT
- 1)),
1945 pos
.tab_offset
- (from
== BEG
? start_hpos
: 0),
1949 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
1950 doc
: /* Move point to start of the screen line LINES lines down.
1951 If LINES is negative, this means moving up.
1953 This function is an ordinary cursor motion function
1954 which calculates the new position based on how text would be displayed.
1955 The new position may be the start of a line,
1956 or just the start of a continuation line.
1957 The function returns number of screen lines moved over;
1958 that usually equals LINES, but may be closer to zero
1959 if beginning or end of buffer was reached.
1961 The optional second argument WINDOW specifies the window to use for
1962 parameters such as width, horizontal scrolling, and so on.
1963 The default is to use the selected window's parameters.
1965 LINES can optionally take the form (COLS . LINES), in which case
1966 the motion will not stop at the start of a screen line but on
1967 its column COLS (if such exists on that line, that is).
1969 `vertical-motion' always uses the current buffer,
1970 regardless of which buffer is displayed in WINDOW.
1971 This is consistent with other cursor motion functions
1972 and makes it possible to use `vertical-motion' in any buffer,
1973 whether or not it is currently displayed in some window. */)
1974 (Lisp_Object lines
, Lisp_Object window
)
1979 Lisp_Object old_buffer
;
1980 EMACS_INT old_charpos
IF_LINT (= 0), old_bytepos
IF_LINT (= 0);
1981 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1982 Lisp_Object lcols
= Qnil
;
1983 double cols
IF_LINT (= 0);
1984 void *itdata
= NULL
;
1986 /* Allow LINES to be of the form (HPOS . VPOS) aka (COLUMNS . LINES). */
1987 if (CONSP (lines
) && (NUMBERP (XCAR (lines
))))
1989 lcols
= XCAR (lines
);
1990 cols
= INTEGERP (lcols
) ? (double) XINT (lcols
) : XFLOAT_DATA (lcols
);
1991 lines
= XCDR (lines
);
1994 CHECK_NUMBER (lines
);
1995 if (! NILP (window
))
1996 CHECK_WINDOW (window
);
1998 window
= selected_window
;
1999 w
= XWINDOW (window
);
2002 GCPRO3 (old_buffer
, old_charpos
, old_bytepos
);
2003 if (XBUFFER (w
->buffer
) != current_buffer
)
2005 /* Set the window's buffer temporarily to the current buffer. */
2006 old_buffer
= w
->buffer
;
2007 old_charpos
= XMARKER (w
->pointm
)->charpos
;
2008 old_bytepos
= XMARKER (w
->pointm
)->bytepos
;
2009 XSETBUFFER (w
->buffer
, current_buffer
);
2011 (w
->pointm
, w
->buffer
, BUF_PT (current_buffer
), BUF_PT_BYTE (current_buffer
));
2016 struct position pos
;
2017 pos
= *vmotion (PT
, XINT (lines
), w
);
2018 SET_PT_BOTH (pos
.bufpos
, pos
.bytepos
);
2023 int first_x
, it_overshoot_count
= 0;
2024 int overshoot_handled
= 0;
2025 int disp_string_at_start_p
= 0;
2027 itdata
= bidi_shelve_cache ();
2028 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
2029 start_display (&it
, w
, pt
);
2030 first_x
= it
.first_visible_x
;
2031 it_start
= IT_CHARPOS (it
);
2033 /* See comments below for why we calculate this. */
2034 if (it
.cmp_it
.id
>= 0)
2035 it_overshoot_count
= 0;
2036 else if (it
.method
== GET_FROM_STRING
)
2038 const char *s
= SSDATA (it
.string
);
2039 const char *e
= s
+ SBYTES (it
.string
);
2041 disp_string_at_start_p
= it
.string_from_display_prop_p
;
2045 it_overshoot_count
++;
2047 if (!it_overshoot_count
)
2048 it_overshoot_count
= -1;
2051 it_overshoot_count
=
2052 !(it
.method
== GET_FROM_IMAGE
|| it
.method
== GET_FROM_STRETCH
);
2054 /* Scan from the start of the line containing PT. If we don't
2055 do this, we start moving with IT->current_x == 0, while PT is
2056 really at some x > 0. */
2057 reseat_at_previous_visible_line_start (&it
);
2058 it
.current_x
= it
.hpos
= 0;
2059 if (IT_CHARPOS (it
) != PT
)
2060 /* We used to temporarily disable selective display here; the
2061 comment said this is "so we don't move too far" (2005-01-19
2062 checkin by kfs). But this does nothing useful that I can
2063 tell, and it causes Bug#2694 . -- cyd */
2064 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
2066 /* IT may move too far if truncate-lines is on and PT lies
2067 beyond the right margin. IT may also move too far if the
2068 starting point is on a Lisp string that has embedded
2069 newlines, or spans several screen lines. In these cases,
2071 if (IT_CHARPOS (it
) > it_start
)
2073 /* We need to backtrack also if the Lisp string contains no
2074 newlines, but there is a newline right after it. In this
2075 case, IT overshoots if there is an after-string just
2076 before the newline. */
2077 if (it_overshoot_count
< 0
2078 && it
.method
== GET_FROM_BUFFER
2080 it_overshoot_count
= 1;
2081 else if (disp_string_at_start_p
&& it
.vpos
> 0)
2083 /* This is the case of a display string that spans
2084 several screen lines. In that case, we end up at the
2085 end of the string, and it.vpos tells us how many
2086 screen lines we need to backtrack. */
2087 it_overshoot_count
= it
.vpos
;
2089 if (it_overshoot_count
> 0)
2090 move_it_by_lines (&it
, -it_overshoot_count
);
2092 overshoot_handled
= 1;
2094 if (XINT (lines
) <= 0)
2097 /* Do this even if LINES is 0, so that we move back to the
2098 beginning of the current line as we ought. */
2099 if (XINT (lines
) == 0 || IT_CHARPOS (it
) > 0)
2100 move_it_by_lines (&it
, max (INT_MIN
, XINT (lines
)));
2102 else if (overshoot_handled
)
2105 move_it_by_lines (&it
, min (INT_MAX
, XINT (lines
)));
2109 /* Otherwise, we are at the first row occupied by PT, which
2110 might span multiple screen lines (e.g., if it's on a
2111 multi-line display string). We want to start from the
2112 last line that it occupies. */
2115 while (IT_CHARPOS (it
) <= it_start
)
2118 move_it_by_lines (&it
, 1);
2120 if (XINT (lines
) > 1)
2121 move_it_by_lines (&it
, min (INT_MAX
, XINT (lines
) - 1));
2126 move_it_by_lines (&it
, min (INT_MAX
, XINT (lines
)));
2130 /* Move to the goal column, if one was specified. */
2133 /* If the window was originally hscrolled, move forward by
2134 the hscrolled amount first. */
2137 move_it_in_display_line (&it
, ZV
, first_x
, MOVE_TO_X
);
2140 move_it_in_display_line
2142 (int)(cols
* FRAME_COLUMN_WIDTH (XFRAME (w
->frame
)) + 0.5),
2146 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
2147 bidi_unshelve_cache (itdata
, 0);
2150 if (BUFFERP (old_buffer
))
2152 w
->buffer
= old_buffer
;
2153 set_marker_both (w
->pointm
, w
->buffer
, old_charpos
, old_bytepos
);
2156 RETURN_UNGCPRO (make_number (it
.vpos
));
2161 /* File's initialization. */
2164 syms_of_indent (void)
2166 DEFVAR_BOOL ("indent-tabs-mode", indent_tabs_mode
,
2167 doc
: /* Indentation can insert tabs if this is non-nil. */);
2168 indent_tabs_mode
= 1;
2170 defsubr (&Scurrent_indentation
);
2171 defsubr (&Sindent_to
);
2172 defsubr (&Scurrent_column
);
2173 defsubr (&Smove_to_column
);
2174 defsubr (&Svertical_motion
);
2175 defsubr (&Scompute_motion
);