1 /* Indentation functions.
2 Copyright (C) 1985,86,87,88,93,94,95,98, 2000, 2001
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 2, or (at your option)
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; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
34 #include "intervals.h"
35 #include "region-cache.h"
37 /* Indentation can insert tabs if this is non-zero;
38 otherwise always uses spaces. */
44 /* These three values memorize the current column to avoid recalculation. */
46 /* Last value returned by current_column.
47 Some things in set last_known_column_point to -1
48 to mark the memorized value as invalid. */
50 int last_known_column
;
52 /* Value of point when current_column was called. */
54 int last_known_column_point
;
56 /* Value of MODIFF when current_column was called. */
58 int last_known_column_modified
;
60 static int current_column_1
P_ ((void));
61 static int position_indentation
P_ ((int));
63 /* Cache of beginning of line found by the last call of
66 int current_column_bol_cache
;
68 /* Get the display table to use for the current buffer. */
70 struct Lisp_Char_Table
*
71 buffer_display_table ()
75 thisbuf
= current_buffer
->display_table
;
76 if (DISP_TABLE_P (thisbuf
))
77 return XCHAR_TABLE (thisbuf
);
78 if (DISP_TABLE_P (Vstandard_display_table
))
79 return XCHAR_TABLE (Vstandard_display_table
);
83 /* Width run cache considerations. */
85 /* Return the width of character C under display table DP. */
88 character_width (c
, dp
)
90 struct Lisp_Char_Table
*dp
;
94 /* These width computations were determined by examining the cases
95 in display_text_line. */
97 /* Everything can be handled by the display table, if it's
98 present and the element is right. */
99 if (dp
&& (elt
= DISP_CHAR_VECTOR (dp
, c
), VECTORP (elt
)))
100 return XVECTOR (elt
)->size
;
102 /* Some characters are special. */
103 if (c
== '\n' || c
== '\t' || c
== '\015')
106 /* Printing characters have width 1. */
107 else if (c
>= 040 && c
< 0177)
110 /* Everybody else (control characters, metacharacters) has other
111 widths. We could return their actual widths here, but they
112 depend on things like ctl_arrow and crud like that, and they're
113 not very common at all. So we'll just claim we don't know their
119 /* Return true iff the display table DISPTAB specifies the same widths
120 for characters as WIDTHTAB. We use this to decide when to
121 invalidate the buffer's width_run_cache. */
124 disptab_matches_widthtab (disptab
, widthtab
)
125 struct Lisp_Char_Table
*disptab
;
126 struct Lisp_Vector
*widthtab
;
130 if (widthtab
->size
!= 256)
133 for (i
= 0; i
< 256; i
++)
134 if (character_width (i
, disptab
)
135 != XFASTINT (widthtab
->contents
[i
]))
141 /* Recompute BUF's width table, using the display table DISPTAB. */
144 recompute_width_table (buf
, disptab
)
146 struct Lisp_Char_Table
*disptab
;
149 struct Lisp_Vector
*widthtab
;
151 if (!VECTORP (buf
->width_table
))
152 buf
->width_table
= Fmake_vector (make_number (256), make_number (0));
153 widthtab
= XVECTOR (buf
->width_table
);
154 if (widthtab
->size
!= 256)
157 for (i
= 0; i
< 256; i
++)
158 XSETFASTINT (widthtab
->contents
[i
], character_width (i
, disptab
));
161 /* Allocate or free the width run cache, as requested by the current
162 state of current_buffer's cache_long_line_scans variable. */
165 width_run_cache_on_off ()
167 if (NILP (current_buffer
->cache_long_line_scans
)
168 /* And, for the moment, this feature doesn't work on multibyte
170 || !NILP (current_buffer
->enable_multibyte_characters
))
172 /* It should be off. */
173 if (current_buffer
->width_run_cache
)
175 free_region_cache (current_buffer
->width_run_cache
);
176 current_buffer
->width_run_cache
= 0;
177 current_buffer
->width_table
= Qnil
;
182 /* It should be on. */
183 if (current_buffer
->width_run_cache
== 0)
185 current_buffer
->width_run_cache
= new_region_cache ();
186 recompute_width_table (current_buffer
, buffer_display_table ());
192 /* Skip some invisible characters starting from POS.
193 This includes characters invisible because of text properties
194 and characters invisible because of overlays.
196 If position POS is followed by invisible characters,
197 skip some of them and return the position after them.
198 Otherwise return POS itself.
200 Set *NEXT_BOUNDARY_P to the next position at which
201 it will be necessary to call this function again.
203 Don't scan past TO, and don't set *NEXT_BOUNDARY_P
204 to a value greater than TO.
206 If WINDOW is non-nil, and this buffer is displayed in WINDOW,
207 take account of overlays that apply only in WINDOW.
209 We don't necessarily skip all the invisible characters after POS
210 because that could take a long time. We skip a reasonable number
211 which can be skipped quickly. If there might be more invisible
212 characters immediately following, then *NEXT_BOUNDARY_P
213 will equal the return value. */
216 skip_invisible (pos
, next_boundary_p
, to
, window
)
218 int *next_boundary_p
;
222 Lisp_Object prop
, position
, overlay_limit
, proplimit
;
226 XSETFASTINT (position
, pos
);
227 XSETBUFFER (buffer
, current_buffer
);
229 /* Give faster response for overlay lookup near POS. */
230 recenter_overlay_lists (current_buffer
, pos
);
232 /* We must not advance farther than the next overlay change.
233 The overlay change might change the invisible property;
234 or there might be overlay strings to be displayed there. */
235 overlay_limit
= Fnext_overlay_change (position
);
236 /* As for text properties, this gives a lower bound
237 for where the invisible text property could change. */
238 proplimit
= Fnext_property_change (position
, buffer
, Qt
);
239 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
240 proplimit
= overlay_limit
;
241 /* PROPLIMIT is now a lower bound for the next change
242 in invisible status. If that is plenty far away,
243 use that lower bound. */
244 if (XFASTINT (proplimit
) > pos
+ 100 || XFASTINT (proplimit
) >= to
)
245 *next_boundary_p
= XFASTINT (proplimit
);
246 /* Otherwise, scan for the next `invisible' property change. */
249 /* Don't scan terribly far. */
250 XSETFASTINT (proplimit
, min (pos
+ 100, to
));
251 /* No matter what. don't go past next overlay change. */
252 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
253 proplimit
= overlay_limit
;
254 end
= XFASTINT (Fnext_single_property_change (position
, Qinvisible
,
257 /* Don't put the boundary in the middle of multibyte form if
258 there is no actual property change. */
260 && !NILP (current_buffer
->enable_multibyte_characters
)
262 while (pos
< end
&& !CHAR_HEAD_P (POS_ADDR (end
)))
265 *next_boundary_p
= end
;
267 /* if the `invisible' property is set, we can skip to
268 the next property change */
269 if (!NILP (window
) && EQ (XWINDOW (window
)->buffer
, buffer
))
270 prop
= Fget_char_property (position
, Qinvisible
, window
);
272 prop
= Fget_char_property (position
, Qinvisible
, buffer
);
273 if (TEXT_PROP_MEANS_INVISIBLE (prop
) > NILP (window
))
274 return *next_boundary_p
;
278 /* If a composition starts at POS/POS_BYTE and it doesn't stride over
279 POINT, set *LEN / *LEN_BYTE to the character and byte lengths, *WIDTH
280 to the width, and return 1. Otherwise, return 0. */
283 check_composition (pos
, pos_byte
, point
, len
, len_byte
, width
)
284 int pos
, pos_byte
, point
;
285 int *len
, *len_byte
, *width
;
291 if (! find_composition (pos
, -1, &start
, &end
, &prop
, Qnil
)
292 || pos
!= start
|| point
< end
293 || !COMPOSITION_VALID_P (start
, end
, prop
))
295 if ((id
= get_composition_id (pos
, pos_byte
, end
- pos
, prop
, Qnil
)) < 0)
298 *len
= COMPOSITION_LENGTH (prop
);
299 *len_byte
= CHAR_TO_BYTE (end
) - pos_byte
;
300 *width
= composition_table
[id
]->width
;
304 /* Set variables WIDTH and BYTES for a multibyte sequence starting at P.
306 DP is a display table or NULL.
308 This macro is used in current_column_1, Fmove_to_column, and
311 #define MULTIBYTE_BYTES_WIDTH(p, dp) \
316 c = STRING_CHAR_AND_LENGTH (p, MAX_MULTIBYTE_LENGTH, bytes); \
317 if (BYTES_BY_CHAR_HEAD (*p) != bytes) \
321 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c))) \
322 width = XVECTOR (DISP_CHAR_VECTOR (dp, c))->size; \
324 width = WIDTH_BY_CHAR_HEAD (*p); \
326 wide_column = width; \
330 DEFUN ("current-column", Fcurrent_column
, Scurrent_column
, 0, 0, 0,
331 doc
: /* Return the horizontal position of point. Beginning of line is column 0.
332 This is calculated by adding together the widths of all the displayed
333 representations of the character between the start of the previous line
334 and point. (eg control characters will have a width of 2 or 4, tabs
335 will have a variable width)
336 Ignores finite width of frame, which means that this function may return
337 values greater than (frame-width).
338 Whether the line is visible (if `selective-display' is t) has no effect;
339 however, ^M is treated as end of line when `selective-display' is t. */)
343 XSETFASTINT (temp
, current_column ());
347 /* Cancel any recorded value of the horizontal position. */
350 invalidate_current_column ()
352 last_known_column_point
= 0;
359 register unsigned char *ptr
, *stop
;
360 register int tab_seen
;
363 register int tab_width
= XINT (current_buffer
->tab_width
);
364 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
365 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
367 if (PT
== last_known_column_point
368 && MODIFF
== last_known_column_modified
)
369 return last_known_column
;
371 /* If the buffer has overlays, text properties,
372 or multibyte characters, use a more general algorithm. */
373 if (BUF_INTERVALS (current_buffer
)
374 || !NILP (current_buffer
->overlays_before
)
375 || !NILP (current_buffer
->overlays_after
)
377 return current_column_1 ();
379 /* Scan backwards from point to the previous newline,
380 counting width. Tab characters are the only complicated case. */
382 /* Make a pointer for decrementing through the chars before point. */
383 ptr
= BYTE_POS_ADDR (PT_BYTE
- 1) + 1;
384 /* Make a pointer to where consecutive chars leave off,
385 going backwards from point. */
388 else if (PT
<= GPT
|| BEGV
> GPT
)
393 if (tab_width
<= 0 || tab_width
> 1000)
396 col
= 0, tab_seen
= 0, post_tab
= 0;
405 /* We stopped either for the beginning of the buffer
407 if (ptr
== BEGV_ADDR
)
410 /* It was the gap. Jump back over it. */
414 /* Check whether that brings us to beginning of buffer. */
421 if (dp
&& VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
423 charvec
= DISP_CHAR_VECTOR (dp
, c
);
432 for (i
= n
- 1; i
>= 0; --i
)
434 if (VECTORP (charvec
))
436 /* This should be handled the same as
437 next_element_from_display_vector does it. */
438 Lisp_Object entry
= AREF (charvec
, i
);
441 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
442 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
447 if (c
>= 040 && c
< 0177)
451 && EQ (current_buffer
->selective_display
, Qt
)))
454 goto start_of_line_found
;
459 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
465 else if (VECTORP (charvec
))
466 /* With a display table entry, C is displayed as is, and
467 not displayed as \NNN or as ^N. If C is a single-byte
468 character, it takes one column. If C is multi-byte in
469 an unibyte buffer, it's translated to unibyte, so it
470 also takes one column. */
473 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
481 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
485 if (ptr
== BEGV_ADDR
)
486 current_column_bol_cache
= BEGV
;
488 current_column_bol_cache
= BYTE_TO_CHAR (PTR_BYTE_POS (ptr
));
490 last_known_column
= col
;
491 last_known_column_point
= PT
;
492 last_known_column_modified
= MODIFF
;
497 /* Return the column number of position POS
498 by scanning forward from the beginning of the line.
499 This function handles characters that are invisible
500 due to text properties or overlays. */
505 register int tab_width
= XINT (current_buffer
->tab_width
);
506 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
507 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
508 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
510 /* Start the scan at the beginning of this line with column number 0. */
511 register int col
= 0;
513 int next_boundary
, next_boundary_byte
;
514 int opoint
= PT
, opoint_byte
= PT_BYTE
;
516 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
517 current_column_bol_cache
= PT
;
518 scan
= PT
, scan_byte
= PT_BYTE
;
519 SET_PT_BOTH (opoint
, opoint_byte
);
520 next_boundary
= scan
;
521 next_boundary_byte
= scan_byte
;
523 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
525 /* Scan forward to the target position. */
526 while (scan
< opoint
)
530 /* Occasionally we may need to skip invisible text. */
531 while (scan
== next_boundary
)
534 /* This updates NEXT_BOUNDARY to the next place
535 where we might need to skip more invisible text. */
536 scan
= skip_invisible (scan
, &next_boundary
, opoint
, Qnil
);
539 if (scan
!= old_scan
)
540 scan_byte
= CHAR_TO_BYTE (scan
);
541 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
544 /* Check composition sequence. */
546 int len
, len_byte
, width
;
548 if (check_composition (scan
, scan_byte
, opoint
,
549 &len
, &len_byte
, &width
))
552 scan_byte
+= len_byte
;
559 c
= FETCH_BYTE (scan_byte
);
562 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
563 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
568 /* This character is displayed using a vector of glyphs.
569 Update the column based on those glyphs. */
571 charvec
= DISP_CHAR_VECTOR (dp
, c
);
574 for (i
= 0; i
< n
; i
++)
576 /* This should be handled the same as
577 next_element_from_display_vector does it. */
579 entry
= AREF (charvec
, i
);
582 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
583 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
589 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
594 col
= col
/ tab_width
* tab_width
;
602 /* The display table says nothing for this character.
603 Display it as itself. */
607 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
612 col
= col
/ tab_width
* tab_width
;
614 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
617 int bytes
, width
, wide_column
;
620 ptr
= BYTE_POS_ADDR (scan_byte
);
621 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
625 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
627 else if (c
< 040 || c
>= 0177)
638 last_known_column
= col
;
639 last_known_column_point
= PT
;
640 last_known_column_modified
= MODIFF
;
646 #if 0 /* Not used. */
648 /* Return the width in columns of the part of STRING from BEG to END.
649 If BEG is nil, that stands for the beginning of STRING.
650 If END is nil, that stands for the end of STRING. */
653 string_display_width (string
, beg
, end
)
654 Lisp_Object string
, beg
, end
;
657 register unsigned char *ptr
, *stop
;
658 register int tab_seen
;
661 register int tab_width
= XINT (current_buffer
->tab_width
);
662 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
663 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
667 e
= XSTRING (string
)->size
;
682 /* Make a pointer for decrementing through the chars before point. */
683 ptr
= XSTRING (string
)->data
+ e
;
684 /* Make a pointer to where consecutive chars leave off,
685 going backwards from point. */
686 stop
= XSTRING (string
)->data
+ b
;
688 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
690 col
= 0, tab_seen
= 0, post_tab
= 0;
698 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
699 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
700 else if (c
>= 040 && c
< 0177)
707 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
714 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
719 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
729 DEFUN ("indent-to", Findent_to
, Sindent_to
, 1, 2, "NIndent to column: ",
730 doc
: /* Indent from point with tabs and spaces until COLUMN is reached.
731 Optional second argument MININUM says always do at least MININUM spaces
732 even if that goes past COLUMN; by default, MININUM is zero. */)
734 Lisp_Object column
, minimum
;
737 register int fromcol
;
738 register int tab_width
= XINT (current_buffer
->tab_width
);
740 CHECK_NUMBER (column
);
742 XSETFASTINT (minimum
, 0);
743 CHECK_NUMBER (minimum
);
745 fromcol
= current_column ();
746 mincol
= fromcol
+ XINT (minimum
);
747 if (mincol
< XINT (column
)) mincol
= XINT (column
);
749 if (fromcol
== mincol
)
750 return make_number (mincol
);
752 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
754 if (indent_tabs_mode
)
757 XSETFASTINT (n
, mincol
/ tab_width
- fromcol
/ tab_width
);
758 if (XFASTINT (n
) != 0)
760 Finsert_char (make_number ('\t'), n
, Qt
);
762 fromcol
= (mincol
/ tab_width
) * tab_width
;
766 XSETFASTINT (column
, mincol
- fromcol
);
767 Finsert_char (make_number (' '), column
, Qt
);
769 last_known_column
= mincol
;
770 last_known_column_point
= PT
;
771 last_known_column_modified
= MODIFF
;
773 XSETINT (column
, mincol
);
778 static int position_indentation
P_ ((int));
780 DEFUN ("current-indentation", Fcurrent_indentation
, Scurrent_indentation
,
782 doc
: /* Return the indentation of the current line.
783 This is the horizontal position of the character
784 following any initial whitespace. */)
788 int opoint
= PT
, opoint_byte
= PT_BYTE
;
790 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
792 XSETFASTINT (val
, position_indentation (PT_BYTE
));
793 SET_PT_BOTH (opoint
, opoint_byte
);
798 position_indentation (pos_byte
)
799 register int pos_byte
;
801 register int column
= 0;
802 register int tab_width
= XINT (current_buffer
->tab_width
);
803 register unsigned char *p
;
804 register unsigned char *stop
;
805 unsigned char *start
;
806 int next_boundary_byte
= pos_byte
;
807 int ceiling
= next_boundary_byte
;
809 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
811 p
= BYTE_POS_ADDR (pos_byte
);
812 /* STOP records the value of P at which we will need
813 to think about the gap, or about invisible text,
814 or about the end of the buffer. */
816 /* START records the starting value of P. */
824 /* If we have updated P, set POS_BYTE to match.
825 The first time we enter the loop, POS_BYTE is already right. */
827 pos_byte
= PTR_BYTE_POS (p
);
828 /* Consider the various reasons STOP might have been set here. */
829 if (pos_byte
== ZV_BYTE
)
831 if (pos_byte
== next_boundary_byte
)
834 int pos
= BYTE_TO_CHAR (pos_byte
);
835 pos
= skip_invisible (pos
, &next_boundary
, ZV
, Qnil
);
836 pos_byte
= CHAR_TO_BYTE (pos
);
837 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
839 if (pos_byte
>= ceiling
)
840 ceiling
= BUFFER_CEILING_OF (pos_byte
) + 1;
841 /* Compute the next place we need to stop and think,
842 and set STOP accordingly. */
843 stop_pos_byte
= min (ceiling
, next_boundary_byte
);
844 /* The -1 and +1 arrange to point at the first byte of gap
845 (if STOP_POS_BYTE is the position of the gap)
846 rather than at the data after the gap. */
848 stop
= BYTE_POS_ADDR (stop_pos_byte
- 1) + 1;
849 p
= BYTE_POS_ADDR (pos_byte
);
854 if (! NILP (current_buffer
->enable_multibyte_characters
))
860 column
+= tab_width
- column
% tab_width
;
863 if (ASCII_BYTE_P (p
[-1])
864 || NILP (current_buffer
->enable_multibyte_characters
))
868 pos_byte
= PTR_BYTE_POS (p
- 1);
869 c
= FETCH_MULTIBYTE_CHAR (pos_byte
);
870 if (CHAR_HAS_CATEGORY (c
, ' '))
874 p
= BYTE_POS_ADDR (pos_byte
);
883 /* Test whether the line beginning at POS is indented beyond COLUMN.
884 Blank lines are treated as if they had the same indentation as the
888 indented_beyond_p (pos
, pos_byte
, column
)
889 int pos
, pos_byte
, column
;
892 int opoint
= PT
, opoint_byte
= PT_BYTE
;
894 SET_PT_BOTH (pos
, pos_byte
);
895 while (PT
> BEGV
&& FETCH_BYTE (PT_BYTE
) == '\n')
896 scan_newline (PT
- 1, PT_BYTE
- 1, BEGV
, BEGV_BYTE
, -1, 0);
898 val
= position_indentation (PT_BYTE
);
899 SET_PT_BOTH (opoint
, opoint_byte
);
900 return val
>= column
;
903 DEFUN ("move-to-column", Fmove_to_column
, Smove_to_column
, 1, 2, "p",
904 doc
: /* Move point to column COLUMN in the current line.
905 The column of a character is calculated by adding together the widths
906 as displayed of the previous characters in the line.
907 This function ignores line-continuation;
908 there is no upper limit on the column number a character can have
909 and horizontal scrolling has no effect.
911 If specified column is within a character, point goes after that character.
912 If it's past end of line, point goes to end of line.
914 A non-nil second (optional) argument FORCE means,
915 if COLUMN is in the middle of a tab character, change it to spaces.
916 In addition, if FORCE is t, and the line is too short
917 to reach column COLUMN, add spaces/tabs to get there.
919 The return value is the current column. */)
921 Lisp_Object column
, force
;
924 register int col
= current_column ();
927 register int tab_width
= XINT (current_buffer
->tab_width
);
928 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
929 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
930 register int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
937 int pos_byte
, end_byte
, next_boundary_byte
;
939 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
940 CHECK_NATNUM (column
);
941 goal
= XINT (column
);
948 next_boundary_byte
= PT_BYTE
;
950 /* If we're starting past the desired column,
951 back up to beginning of line and scan from there. */
955 pos
= current_column_bol_cache
;
956 pos_byte
= CHAR_TO_BYTE (pos
);
962 while (pos
== next_boundary
)
965 pos
= skip_invisible (pos
, &next_boundary
, end
, Qnil
);
967 pos_byte
= CHAR_TO_BYTE (pos
);
968 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
973 /* Test reaching the goal column. We do this after skipping
974 invisible characters, so that we put point before the
975 character on which the cursor will appear. */
979 /* Check composition sequence. */
981 int len
, len_byte
, width
;
983 if (check_composition (pos
, pos_byte
, Z
, &len
, &len_byte
, &width
))
986 pos_byte
+= len_byte
;
992 c
= FETCH_BYTE (pos_byte
);
994 /* See if there is a display table and it relates
995 to this character. */
998 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
999 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1001 Lisp_Object charvec
;
1004 /* This character is displayed using a vector of glyphs.
1005 Update the position based on those glyphs. */
1007 charvec
= DISP_CHAR_VECTOR (dp
, c
);
1008 n
= ASIZE (charvec
);
1010 for (i
= 0; i
< n
; i
++)
1012 /* This should be handled the same as
1013 next_element_from_display_vector does it. */
1016 entry
= AREF (charvec
, i
);
1018 if (INTEGERP (entry
)
1019 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
1020 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
1026 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
1032 col
= col
/ tab_width
* tab_width
;
1040 /* The display table doesn't affect this character;
1041 it displays as itself. */
1045 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
1051 col
= col
/ tab_width
* tab_width
;
1053 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
1055 else if (c
< 040 || c
== 0177)
1059 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
1061 /* Start of multi-byte form. */
1063 int bytes
, width
, wide_column
;
1065 ptr
= BYTE_POS_ADDR (pos_byte
);
1066 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
1067 pos_byte
+= bytes
- 1;
1079 SET_PT_BOTH (pos
, pos_byte
);
1081 /* If a tab char made us overshoot, change it to spaces
1082 and scan through it again. */
1083 if (!NILP (force
) && col
> goal
&& c
== '\t' && prev_col
< goal
)
1085 int goal_pt
, goal_pt_byte
;
1087 /* Insert spaces in front of the tab to reach GOAL. Do this
1088 first so that a marker at the end of the tab gets
1090 SET_PT_BOTH (PT
- 1, PT_BYTE
- 1);
1091 Finsert_char (make_number (' '), make_number (goal
- prev_col
), Qt
);
1093 /* Now delete the tab, and indent to COL. */
1094 del_range (PT
, PT
+ 1);
1096 goal_pt_byte
= PT_BYTE
;
1097 Findent_to (make_number (col
), Qnil
);
1098 SET_PT_BOTH (goal_pt
, goal_pt_byte
);
1100 /* Set the last_known... vars consistently. */
1104 /* If line ends prematurely, add space to the end. */
1105 if (col
< goal
&& EQ (force
, Qt
))
1106 Findent_to (make_number (col
= goal
), Qnil
);
1108 last_known_column
= col
;
1109 last_known_column_point
= PT
;
1110 last_known_column_modified
= MODIFF
;
1112 XSETFASTINT (val
, col
);
1116 /* compute_motion: compute buffer posn given screen posn and vice versa */
1118 struct position val_compute_motion
;
1120 /* Scan the current buffer forward from offset FROM, pretending that
1121 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
1122 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
1123 and return the ending buffer position and screen location. If we
1124 can't hit the requested column exactly (because of a tab or other
1125 multi-column character), overshoot.
1127 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
1128 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
1129 earlier call to compute_motion. The other common case is that FROMHPOS
1130 is zero and FROM is a position that "belongs" at column zero, but might
1131 be shifted by overlay strings; in this case DID_MOTION should be 0.
1133 WIDTH is the number of columns available to display text;
1134 compute_motion uses this to handle continuation lines and such.
1135 HSCROLL is the number of columns not being displayed at the left
1136 margin; this is usually taken from a window's hscroll member.
1137 TAB_OFFSET is the number of columns of the first tab that aren't
1138 being displayed, perhaps because of a continuation line or
1141 compute_motion returns a pointer to a struct position. The bufpos
1142 member gives the buffer position at the end of the scan, and hpos
1143 and vpos give its cartesian location. prevhpos is the column at
1144 which the character before bufpos started, and contin is non-zero
1145 if we reached the current line by continuing the previous.
1147 Note that FROMHPOS and TOHPOS should be expressed in real screen
1148 columns, taking HSCROLL and the truncation glyph at the left margin
1149 into account. That is, beginning-of-line moves you to the hpos
1150 -HSCROLL + (HSCROLL > 0).
1152 For example, to find the buffer position of column COL of line LINE
1153 of a certain window, pass the window's starting location as FROM
1154 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
1155 Pass the buffer's ZV as TO, to limit the scan to the end of the
1156 visible section of the buffer, and pass LINE and COL as TOVPOS and
1159 When displaying in window w, a typical formula for WIDTH is:
1162 - (has_vertical_scroll_bars
1163 ? FRAME_SCROLL_BAR_COLS (XFRAME (window->frame))
1164 : (window_width + window_left != frame_width))
1167 window_width is XFASTINT (w->width),
1168 window_left is XFASTINT (w->left),
1169 has_vertical_scroll_bars is
1170 FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (WINDOW_FRAME (window)))
1171 and frame_width = FRAME_WIDTH (XFRAME (window->frame))
1173 Or you can let window_internal_width do this all for you, and write:
1174 window_internal_width (w) - 1
1176 The `-1' accounts for the continuation-line backslashes; the rest
1177 accounts for window borders if the window is split horizontally, and
1178 the scroll bars if they are turned on. */
1181 compute_motion (from
, fromvpos
, fromhpos
, did_motion
, to
, tovpos
, tohpos
, width
, hscroll
, tab_offset
, win
)
1182 int from
, fromvpos
, fromhpos
, to
, tovpos
, tohpos
;
1185 int hscroll
, tab_offset
;
1188 register int hpos
= fromhpos
;
1189 register int vpos
= fromvpos
;
1194 register int tab_width
= XFASTINT (current_buffer
->tab_width
);
1195 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
1196 register struct Lisp_Char_Table
*dp
= window_display_table (win
);
1198 = (INTEGERP (current_buffer
->selective_display
)
1199 ? XINT (current_buffer
->selective_display
)
1200 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1203 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
1204 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
: 0);
1205 /* The next location where the `invisible' property changes, or an
1206 overlay starts or ends. */
1207 int next_boundary
= from
;
1209 /* For computing runs of characters with similar widths.
1210 Invariant: width_run_width is zero, or all the characters
1211 from width_run_start to width_run_end have a fixed width of
1213 int width_run_start
= from
;
1214 int width_run_end
= from
;
1215 int width_run_width
= 0;
1216 Lisp_Object
*width_table
;
1219 /* The next buffer pos where we should consult the width run cache. */
1220 int next_width_run
= from
;
1223 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
1224 /* If previous char scanned was a wide character,
1225 this is the column where it ended. Otherwise, this is 0. */
1226 int wide_column_end_hpos
= 0;
1227 int prev_pos
; /* Previous buffer position. */
1228 int prev_pos_byte
; /* Previous buffer position. */
1229 int contin_hpos
; /* HPOS of last column of continued line. */
1230 int prev_tab_offset
; /* Previous tab offset. */
1232 XSETBUFFER (buffer
, current_buffer
);
1233 XSETWINDOW (window
, win
);
1235 width_run_cache_on_off ();
1236 if (dp
== buffer_display_table ())
1237 width_table
= (VECTORP (current_buffer
->width_table
)
1238 ? XVECTOR (current_buffer
->width_table
)->contents
1241 /* If the window has its own display table, we can't use the width
1242 run cache, because that's based on the buffer's display table. */
1245 if (tab_width
<= 0 || tab_width
> 1000)
1251 pos
= prev_pos
= from
;
1252 pos_byte
= prev_pos_byte
= CHAR_TO_BYTE (from
);
1254 prev_tab_offset
= tab_offset
;
1257 while (pos
== next_boundary
)
1262 /* Don't skip invisible if we are already at the margin. */
1263 if (vpos
> tovpos
|| vpos
== tovpos
&& hpos
>= tohpos
)
1265 if (contin_hpos
&& prev_hpos
== 0
1267 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1268 { /* Line breaks because we can't put the character at the
1269 previous line any more. It is not the multi-column
1270 character continued in middle. Go back to previous
1271 buffer position, screen position, and set tab offset
1272 to previous value. It's the beginning of the
1275 pos_byte
= prev_pos_byte
;
1277 tab_offset
= prev_tab_offset
;
1282 /* If the caller says that the screen position came from an earlier
1283 call to compute_motion, then we've already accounted for the
1284 overlay strings at point. This is only true the first time
1285 through, so clear the flag after testing it. */
1287 /* We need to skip past the overlay strings. Currently those
1288 strings must not contain TAB;
1289 if we want to relax that restriction, something will have
1290 to be changed here. */
1292 unsigned char *ovstr
;
1293 int ovlen
= overlay_strings (pos
, win
, &ovstr
);
1294 hpos
+= ((multibyte
&& ovlen
> 0)
1295 ? strwidth (ovstr
, ovlen
) : ovlen
);
1302 /* Advance POS past invisible characters
1303 (but not necessarily all that there are here),
1304 and store in next_boundary the next position where
1305 we need to call skip_invisible. */
1306 newpos
= skip_invisible (pos
, &next_boundary
, to
, window
);
1310 pos
= min (to
, newpos
);
1311 pos_byte
= CHAR_TO_BYTE (pos
);
1315 if (newpos
!= pos_here
)
1318 pos_byte
= CHAR_TO_BYTE (pos
);
1322 /* Handle right margin. */
1323 /* Note on a wide-column character.
1325 Characters are classified into the following three categories
1326 according to the width (columns occupied on screen).
1328 (1) single-column character: ex. `a'
1329 (2) multi-column character: ex. `^A', TAB, `\033'
1330 (3) wide-column character: ex. Japanese character, Chinese character
1331 (In the following example, `W_' stands for them.)
1333 Multi-column characters can be divided around the right margin,
1334 but wide-column characters cannot.
1338 (*) The cursor is placed on the next character after the point.
1342 j ^---- next after the point
1343 ^--- next char. after the point.
1345 In case of sigle-column character
1349 033 ^---- next after the point, next char. after the point.
1351 In case of multi-column character
1355 W_ ^---- next after the point
1356 ^---- next char. after the point.
1358 In case of wide-column character
1360 The problem here is continuation at a wide-column character.
1361 In this case, the line may shorter less than WIDTH.
1362 And we find the continuation AFTER it occurs.
1369 || (truncate_partial_width_windows
1370 && width
+ 1 < FRAME_WIDTH (XFRAME (WINDOW_FRAME (win
))))
1371 || !NILP (current_buffer
->truncate_lines
))
1373 /* Truncating: skip to newline, unless we are already past
1374 TO (we need to go back below). */
1377 pos
= find_before_next_newline (pos
, to
, 1);
1378 pos_byte
= CHAR_TO_BYTE (pos
);
1380 /* If we just skipped next_boundary,
1381 loop around in the main while
1383 if (pos
>= next_boundary
)
1384 next_boundary
= pos
+ 1;
1386 prev_tab_offset
= tab_offset
;
1392 /* Remember the previous value. */
1393 prev_tab_offset
= tab_offset
;
1395 if (wide_column_end_hpos
> width
)
1398 tab_offset
+= prev_hpos
;
1402 tab_offset
+= width
;
1406 contin_hpos
= prev_hpos
;
1411 /* Stop if past the target buffer position or screen position. */
1414 /* Go back to the previous position. */
1416 pos_byte
= prev_pos_byte
;
1418 tab_offset
= prev_tab_offset
;
1420 /* NOTE on contin_hpos, hpos, and prev_hpos.
1424 W_ ^---- contin_hpos
1430 if (contin_hpos
&& prev_hpos
== 0
1431 && contin_hpos
< width
&& !wide_column_end_hpos
)
1433 /* Line breaking occurs in the middle of multi-column
1434 character. Go back to previous line. */
1439 /* If previous character is NEWLINE,
1440 set VPOS back to previous line */
1445 if (vpos
> tovpos
|| vpos
== tovpos
&& hpos
>= tohpos
)
1447 if (contin_hpos
&& prev_hpos
== 0
1449 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1450 { /* Line breaks because we can't put the character at the
1451 previous line any more. It is not the multi-column
1452 character continued in middle. Go back to previous
1453 buffer position, screen position, and set tab offset
1454 to previous value. It's the beginning of the
1457 pos_byte
= prev_pos_byte
;
1459 tab_offset
= prev_tab_offset
;
1463 if (pos
== ZV
) /* We cannot go beyond ZV. Stop here. */
1468 prev_pos_byte
= pos_byte
;
1469 wide_column_end_hpos
= 0;
1471 /* Consult the width run cache to see if we can avoid inspecting
1472 the text character-by-character. */
1473 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
1477 = region_cache_forward (current_buffer
,
1478 current_buffer
->width_run_cache
,
1481 /* A width of zero means the character's width varies (like
1482 a tab), is meaningless (like a newline), or we just don't
1483 want to skip over it for some other reason. */
1484 if (common_width
!= 0)
1488 /* Don't go past the final buffer posn the user
1493 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1495 /* Don't go past the final horizontal position the user
1497 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
1499 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
1500 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1503 /* Don't go past the margin. */
1504 if (run_end_hpos
>= width
)
1506 run_end
= pos
+ (width
- hpos
) / common_width
;
1507 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1510 hpos
= run_end_hpos
;
1512 prev_hpos
= hpos
- common_width
;
1516 pos_byte
= CHAR_TO_BYTE (pos
);
1520 next_width_run
= run_end
+ 1;
1523 /* We have to scan the text character-by-character. */
1527 Lisp_Object charvec
;
1529 c
= FETCH_BYTE (pos_byte
);
1531 /* Check composition sequence. */
1533 int len
, len_byte
, width
;
1535 if (check_composition (pos
, pos_byte
, to
, &len
, &len_byte
, &width
))
1538 pos_byte
+= len_byte
;
1546 /* Perhaps add some info to the width_run_cache. */
1547 if (current_buffer
->width_run_cache
)
1549 /* Is this character part of the current run? If so, extend
1551 if (pos
- 1 == width_run_end
1552 && XFASTINT (width_table
[c
]) == width_run_width
)
1553 width_run_end
= pos
;
1555 /* The previous run is over, since this is a character at a
1556 different position, or a different width. */
1559 /* Have we accumulated a run to put in the cache?
1560 (Currently, we only cache runs of width == 1). */
1561 if (width_run_start
< width_run_end
1562 && width_run_width
== 1)
1563 know_region_cache (current_buffer
,
1564 current_buffer
->width_run_cache
,
1565 width_run_start
, width_run_end
);
1567 /* Start recording a new width run. */
1568 width_run_width
= XFASTINT (width_table
[c
]);
1569 width_run_start
= pos
- 1;
1570 width_run_end
= pos
;
1575 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
1576 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1578 charvec
= DISP_CHAR_VECTOR (dp
, c
);
1579 n
= ASIZE (charvec
);
1587 for (i
= n
- 1; i
>= 0; --i
)
1589 if (VECTORP (charvec
))
1591 /* This should be handled the same as
1592 next_element_from_display_vector does it. */
1593 Lisp_Object entry
= AREF (charvec
, i
);
1595 if (INTEGERP (entry
)
1596 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
1597 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
1602 if (c
>= 040 && c
< 0177)
1606 int tem
= ((hpos
+ tab_offset
+ hscroll
- (hscroll
> 0))
1610 hpos
+= tab_width
- tem
;
1615 && indented_beyond_p (pos
, pos_byte
, selective
))
1617 /* If (pos == to), we don't have to take care of
1618 selective display. */
1621 /* Skip any number of invisible lines all at once */
1624 pos
= find_before_next_newline (pos
, to
, 1);
1627 pos_byte
= CHAR_TO_BYTE (pos
);
1630 && indented_beyond_p (pos
, pos_byte
, selective
));
1631 /* Allow for the " ..." that is displayed for them. */
1634 hpos
+= selective_rlen
;
1638 DEC_BOTH (pos
, pos_byte
);
1639 /* We have skipped the invis text, but not the
1645 /* A visible line. */
1649 /* Count the truncation glyph on column 0 */
1656 else if (c
== CR
&& selective
< 0)
1658 /* In selective display mode,
1659 everything from a ^M to the end of the line is invisible.
1660 Stop *before* the real newline. */
1663 pos
= find_before_next_newline (pos
, to
, 1);
1664 pos_byte
= CHAR_TO_BYTE (pos
);
1666 /* If we just skipped next_boundary,
1667 loop around in the main while
1669 if (pos
> next_boundary
)
1670 next_boundary
= pos
;
1671 /* Allow for the " ..." that is displayed for them. */
1674 hpos
+= selective_rlen
;
1679 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
1681 /* Start of multi-byte form. */
1683 int bytes
, width
, wide_column
;
1685 pos_byte
--; /* rewind POS_BYTE */
1686 ptr
= BYTE_POS_ADDR (pos_byte
);
1687 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
1690 wide_column_end_hpos
= hpos
+ wide_column
;
1693 else if (VECTORP (charvec
))
1696 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
1703 /* Remember any final width run in the cache. */
1704 if (current_buffer
->width_run_cache
1705 && width_run_width
== 1
1706 && width_run_start
< width_run_end
)
1707 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
1708 width_run_start
, width_run_end
);
1710 val_compute_motion
.bufpos
= pos
;
1711 val_compute_motion
.bytepos
= pos_byte
;
1712 val_compute_motion
.hpos
= hpos
;
1713 val_compute_motion
.vpos
= vpos
;
1714 if (contin_hpos
&& prev_hpos
== 0)
1715 val_compute_motion
.prevhpos
= contin_hpos
;
1717 val_compute_motion
.prevhpos
= prev_hpos
;
1718 /* We alalways handle all of them here; none of them remain to do. */
1719 val_compute_motion
.ovstring_chars_done
= 0;
1721 /* Nonzero if have just continued a line */
1722 val_compute_motion
.contin
= (contin_hpos
&& prev_hpos
== 0);
1725 return &val_compute_motion
;
1729 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
1730 doc
: /* Scan through the current buffer, calculating screen position.
1731 Scan the current buffer forward from offset FROM,
1732 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--
1733 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--
1734 and return the ending buffer position and screen location.
1736 There are three additional arguments:
1738 WIDTH is the number of columns available to display text;
1739 this affects handling of continuation lines.
1740 This is usually the value returned by `window-width', less one (to allow
1741 for the continuation glyph).
1743 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).
1744 HSCROLL is the number of columns not being displayed at the left
1745 margin; this is usually taken from a window's hscroll member.
1746 TAB-OFFSET is the number of columns of the first tab that aren't
1747 being displayed, perhaps because the line was continued within it.
1748 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.
1750 WINDOW is the window to operate on. It is used to choose the display table;
1751 if it is showing the current buffer, it is used also for
1752 deciding which overlay properties apply.
1753 Note that `compute-motion' always operates on the current buffer.
1755 The value is a list of five elements:
1756 (POS HPOS VPOS PREVHPOS CONTIN)
1757 POS is the buffer position where the scan stopped.
1758 VPOS is the vertical position where the scan stopped.
1759 HPOS is the horizontal position where the scan stopped.
1761 PREVHPOS is the horizontal position one character back from POS.
1762 CONTIN is t if a line was continued after (or within) the previous character.
1764 For example, to find the buffer position of column COL of line LINE
1765 of a certain window, pass the window's starting location as FROM
1766 and the window's upper-left coordinates as FROMPOS.
1767 Pass the buffer's (point-max) as TO, to limit the scan to the end of the
1768 visible section of the buffer, and pass LINE and COL as TOPOS. */)
1769 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1770 Lisp_Object from
, frompos
, to
, topos
;
1771 Lisp_Object width
, offsets
, window
;
1773 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
;
1774 struct position
*pos
;
1775 int hscroll
, tab_offset
;
1777 CHECK_NUMBER_COERCE_MARKER (from
);
1778 CHECK_CONS (frompos
);
1779 CHECK_NUMBER_CAR (frompos
);
1780 CHECK_NUMBER_CDR (frompos
);
1781 CHECK_NUMBER_COERCE_MARKER (to
);
1783 CHECK_NUMBER_CAR (topos
);
1784 CHECK_NUMBER_CDR (topos
);
1785 CHECK_NUMBER (width
);
1786 if (!NILP (offsets
))
1788 CHECK_CONS (offsets
);
1789 CHECK_NUMBER_CAR (offsets
);
1790 CHECK_NUMBER_CDR (offsets
);
1791 hscroll
= XINT (XCAR (offsets
));
1792 tab_offset
= XINT (XCDR (offsets
));
1795 hscroll
= tab_offset
= 0;
1798 window
= Fselected_window ();
1800 CHECK_LIVE_WINDOW (window
);
1802 if (XINT (from
) < BEGV
|| XINT (from
) > ZV
)
1803 args_out_of_range_3 (from
, make_number (BEGV
), make_number (ZV
));
1804 if (XINT (to
) < BEGV
|| XINT (to
) > ZV
)
1805 args_out_of_range_3 (to
, make_number (BEGV
), make_number (ZV
));
1807 pos
= compute_motion (XINT (from
), XINT (XCDR (frompos
)),
1808 XINT (XCAR (frompos
)), 0,
1809 XINT (to
), XINT (XCDR (topos
)),
1810 XINT (XCAR (topos
)),
1811 XINT (width
), hscroll
, tab_offset
,
1814 XSETFASTINT (bufpos
, pos
->bufpos
);
1815 XSETINT (hpos
, pos
->hpos
);
1816 XSETINT (vpos
, pos
->vpos
);
1817 XSETINT (prevhpos
, pos
->prevhpos
);
1819 return Fcons (bufpos
,
1823 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
1827 /* Fvertical_motion and vmotion */
1829 struct position val_vmotion
;
1832 vmotion (from
, vtarget
, w
)
1833 register int from
, vtarget
;
1836 int width
= window_internal_width (w
) - 1;
1837 int hscroll
= XINT (w
->hscroll
);
1838 struct position pos
;
1839 /* vpos is cumulative vertical position, changed as from is changed */
1840 register int vpos
= 0;
1841 Lisp_Object prevline
;
1844 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1846 = (INTEGERP (current_buffer
->selective_display
)
1847 ? XINT (current_buffer
->selective_display
)
1848 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1852 /* This is the object we use for fetching character properties. */
1853 Lisp_Object text_prop_object
;
1855 XSETWINDOW (window
, w
);
1857 /* If the window contains this buffer, use it for getting text properties.
1858 Otherwise use the current buffer as arg for doing that. */
1859 if (EQ (w
->buffer
, Fcurrent_buffer ()))
1860 text_prop_object
= window
;
1862 text_prop_object
= Fcurrent_buffer ();
1864 if (vpos
>= vtarget
)
1866 /* To move upward, go a line at a time until
1867 we have gone at least far enough. */
1871 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1873 Lisp_Object propval
;
1875 XSETFASTINT (prevline
, find_next_newline_no_quit (from
- 1, -1));
1876 while (XFASTINT (prevline
) > BEGV
1878 && indented_beyond_p (XFASTINT (prevline
),
1879 CHAR_TO_BYTE (XFASTINT (prevline
)),
1881 /* watch out for newlines with `invisible' property */
1882 || (propval
= Fget_char_property (prevline
,
1885 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1886 XSETFASTINT (prevline
,
1887 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1889 pos
= *compute_motion (XFASTINT (prevline
), 0,
1890 lmargin
+ (XFASTINT (prevline
) == BEG
1894 /* Don't care for VPOS... */
1895 1 << (BITS_PER_SHORT
- 1),
1897 1 << (BITS_PER_SHORT
- 1),
1899 /* This compensates for start_hpos
1900 so that a tab as first character
1901 still occupies 8 columns. */
1902 (XFASTINT (prevline
) == BEG
1907 from
= XFASTINT (prevline
);
1910 /* If we made exactly the desired vertical distance,
1911 or if we hit beginning of buffer,
1912 return point found */
1913 if (vpos
>= vtarget
)
1915 val_vmotion
.bufpos
= from
;
1916 val_vmotion
.bytepos
= CHAR_TO_BYTE (from
);
1917 val_vmotion
.vpos
= vpos
;
1918 val_vmotion
.hpos
= lmargin
;
1919 val_vmotion
.contin
= 0;
1920 val_vmotion
.prevhpos
= 0;
1921 val_vmotion
.ovstring_chars_done
= 0;
1922 val_vmotion
.tab_offset
= 0; /* For accumulating tab offset. */
1923 return &val_vmotion
;
1926 /* Otherwise find the correct spot by moving down */
1928 /* Moving downward is simple, but must calculate from beg of line
1929 to determine hpos of starting point */
1930 from_byte
= CHAR_TO_BYTE (from
);
1931 if (from
> BEGV
&& FETCH_BYTE (from_byte
- 1) != '\n')
1933 Lisp_Object propval
;
1935 XSETFASTINT (prevline
, find_next_newline_no_quit (from
, -1));
1936 while (XFASTINT (prevline
) > BEGV
1938 && indented_beyond_p (XFASTINT (prevline
),
1939 CHAR_TO_BYTE (XFASTINT (prevline
)),
1941 /* watch out for newlines with `invisible' property */
1942 || (propval
= Fget_char_property (prevline
, Qinvisible
,
1944 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1945 XSETFASTINT (prevline
,
1946 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1948 pos
= *compute_motion (XFASTINT (prevline
), 0,
1949 lmargin
+ (XFASTINT (prevline
) == BEG
1953 /* Don't care for VPOS... */
1954 1 << (BITS_PER_SHORT
- 1),
1956 1 << (BITS_PER_SHORT
- 1),
1958 (XFASTINT (prevline
) == BEG
? -start_hpos
: 0),
1964 pos
.hpos
= lmargin
+ (from
== BEG
? start_hpos
: 0);
1969 return compute_motion (from
, vpos
, pos
.hpos
, did_motion
,
1970 ZV
, vtarget
, - (1 << (BITS_PER_SHORT
- 1)),
1972 pos
.tab_offset
- (from
== BEG
? start_hpos
: 0),
1976 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
1977 doc
: /* Move point to start of the screen line LINES lines down.
1978 If LINES is negative, this means moving up.
1980 This function is an ordinary cursor motion function
1981 which calculates the new position based on how text would be displayed.
1982 The new position may be the start of a line,
1983 or just the start of a continuation line.
1984 The function returns number of screen lines moved over;
1985 that usually equals LINES, but may be closer to zero
1986 if beginning or end of buffer was reached.
1988 The optional second argument WINDOW specifies the window to use for
1989 parameters such as width, horizontal scrolling, and so on.
1990 The default is to use the selected window's parameters.
1992 `vertical-motion' always uses the current buffer,
1993 regardless of which buffer is displayed in WINDOW.
1994 This is consistent with other cursor motion functions
1995 and makes it possible to use `vertical-motion' in any buffer,
1996 whether or not it is currently displayed in some window. */)
1998 Lisp_Object lines
, window
;
2003 Lisp_Object old_buffer
;
2004 struct gcpro gcpro1
;
2006 CHECK_NUMBER (lines
);
2007 if (! NILP (window
))
2008 CHECK_WINDOW (window
);
2010 window
= selected_window
;
2011 w
= XWINDOW (window
);
2014 GCPRO1 (old_buffer
);
2015 if (XBUFFER (w
->buffer
) != current_buffer
)
2017 /* Set the window's buffer temporarily to the current buffer. */
2018 old_buffer
= w
->buffer
;
2019 XSETBUFFER (w
->buffer
, current_buffer
);
2022 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
2023 start_display (&it
, w
, pt
);
2024 move_it_by_lines (&it
, XINT (lines
), 0);
2025 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
2027 if (BUFFERP (old_buffer
))
2028 w
->buffer
= old_buffer
;
2030 RETURN_UNGCPRO (make_number (it
.vpos
));
2035 /* File's initialization. */
2040 DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode
,
2041 doc
: /* *Indentation can insert tabs if this is non-nil.
2042 Setting this variable automatically makes it local to the current buffer. */);
2043 indent_tabs_mode
= 1;
2045 defsubr (&Scurrent_indentation
);
2046 defsubr (&Sindent_to
);
2047 defsubr (&Scurrent_column
);
2048 defsubr (&Smove_to_column
);
2049 defsubr (&Svertical_motion
);
2050 defsubr (&Scompute_motion
);