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. */
42 #define min(a, b) ((a) < (b) ? (a) : (b))
43 #define max(a, b) ((a) > (b) ? (a) : (b))
47 /* These three values memoize the current column to avoid recalculation. */
49 /* Last value returned by current_column.
50 Some things in set last_known_column_point to -1
51 to mark the memoized value as invalid. */
53 int last_known_column
;
55 /* Value of point when current_column was called. */
57 int last_known_column_point
;
59 /* Value of MODIFF when current_column was called. */
61 int last_known_column_modified
;
63 static int current_column_1
P_ ((void));
64 static int position_indentation
P_ ((int));
66 /* Cache of beginning of line found by the last call of
69 int current_column_bol_cache
;
71 /* Get the display table to use for the current buffer. */
73 struct Lisp_Char_Table
*
74 buffer_display_table ()
78 thisbuf
= current_buffer
->display_table
;
79 if (DISP_TABLE_P (thisbuf
))
80 return XCHAR_TABLE (thisbuf
);
81 if (DISP_TABLE_P (Vstandard_display_table
))
82 return XCHAR_TABLE (Vstandard_display_table
);
86 /* Width run cache considerations. */
88 /* Return the width of character C under display table DP. */
91 character_width (c
, dp
)
93 struct Lisp_Char_Table
*dp
;
97 /* These width computations were determined by examining the cases
98 in display_text_line. */
100 /* Everything can be handled by the display table, if it's
101 present and the element is right. */
102 if (dp
&& (elt
= DISP_CHAR_VECTOR (dp
, c
), VECTORP (elt
)))
103 return XVECTOR (elt
)->size
;
105 /* Some characters are special. */
106 if (c
== '\n' || c
== '\t' || c
== '\015')
109 /* Printing characters have width 1. */
110 else if (c
>= 040 && c
< 0177)
113 /* Everybody else (control characters, metacharacters) has other
114 widths. We could return their actual widths here, but they
115 depend on things like ctl_arrow and crud like that, and they're
116 not very common at all. So we'll just claim we don't know their
122 /* Return true iff the display table DISPTAB specifies the same widths
123 for characters as WIDTHTAB. We use this to decide when to
124 invalidate the buffer's width_run_cache. */
127 disptab_matches_widthtab (disptab
, widthtab
)
128 struct Lisp_Char_Table
*disptab
;
129 struct Lisp_Vector
*widthtab
;
133 if (widthtab
->size
!= 256)
136 for (i
= 0; i
< 256; i
++)
137 if (character_width (i
, disptab
)
138 != XFASTINT (widthtab
->contents
[i
]))
144 /* Recompute BUF's width table, using the display table DISPTAB. */
147 recompute_width_table (buf
, disptab
)
149 struct Lisp_Char_Table
*disptab
;
152 struct Lisp_Vector
*widthtab
;
154 if (!VECTORP (buf
->width_table
))
155 buf
->width_table
= Fmake_vector (make_number (256), make_number (0));
156 widthtab
= XVECTOR (buf
->width_table
);
157 if (widthtab
->size
!= 256)
160 for (i
= 0; i
< 256; i
++)
161 XSETFASTINT (widthtab
->contents
[i
], character_width (i
, disptab
));
164 /* Allocate or free the width run cache, as requested by the current
165 state of current_buffer's cache_long_line_scans variable. */
168 width_run_cache_on_off ()
170 if (NILP (current_buffer
->cache_long_line_scans
)
171 /* And, for the moment, this feature doesn't work on multibyte
173 || !NILP (current_buffer
->enable_multibyte_characters
))
175 /* It should be off. */
176 if (current_buffer
->width_run_cache
)
178 free_region_cache (current_buffer
->width_run_cache
);
179 current_buffer
->width_run_cache
= 0;
180 current_buffer
->width_table
= Qnil
;
185 /* It should be on. */
186 if (current_buffer
->width_run_cache
== 0)
188 current_buffer
->width_run_cache
= new_region_cache ();
189 recompute_width_table (current_buffer
, buffer_display_table ());
195 /* Skip some invisible characters starting from POS.
196 This includes characters invisible because of text properties
197 and characters invisible because of overlays.
199 If position POS is followed by invisible characters,
200 skip some of them and return the position after them.
201 Otherwise return POS itself.
203 Set *NEXT_BOUNDARY_P to the next position at which
204 it will be necessary to call this function again.
206 Don't scan past TO, and don't set *NEXT_BOUNDARY_P
207 to a value greater than TO.
209 If WINDOW is non-nil, and this buffer is displayed in WINDOW,
210 take account of overlays that apply only in WINDOW.
212 We don't necessarily skip all the invisible characters after POS
213 because that could take a long time. We skip a reasonable number
214 which can be skipped quickly. If there might be more invisible
215 characters immediately following, then *NEXT_BOUNDARY_P
216 will equal the return value. */
219 skip_invisible (pos
, next_boundary_p
, to
, window
)
221 int *next_boundary_p
;
225 Lisp_Object prop
, position
, overlay_limit
, proplimit
;
229 XSETFASTINT (position
, pos
);
230 XSETBUFFER (buffer
, current_buffer
);
232 /* Give faster response for overlay lookup near POS. */
233 recenter_overlay_lists (current_buffer
, pos
);
235 /* We must not advance farther than the next overlay change.
236 The overlay change might change the invisible property;
237 or there might be overlay strings to be displayed there. */
238 overlay_limit
= Fnext_overlay_change (position
);
239 /* As for text properties, this gives a lower bound
240 for where the invisible text property could change. */
241 proplimit
= Fnext_property_change (position
, buffer
, Qt
);
242 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
243 proplimit
= overlay_limit
;
244 /* PROPLIMIT is now a lower bound for the next change
245 in invisible status. If that is plenty far away,
246 use that lower bound. */
247 if (XFASTINT (proplimit
) > pos
+ 100 || XFASTINT (proplimit
) >= to
)
248 *next_boundary_p
= XFASTINT (proplimit
);
249 /* Otherwise, scan for the next `invisible' property change. */
252 /* Don't scan terribly far. */
253 XSETFASTINT (proplimit
, min (pos
+ 100, to
));
254 /* No matter what. don't go past next overlay change. */
255 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
256 proplimit
= overlay_limit
;
257 end
= XFASTINT (Fnext_single_property_change (position
, Qinvisible
,
260 /* Don't put the boundary in the middle of multibyte form if
261 there is no actual property change. */
263 && !NILP (current_buffer
->enable_multibyte_characters
)
265 while (pos
< end
&& !CHAR_HEAD_P (POS_ADDR (end
)))
268 *next_boundary_p
= end
;
270 /* if the `invisible' property is set, we can skip to
271 the next property change */
272 if (!NILP (window
) && EQ (XWINDOW (window
)->buffer
, buffer
))
273 prop
= Fget_char_property (position
, Qinvisible
, window
);
275 prop
= Fget_char_property (position
, Qinvisible
, buffer
);
276 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
277 return *next_boundary_p
;
281 /* If a composition starts at POS/POS_BYTE and it doesn't stride over
282 POINT, set *LEN / *LEN_BYTE to the character and byte lengths, *WIDTH
283 to the width, and return 1. Otherwise, return 0. */
286 check_composition (pos
, pos_byte
, point
, len
, len_byte
, width
)
287 int pos
, pos_byte
, point
;
288 int *len
, *len_byte
, *width
;
294 if (! find_composition (pos
, -1, &start
, &end
, &prop
, Qnil
)
295 || pos
!= start
|| point
< end
296 || !COMPOSITION_VALID_P (start
, end
, prop
))
298 if ((id
= get_composition_id (pos
, pos_byte
, end
- pos
, prop
, Qnil
)) < 0)
301 *len
= COMPOSITION_LENGTH (prop
);
302 *len_byte
= CHAR_TO_BYTE (end
) - pos_byte
;
303 *width
= composition_table
[id
]->width
;
307 /* Set variables WIDTH and BYTES for a multibyte sequence starting at P.
309 DP is a display table or NULL.
311 This macro is used in current_column_1, Fmove_to_column, and
314 #define MULTIBYTE_BYTES_WIDTH(p, dp) \
319 c = STRING_CHAR_AND_LENGTH (p, MAX_MULTIBYTE_LENGTH, bytes); \
320 if (BYTES_BY_CHAR_HEAD (*p) != bytes) \
324 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c))) \
325 width = XVECTOR (DISP_CHAR_VECTOR (dp, c))->size; \
327 width = WIDTH_BY_CHAR_HEAD (*p); \
329 wide_column = width; \
333 DEFUN ("current-column", Fcurrent_column
, Scurrent_column
, 0, 0, 0,
334 "Return the horizontal position of point. Beginning of line is column 0.\n\
335 This is calculated by adding together the widths of all the displayed\n\
336 representations of the character between the start of the previous line\n\
337 and point. (eg control characters will have a width of 2 or 4, tabs\n\
338 will have a variable width)\n\
339 Ignores finite width of frame, which means that this function may return\n\
340 values greater than (frame-width).\n\
341 Whether the line is visible (if `selective-display' is t) has no effect;\n\
342 however, ^M is treated as end of line when `selective-display' is t.")
346 XSETFASTINT (temp
, current_column ());
350 /* Cancel any recorded value of the horizontal position. */
353 invalidate_current_column ()
355 last_known_column_point
= 0;
362 register unsigned char *ptr
, *stop
;
363 register int tab_seen
;
366 register int tab_width
= XINT (current_buffer
->tab_width
);
367 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
368 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
370 if (PT
== last_known_column_point
371 && MODIFF
== last_known_column_modified
)
372 return last_known_column
;
374 /* If the buffer has overlays, text properties,
375 or multibyte characters, use a more general algorithm. */
376 if (BUF_INTERVALS (current_buffer
)
377 || !NILP (current_buffer
->overlays_before
)
378 || !NILP (current_buffer
->overlays_after
)
380 return current_column_1 ();
382 /* Scan backwards from point to the previous newline,
383 counting width. Tab characters are the only complicated case. */
385 /* Make a pointer for decrementing through the chars before point. */
386 ptr
= BYTE_POS_ADDR (PT_BYTE
- 1) + 1;
387 /* Make a pointer to where consecutive chars leave off,
388 going backwards from point. */
391 else if (PT
<= GPT
|| BEGV
> GPT
)
396 if (tab_width
<= 0 || tab_width
> 1000)
399 col
= 0, tab_seen
= 0, post_tab
= 0;
408 /* We stopped either for the beginning of the buffer
410 if (ptr
== BEGV_ADDR
)
413 /* It was the gap. Jump back over it. */
417 /* Check whether that brings us to beginning of buffer. */
424 if (dp
&& VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
426 charvec
= DISP_CHAR_VECTOR (dp
, c
);
435 for (i
= n
- 1; i
>= 0; --i
)
437 if (VECTORP (charvec
))
439 /* This should be handled the same as
440 next_element_from_display_vector does it. */
441 Lisp_Object entry
= AREF (charvec
, i
);
444 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
445 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
450 if (c
>= 040 && c
< 0177)
454 && EQ (current_buffer
->selective_display
, Qt
)))
457 goto start_of_line_found
;
462 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
468 else if (VECTORP (charvec
))
469 /* With a display table entry, C is displayed as is, and
470 not displayed as \NNN or as ^N. If C is a single-byte
471 character, it takes one column. If C is multi-byte in
472 an unibyte buffer, it's translated to unibyte, so it
473 also takes one column. */
476 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
484 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
488 if (ptr
== BEGV_ADDR
)
489 current_column_bol_cache
= BEGV
;
491 current_column_bol_cache
= BYTE_TO_CHAR (PTR_BYTE_POS (ptr
));
493 last_known_column
= col
;
494 last_known_column_point
= PT
;
495 last_known_column_modified
= MODIFF
;
500 /* Return the column number of position POS
501 by scanning forward from the beginning of the line.
502 This function handles characters that are invisible
503 due to text properties or overlays. */
508 register int tab_width
= XINT (current_buffer
->tab_width
);
509 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
510 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
511 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
513 /* Start the scan at the beginning of this line with column number 0. */
514 register int col
= 0;
516 int next_boundary
, next_boundary_byte
;
517 int opoint
= PT
, opoint_byte
= PT_BYTE
;
519 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
520 current_column_bol_cache
= PT
;
521 scan
= PT
, scan_byte
= PT_BYTE
;
522 SET_PT_BOTH (opoint
, opoint_byte
);
523 next_boundary
= scan
;
524 next_boundary_byte
= scan_byte
;
526 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
528 /* Scan forward to the target position. */
529 while (scan
< opoint
)
535 /* Occasionally we may need to skip invisible text. */
536 while (scan
== next_boundary
)
539 /* This updates NEXT_BOUNDARY to the next place
540 where we might need to skip more invisible text. */
541 scan
= skip_invisible (scan
, &next_boundary
, opoint
, Qnil
);
544 if (scan
!= old_scan
)
545 scan_byte
= CHAR_TO_BYTE (scan
);
546 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
549 /* Check composition sequence. */
551 int len
, len_byte
, width
;
553 if (check_composition (scan
, scan_byte
, opoint
,
554 &len
, &len_byte
, &width
))
557 scan_byte
+= len_byte
;
564 c
= FETCH_BYTE (scan_byte
);
567 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
568 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
570 charvec
= DISP_CHAR_VECTOR (dp
, c
);
579 for (i
= n
- 1; i
>= 0; --i
)
581 if (VECTORP (charvec
))
583 /* This should be handled the same as
584 next_element_from_display_vector does it. */
585 Lisp_Object entry
= AREF (charvec
, i
);
588 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
589 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
596 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
604 col
= col
/ tab_width
* tab_width
;
606 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
609 int bytes
, width
, wide_column
;
612 ptr
= BYTE_POS_ADDR (scan_byte
);
613 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
617 else if (VECTORP (charvec
))
619 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
621 else if (c
< 040 || c
>= 0177)
629 last_known_column
= col
;
630 last_known_column_point
= PT
;
631 last_known_column_modified
= MODIFF
;
637 #if 0 /* Not used. */
639 /* Return the width in columns of the part of STRING from BEG to END.
640 If BEG is nil, that stands for the beginning of STRING.
641 If END is nil, that stands for the end of STRING. */
644 string_display_width (string
, beg
, end
)
645 Lisp_Object string
, beg
, end
;
648 register unsigned char *ptr
, *stop
;
649 register int tab_seen
;
652 register int tab_width
= XINT (current_buffer
->tab_width
);
653 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
654 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
658 e
= XSTRING (string
)->size
;
661 CHECK_NUMBER (end
, 0);
669 CHECK_NUMBER (beg
, 0);
673 /* Make a pointer for decrementing through the chars before point. */
674 ptr
= XSTRING (string
)->data
+ e
;
675 /* Make a pointer to where consecutive chars leave off,
676 going backwards from point. */
677 stop
= XSTRING (string
)->data
+ b
;
679 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
681 col
= 0, tab_seen
= 0, post_tab
= 0;
689 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
690 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
691 else if (c
>= 040 && c
< 0177)
698 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
705 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
710 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
720 DEFUN ("indent-to", Findent_to
, Sindent_to
, 1, 2, "NIndent to column: ",
721 "Indent from point with tabs and spaces until COLUMN is reached.\n\
722 Optional second argument MININUM says always do at least MININUM spaces\n\
723 even if that goes past COLUMN; by default, MININUM is zero.")
725 Lisp_Object column
, minimum
;
728 register int fromcol
;
729 register int tab_width
= XINT (current_buffer
->tab_width
);
731 CHECK_NUMBER (column
, 0);
733 XSETFASTINT (minimum
, 0);
734 CHECK_NUMBER (minimum
, 1);
736 fromcol
= current_column ();
737 mincol
= fromcol
+ XINT (minimum
);
738 if (mincol
< XINT (column
)) mincol
= XINT (column
);
740 if (fromcol
== mincol
)
741 return make_number (mincol
);
743 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
745 if (indent_tabs_mode
)
748 XSETFASTINT (n
, mincol
/ tab_width
- fromcol
/ tab_width
);
749 if (XFASTINT (n
) != 0)
751 Finsert_char (make_number ('\t'), n
, Qt
);
753 fromcol
= (mincol
/ tab_width
) * tab_width
;
757 XSETFASTINT (column
, mincol
- fromcol
);
758 Finsert_char (make_number (' '), column
, Qt
);
760 last_known_column
= mincol
;
761 last_known_column_point
= PT
;
762 last_known_column_modified
= MODIFF
;
764 XSETINT (column
, mincol
);
769 static int position_indentation
P_ ((int));
771 DEFUN ("current-indentation", Fcurrent_indentation
, Scurrent_indentation
,
773 "Return the indentation of the current line.\n\
774 This is the horizontal position of the character\n\
775 following any initial whitespace.")
779 int opoint
= PT
, opoint_byte
= PT_BYTE
;
781 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
783 XSETFASTINT (val
, position_indentation (PT_BYTE
));
784 SET_PT_BOTH (opoint
, opoint_byte
);
789 position_indentation (pos_byte
)
790 register int pos_byte
;
792 register int column
= 0;
793 register int tab_width
= XINT (current_buffer
->tab_width
);
794 register unsigned char *p
;
795 register unsigned char *stop
;
796 unsigned char *start
;
797 int next_boundary_byte
= pos_byte
;
798 int ceiling
= next_boundary_byte
;
800 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
802 p
= BYTE_POS_ADDR (pos_byte
);
803 /* STOP records the value of P at which we will need
804 to think about the gap, or about invisible text,
805 or about the end of the buffer. */
807 /* START records the starting value of P. */
815 /* If we have updated P, set POS_BYTE to match.
816 The first time we enter the loop, POS_BYTE is already right. */
818 pos_byte
= PTR_BYTE_POS (p
);
819 /* Consider the various reasons STOP might have been set here. */
820 if (pos_byte
== ZV_BYTE
)
822 if (pos_byte
== next_boundary_byte
)
825 int pos
= BYTE_TO_CHAR (pos_byte
);
826 pos
= skip_invisible (pos
, &next_boundary
, ZV
, Qnil
);
827 pos_byte
= CHAR_TO_BYTE (pos
);
828 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
830 if (pos_byte
>= ceiling
)
831 ceiling
= BUFFER_CEILING_OF (pos_byte
) + 1;
832 /* Compute the next place we need to stop and think,
833 and set STOP accordingly. */
834 stop_pos_byte
= min (ceiling
, next_boundary_byte
);
835 /* The -1 and +1 arrange to point at the first byte of gap
836 (if STOP_POS_BYTE is the position of the gap)
837 rather than at the data after the gap. */
839 stop
= BYTE_POS_ADDR (stop_pos_byte
- 1) + 1;
840 p
= BYTE_POS_ADDR (pos_byte
);
845 if (! NILP (current_buffer
->enable_multibyte_characters
))
851 column
+= tab_width
- column
% tab_width
;
854 if (ASCII_BYTE_P (p
[-1])
855 || NILP (current_buffer
->enable_multibyte_characters
))
859 pos_byte
= PTR_BYTE_POS (p
- 1);
860 c
= FETCH_MULTIBYTE_CHAR (pos_byte
);
861 if (CHAR_HAS_CATEGORY (c
, ' '))
865 p
= BYTE_POS_ADDR (pos_byte
);
874 /* Test whether the line beginning at POS is indented beyond COLUMN.
875 Blank lines are treated as if they had the same indentation as the
879 indented_beyond_p (pos
, pos_byte
, column
)
880 int pos
, pos_byte
, column
;
883 int opoint
= PT
, opoint_byte
= PT_BYTE
;
885 SET_PT_BOTH (pos
, pos_byte
);
886 while (PT
> BEGV
&& FETCH_BYTE (PT_BYTE
) == '\n')
887 scan_newline (PT
- 1, PT_BYTE
- 1, BEGV
, BEGV_BYTE
, -1, 0);
889 val
= position_indentation (PT_BYTE
);
890 SET_PT_BOTH (opoint
, opoint_byte
);
891 return val
>= column
;
894 DEFUN ("move-to-column", Fmove_to_column
, Smove_to_column
, 1, 2, "p",
895 "Move point to column COLUMN in the current line.\n\
896 The column of a character is calculated by adding together the widths\n\
897 as displayed of the previous characters in the line.\n\
898 This function ignores line-continuation;\n\
899 there is no upper limit on the column number a character can have\n\
900 and horizontal scrolling has no effect.\n\
902 If specified column is within a character, point goes after that character.\n\
903 If it's past end of line, point goes to end of line.\n\n\
904 A non-nil second (optional) argument FORCE means,\n\
905 if COLUMN is in the middle of a tab character, change it to spaces.\n\
906 In addition, if FORCE is t, and the line is too short\n\
907 to reach column COLUMN, add spaces/tabs to get there.\n\
909 The return value is the current column.")
911 Lisp_Object column
, force
;
914 register int col
= current_column ();
917 register int tab_width
= XINT (current_buffer
->tab_width
);
918 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
919 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
920 register int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
927 int pos_byte
, end_byte
, next_boundary_byte
;
929 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
930 CHECK_NATNUM (column
, 0);
931 goal
= XINT (column
);
938 next_boundary_byte
= PT_BYTE
;
940 /* If we're starting past the desired column,
941 back up to beginning of line and scan from there. */
945 pos
= current_column_bol_cache
;
946 pos_byte
= CHAR_TO_BYTE (pos
);
955 while (pos
== next_boundary
)
958 pos
= skip_invisible (pos
, &next_boundary
, end
, Qnil
);
960 pos_byte
= CHAR_TO_BYTE (pos
);
961 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
966 /* Test reaching the goal column. We do this after skipping
967 invisible characters, so that we put point before the
968 character on which the cursor will appear. */
972 /* Check composition sequence. */
974 int len
, len_byte
, width
;
976 if (check_composition (pos
, pos_byte
, Z
, &len
, &len_byte
, &width
))
979 pos_byte
+= len_byte
;
985 c
= FETCH_BYTE (pos_byte
);
988 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
989 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
991 charvec
= DISP_CHAR_VECTOR (dp
, c
);
1000 for (i
= n
- 1; i
>= 0; --i
)
1002 if (VECTORP (charvec
))
1004 /* This should be handled the same as
1005 next_element_from_display_vector does it. */
1006 Lisp_Object entry
= AREF (charvec
, i
);
1008 if (INTEGERP (entry
)
1009 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
1010 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
1018 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
1026 col
= col
/ tab_width
* tab_width
;
1028 else if (VECTORP (charvec
))
1030 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
1032 else if (c
< 040 || c
== 0177)
1036 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
1038 /* Start of multi-byte form. */
1040 int bytes
, width
, wide_column
;
1043 ptr
= BYTE_POS_ADDR (pos_byte
);
1044 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
1054 SET_PT_BOTH (pos
, pos_byte
);
1056 /* If a tab char made us overshoot, change it to spaces
1057 and scan through it again. */
1058 if (!NILP (force
) && col
> goal
&& c
== '\t' && prev_col
< goal
)
1060 int goal_pt
, goal_pt_byte
;
1062 /* Insert spaces in front of the tab to reach GOAL. Do this
1063 first so that a marker at the end of the tab gets
1065 SET_PT_BOTH (PT
- 1, PT_BYTE
- 1);
1066 Finsert_char (make_number (' '), make_number (goal
- prev_col
), Qt
);
1068 /* Now delete the tab, and indent to COL. */
1069 del_range (PT
, PT
+ 1);
1071 goal_pt_byte
= PT_BYTE
;
1072 Findent_to (make_number (col
), Qnil
);
1073 SET_PT_BOTH (goal_pt
, goal_pt_byte
);
1075 /* Set the last_known... vars consistently. */
1079 /* If line ends prematurely, add space to the end. */
1080 if (col
< goal
&& EQ (force
, Qt
))
1081 Findent_to (make_number (col
= goal
), Qnil
);
1083 last_known_column
= col
;
1084 last_known_column_point
= PT
;
1085 last_known_column_modified
= MODIFF
;
1087 XSETFASTINT (val
, col
);
1091 /* compute_motion: compute buffer posn given screen posn and vice versa */
1093 struct position val_compute_motion
;
1095 /* Scan the current buffer forward from offset FROM, pretending that
1096 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
1097 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
1098 and return the ending buffer position and screen location. If we
1099 can't hit the requested column exactly (because of a tab or other
1100 multi-column character), overshoot.
1102 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
1103 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
1104 earlier call to compute_motion. The other common case is that FROMHPOS
1105 is zero and FROM is a position that "belongs" at column zero, but might
1106 be shifted by overlay strings; in this case DID_MOTION should be 0.
1108 WIDTH is the number of columns available to display text;
1109 compute_motion uses this to handle continuation lines and such.
1110 HSCROLL is the number of columns not being displayed at the left
1111 margin; this is usually taken from a window's hscroll member.
1112 TAB_OFFSET is the number of columns of the first tab that aren't
1113 being displayed, perhaps because of a continuation line or
1116 compute_motion returns a pointer to a struct position. The bufpos
1117 member gives the buffer position at the end of the scan, and hpos
1118 and vpos give its cartesian location. prevhpos is the column at
1119 which the character before bufpos started, and contin is non-zero
1120 if we reached the current line by continuing the previous.
1122 Note that FROMHPOS and TOHPOS should be expressed in real screen
1123 columns, taking HSCROLL and the truncation glyph at the left margin
1124 into account. That is, beginning-of-line moves you to the hpos
1125 -HSCROLL + (HSCROLL > 0).
1127 For example, to find the buffer position of column COL of line LINE
1128 of a certain window, pass the window's starting location as FROM
1129 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
1130 Pass the buffer's ZV as TO, to limit the scan to the end of the
1131 visible section of the buffer, and pass LINE and COL as TOVPOS and
1134 When displaying in window w, a typical formula for WIDTH is:
1137 - (has_vertical_scroll_bars
1138 ? FRAME_SCROLL_BAR_COLS (XFRAME (window->frame))
1139 : (window_width + window_left != frame_width))
1142 window_width is XFASTINT (w->width),
1143 window_left is XFASTINT (w->left),
1144 has_vertical_scroll_bars is
1145 FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (WINDOW_FRAME (window)))
1146 and frame_width = FRAME_WIDTH (XFRAME (window->frame))
1148 Or you can let window_internal_width do this all for you, and write:
1149 window_internal_width (w) - 1
1151 The `-1' accounts for the continuation-line backslashes; the rest
1152 accounts for window borders if the window is split horizontally, and
1153 the scroll bars if they are turned on. */
1156 compute_motion (from
, fromvpos
, fromhpos
, did_motion
, to
, tovpos
, tohpos
, width
, hscroll
, tab_offset
, win
)
1157 int from
, fromvpos
, fromhpos
, to
, tovpos
, tohpos
;
1160 int hscroll
, tab_offset
;
1163 register int hpos
= fromhpos
;
1164 register int vpos
= fromvpos
;
1169 register int tab_width
= XFASTINT (current_buffer
->tab_width
);
1170 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
1171 register struct Lisp_Char_Table
*dp
= window_display_table (win
);
1173 = (INTEGERP (current_buffer
->selective_display
)
1174 ? XINT (current_buffer
->selective_display
)
1175 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1178 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
1179 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
: 0);
1180 /* The next location where the `invisible' property changes, or an
1181 overlay starts or ends. */
1182 int next_boundary
= from
;
1184 /* For computing runs of characters with similar widths.
1185 Invariant: width_run_width is zero, or all the characters
1186 from width_run_start to width_run_end have a fixed width of
1188 int width_run_start
= from
;
1189 int width_run_end
= from
;
1190 int width_run_width
= 0;
1191 Lisp_Object
*width_table
;
1194 /* The next buffer pos where we should consult the width run cache. */
1195 int next_width_run
= from
;
1198 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
1199 /* If previous char scanned was a wide character,
1200 this is the column where it ended. Otherwise, this is 0. */
1201 int wide_column_end_hpos
= 0;
1202 int prev_pos
; /* Previous buffer position. */
1203 int prev_pos_byte
; /* Previous buffer position. */
1204 int contin_hpos
; /* HPOS of last column of continued line. */
1205 int prev_tab_offset
; /* Previous tab offset. */
1207 XSETBUFFER (buffer
, current_buffer
);
1208 XSETWINDOW (window
, win
);
1210 width_run_cache_on_off ();
1211 if (dp
== buffer_display_table ())
1212 width_table
= (VECTORP (current_buffer
->width_table
)
1213 ? XVECTOR (current_buffer
->width_table
)->contents
1216 /* If the window has its own display table, we can't use the width
1217 run cache, because that's based on the buffer's display table. */
1220 if (tab_width
<= 0 || tab_width
> 1000)
1226 pos
= prev_pos
= from
;
1227 pos_byte
= prev_pos_byte
= CHAR_TO_BYTE (from
);
1229 prev_tab_offset
= tab_offset
;
1232 while (pos
== next_boundary
)
1237 /* Don't skip invisible if we are already at the margin. */
1238 if (vpos
> tovpos
|| vpos
== tovpos
&& hpos
>= tohpos
)
1240 if (contin_hpos
&& prev_hpos
== 0
1242 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1243 { /* Line breaks because we can't put the character at the
1244 previous line any more. It is not the multi-column
1245 character continued in middle. Go back to previous
1246 buffer position, screen position, and set tab offset
1247 to previous value. It's the beginning of the
1250 pos_byte
= prev_pos_byte
;
1252 tab_offset
= prev_tab_offset
;
1257 /* If the caller says that the screen position came from an earlier
1258 call to compute_motion, then we've already accounted for the
1259 overlay strings at point. This is only true the first time
1260 through, so clear the flag after testing it. */
1262 /* We need to skip past the overlay strings. Currently those
1263 strings must not contain TAB;
1264 if we want to relax that restriction, something will have
1265 to be changed here. */
1267 unsigned char *ovstr
;
1268 int ovlen
= overlay_strings (pos
, win
, &ovstr
);
1269 hpos
+= ((multibyte
&& ovlen
> 0)
1270 ? strwidth (ovstr
, ovlen
) : ovlen
);
1277 /* Advance POS past invisible characters
1278 (but not necessarily all that there are here),
1279 and store in next_boundary the next position where
1280 we need to call skip_invisible. */
1281 newpos
= skip_invisible (pos
, &next_boundary
, to
, window
);
1285 pos
= min (to
, newpos
);
1286 pos_byte
= CHAR_TO_BYTE (pos
);
1290 if (newpos
!= pos_here
)
1293 pos_byte
= CHAR_TO_BYTE (pos
);
1297 /* Handle right margin. */
1298 /* Note on a wide-column character.
1300 Characters are classified into the following three categories
1301 according to the width (columns occupied on screen).
1303 (1) single-column character: ex. `a'
1304 (2) multi-column character: ex. `^A', TAB, `\033'
1305 (3) wide-column character: ex. Japanese character, Chinese character
1306 (In the following example, `W_' stands for them.)
1308 Multi-column characters can be divided around the right margin,
1309 but wide-column characters cannot.
1313 (*) The cursor is placed on the next character after the point.
1317 j ^---- next after the point
1318 ^--- next char. after the point.
1320 In case of sigle-column character
1324 033 ^---- next after the point, next char. after the point.
1326 In case of multi-column character
1330 W_ ^---- next after the point
1331 ^---- next char. after the point.
1333 In case of wide-column character
1335 The problem here is continuation at a wide-column character.
1336 In this case, the line may shorter less than WIDTH.
1337 And we find the continuation AFTER it occurs.
1344 || (truncate_partial_width_windows
1345 && width
+ 1 < FRAME_WIDTH (XFRAME (WINDOW_FRAME (win
))))
1346 || !NILP (current_buffer
->truncate_lines
))
1348 /* Truncating: skip to newline, unless we are already past
1349 TO (we need to go back below). */
1352 pos
= find_before_next_newline (pos
, to
, 1);
1353 pos_byte
= CHAR_TO_BYTE (pos
);
1355 /* If we just skipped next_boundary,
1356 loop around in the main while
1358 if (pos
>= next_boundary
)
1359 next_boundary
= pos
+ 1;
1361 prev_tab_offset
= tab_offset
;
1367 /* Remember the previous value. */
1368 prev_tab_offset
= tab_offset
;
1370 if (wide_column_end_hpos
> width
)
1373 tab_offset
+= prev_hpos
;
1377 tab_offset
+= width
;
1381 contin_hpos
= prev_hpos
;
1386 /* Stop if past the target buffer position or screen position. */
1389 /* Go back to the previous position. */
1391 pos_byte
= prev_pos_byte
;
1393 tab_offset
= prev_tab_offset
;
1395 /* NOTE on contin_hpos, hpos, and prev_hpos.
1399 W_ ^---- contin_hpos
1405 if (contin_hpos
&& prev_hpos
== 0
1406 && contin_hpos
< width
&& !wide_column_end_hpos
)
1408 /* Line breaking occurs in the middle of multi-column
1409 character. Go back to previous line. */
1414 /* If previous character is NEWLINE,
1415 set VPOS back to previous line */
1420 if (vpos
> tovpos
|| vpos
== tovpos
&& hpos
>= tohpos
)
1422 if (contin_hpos
&& prev_hpos
== 0
1424 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1425 { /* Line breaks because we can't put the character at the
1426 previous line any more. It is not the multi-column
1427 character continued in middle. Go back to previous
1428 buffer position, screen position, and set tab offset
1429 to previous value. It's the beginning of the
1432 pos_byte
= prev_pos_byte
;
1434 tab_offset
= prev_tab_offset
;
1438 if (pos
== ZV
) /* We cannot go beyond ZV. Stop here. */
1443 prev_pos_byte
= pos_byte
;
1444 wide_column_end_hpos
= 0;
1446 /* Consult the width run cache to see if we can avoid inspecting
1447 the text character-by-character. */
1448 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
1452 = region_cache_forward (current_buffer
,
1453 current_buffer
->width_run_cache
,
1456 /* A width of zero means the character's width varies (like
1457 a tab), is meaningless (like a newline), or we just don't
1458 want to skip over it for some other reason. */
1459 if (common_width
!= 0)
1463 /* Don't go past the final buffer posn the user
1468 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1470 /* Don't go past the final horizontal position the user
1472 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
1474 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
1475 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1478 /* Don't go past the margin. */
1479 if (run_end_hpos
>= width
)
1481 run_end
= pos
+ (width
- hpos
) / common_width
;
1482 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1485 hpos
= run_end_hpos
;
1487 prev_hpos
= hpos
- common_width
;
1491 pos_byte
= CHAR_TO_BYTE (pos
);
1495 next_width_run
= run_end
+ 1;
1498 /* We have to scan the text character-by-character. */
1502 Lisp_Object charvec
;
1504 c
= FETCH_BYTE (pos_byte
);
1506 /* Check composition sequence. */
1508 int len
, len_byte
, width
;
1510 if (check_composition (pos
, pos_byte
, to
, &len
, &len_byte
, &width
))
1513 pos_byte
+= len_byte
;
1521 /* Perhaps add some info to the width_run_cache. */
1522 if (current_buffer
->width_run_cache
)
1524 /* Is this character part of the current run? If so, extend
1526 if (pos
- 1 == width_run_end
1527 && XFASTINT (width_table
[c
]) == width_run_width
)
1528 width_run_end
= pos
;
1530 /* The previous run is over, since this is a character at a
1531 different position, or a different width. */
1534 /* Have we accumulated a run to put in the cache?
1535 (Currently, we only cache runs of width == 1). */
1536 if (width_run_start
< width_run_end
1537 && width_run_width
== 1)
1538 know_region_cache (current_buffer
,
1539 current_buffer
->width_run_cache
,
1540 width_run_start
, width_run_end
);
1542 /* Start recording a new width run. */
1543 width_run_width
= XFASTINT (width_table
[c
]);
1544 width_run_start
= pos
- 1;
1545 width_run_end
= pos
;
1550 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
1551 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1553 charvec
= DISP_CHAR_VECTOR (dp
, c
);
1554 n
= ASIZE (charvec
);
1562 for (i
= n
- 1; i
>= 0; --i
)
1564 if (VECTORP (charvec
))
1566 /* This should be handled the same as
1567 next_element_from_display_vector does it. */
1568 Lisp_Object entry
= AREF (charvec
, i
);
1570 if (INTEGERP (entry
)
1571 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
1572 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
1577 if (c
>= 040 && c
< 0177)
1581 int tem
= ((hpos
+ tab_offset
+ hscroll
- (hscroll
> 0))
1585 hpos
+= tab_width
- tem
;
1590 && indented_beyond_p (pos
, pos_byte
, selective
))
1592 /* If (pos == to), we don't have to take care of
1593 selective display. */
1596 /* Skip any number of invisible lines all at once */
1599 pos
= find_before_next_newline (pos
, to
, 1);
1602 pos_byte
= CHAR_TO_BYTE (pos
);
1605 && indented_beyond_p (pos
, pos_byte
, selective
));
1606 /* Allow for the " ..." that is displayed for them. */
1609 hpos
+= selective_rlen
;
1613 DEC_BOTH (pos
, pos_byte
);
1614 /* We have skipped the invis text, but not the
1620 /* A visible line. */
1624 /* Count the truncation glyph on column 0 */
1631 else if (c
== CR
&& selective
< 0)
1633 /* In selective display mode,
1634 everything from a ^M to the end of the line is invisible.
1635 Stop *before* the real newline. */
1638 pos
= find_before_next_newline (pos
, to
, 1);
1639 pos_byte
= CHAR_TO_BYTE (pos
);
1641 /* If we just skipped next_boundary,
1642 loop around in the main while
1644 if (pos
> next_boundary
)
1645 next_boundary
= pos
;
1646 /* Allow for the " ..." that is displayed for them. */
1649 hpos
+= selective_rlen
;
1654 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
1656 /* Start of multi-byte form. */
1658 int bytes
, width
, wide_column
;
1660 pos_byte
--; /* rewind POS_BYTE */
1661 ptr
= BYTE_POS_ADDR (pos_byte
);
1662 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
1665 wide_column_end_hpos
= hpos
+ wide_column
;
1668 else if (VECTORP (charvec
))
1671 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
1678 /* Remember any final width run in the cache. */
1679 if (current_buffer
->width_run_cache
1680 && width_run_width
== 1
1681 && width_run_start
< width_run_end
)
1682 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
1683 width_run_start
, width_run_end
);
1685 val_compute_motion
.bufpos
= pos
;
1686 val_compute_motion
.bytepos
= pos_byte
;
1687 val_compute_motion
.hpos
= hpos
;
1688 val_compute_motion
.vpos
= vpos
;
1689 if (contin_hpos
&& prev_hpos
== 0)
1690 val_compute_motion
.prevhpos
= contin_hpos
;
1692 val_compute_motion
.prevhpos
= prev_hpos
;
1693 /* We alalways handle all of them here; none of them remain to do. */
1694 val_compute_motion
.ovstring_chars_done
= 0;
1696 /* Nonzero if have just continued a line */
1697 val_compute_motion
.contin
= (contin_hpos
&& prev_hpos
== 0);
1700 return &val_compute_motion
;
1704 #if 0 /* The doc string is too long for some compilers,
1705 but make-docfile can find it in this comment. */
1706 DEFUN ("compute-motion", Ffoo
, Sfoo
, 7, 7, 0,
1707 "Scan through the current buffer, calculating screen position.\n\
1708 Scan the current buffer forward from offset FROM,\n\
1709 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--\n\
1710 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--\n\
1711 and return the ending buffer position and screen location.\n\
1713 There are three additional arguments:\n\
1715 WIDTH is the number of columns available to display text;\n\
1716 this affects handling of continuation lines.\n\
1717 This is usually the value returned by `window-width', less one (to allow\n\
1718 for the continuation glyph).\n\
1720 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).\n\
1721 HSCROLL is the number of columns not being displayed at the left\n\
1722 margin; this is usually taken from a window's hscroll member.\n\
1723 TAB-OFFSET is the number of columns of the first tab that aren't\n\
1724 being displayed, perhaps because the line was continued within it.\n\
1725 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.\n\
1727 WINDOW is the window to operate on. It is used to choose the display table;\n\
1728 if it is showing the current buffer, it is used also for\n\
1729 deciding which overlay properties apply.\n\
1730 Note that `compute-motion' always operates on the current buffer.\n\
1732 The value is a list of five elements:\n\
1733 (POS HPOS VPOS PREVHPOS CONTIN)\n\
1734 POS is the buffer position where the scan stopped.\n\
1735 VPOS is the vertical position where the scan stopped.\n\
1736 HPOS is the horizontal position where the scan stopped.\n\
1738 PREVHPOS is the horizontal position one character back from POS.\n\
1739 CONTIN is t if a line was continued after (or within) the previous character.\n\
1741 For example, to find the buffer position of column COL of line LINE\n\
1742 of a certain window, pass the window's starting location as FROM\n\
1743 and the window's upper-left coordinates as FROMPOS.\n\
1744 Pass the buffer's (point-max) as TO, to limit the scan to the end of the\n\
1745 visible section of the buffer, and pass LINE and COL as TOPOS.")
1746 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1749 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
1751 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1752 Lisp_Object from
, frompos
, to
, topos
;
1753 Lisp_Object width
, offsets
, window
;
1755 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
;
1756 struct position
*pos
;
1757 int hscroll
, tab_offset
;
1759 CHECK_NUMBER_COERCE_MARKER (from
, 0);
1760 CHECK_CONS (frompos
, 0);
1761 CHECK_NUMBER (XCAR (frompos
), 0);
1762 CHECK_NUMBER (XCDR (frompos
), 0);
1763 CHECK_NUMBER_COERCE_MARKER (to
, 0);
1764 CHECK_CONS (topos
, 0);
1765 CHECK_NUMBER (XCAR (topos
), 0);
1766 CHECK_NUMBER (XCDR (topos
), 0);
1767 CHECK_NUMBER (width
, 0);
1768 if (!NILP (offsets
))
1770 CHECK_CONS (offsets
, 0);
1771 CHECK_NUMBER (XCAR (offsets
), 0);
1772 CHECK_NUMBER (XCDR (offsets
), 0);
1773 hscroll
= XINT (XCAR (offsets
));
1774 tab_offset
= XINT (XCDR (offsets
));
1777 hscroll
= tab_offset
= 0;
1780 window
= Fselected_window ();
1782 CHECK_LIVE_WINDOW (window
, 0);
1784 if (XINT (from
) < BEGV
|| XINT (from
) > ZV
)
1785 args_out_of_range_3 (from
, make_number (BEGV
), make_number (ZV
));
1786 if (XINT (to
) < BEGV
|| XINT (to
) > ZV
)
1787 args_out_of_range_3 (to
, make_number (BEGV
), make_number (ZV
));
1789 pos
= compute_motion (XINT (from
), XINT (XCDR (frompos
)),
1790 XINT (XCAR (frompos
)), 0,
1791 XINT (to
), XINT (XCDR (topos
)),
1792 XINT (XCAR (topos
)),
1793 XINT (width
), hscroll
, tab_offset
,
1796 XSETFASTINT (bufpos
, pos
->bufpos
);
1797 XSETINT (hpos
, pos
->hpos
);
1798 XSETINT (vpos
, pos
->vpos
);
1799 XSETINT (prevhpos
, pos
->prevhpos
);
1801 return Fcons (bufpos
,
1805 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
1809 /* Fvertical_motion and vmotion */
1811 struct position val_vmotion
;
1814 vmotion (from
, vtarget
, w
)
1815 register int from
, vtarget
;
1818 int width
= window_internal_width (w
) - 1;
1819 int hscroll
= XINT (w
->hscroll
);
1820 struct position pos
;
1821 /* vpos is cumulative vertical position, changed as from is changed */
1822 register int vpos
= 0;
1823 Lisp_Object prevline
;
1826 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1828 = (INTEGERP (current_buffer
->selective_display
)
1829 ? XINT (current_buffer
->selective_display
)
1830 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1834 /* This is the object we use for fetching character properties. */
1835 Lisp_Object text_prop_object
;
1837 XSETWINDOW (window
, w
);
1839 /* If the window contains this buffer, use it for getting text properties.
1840 Otherwise use the current buffer as arg for doing that. */
1841 if (EQ (w
->buffer
, Fcurrent_buffer ()))
1842 text_prop_object
= window
;
1844 text_prop_object
= Fcurrent_buffer ();
1846 if (vpos
>= vtarget
)
1848 /* To move upward, go a line at a time until
1849 we have gone at least far enough. */
1853 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1855 Lisp_Object propval
;
1857 XSETFASTINT (prevline
, find_next_newline_no_quit (from
- 1, -1));
1858 while (XFASTINT (prevline
) > BEGV
1860 && indented_beyond_p (XFASTINT (prevline
),
1861 CHAR_TO_BYTE (XFASTINT (prevline
)),
1863 /* watch out for newlines with `invisible' property */
1864 || (propval
= Fget_char_property (prevline
,
1867 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1868 XSETFASTINT (prevline
,
1869 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1871 pos
= *compute_motion (XFASTINT (prevline
), 0,
1872 lmargin
+ (XFASTINT (prevline
) == BEG
1876 /* Don't care for VPOS... */
1877 1 << (BITS_PER_SHORT
- 1),
1879 1 << (BITS_PER_SHORT
- 1),
1881 /* This compensates for start_hpos
1882 so that a tab as first character
1883 still occupies 8 columns. */
1884 (XFASTINT (prevline
) == BEG
1889 from
= XFASTINT (prevline
);
1892 /* If we made exactly the desired vertical distance,
1893 or if we hit beginning of buffer,
1894 return point found */
1895 if (vpos
>= vtarget
)
1897 val_vmotion
.bufpos
= from
;
1898 val_vmotion
.bytepos
= CHAR_TO_BYTE (from
);
1899 val_vmotion
.vpos
= vpos
;
1900 val_vmotion
.hpos
= lmargin
;
1901 val_vmotion
.contin
= 0;
1902 val_vmotion
.prevhpos
= 0;
1903 val_vmotion
.ovstring_chars_done
= 0;
1904 val_vmotion
.tab_offset
= 0; /* For accumulating tab offset. */
1905 return &val_vmotion
;
1908 /* Otherwise find the correct spot by moving down */
1910 /* Moving downward is simple, but must calculate from beg of line
1911 to determine hpos of starting point */
1912 from_byte
= CHAR_TO_BYTE (from
);
1913 if (from
> BEGV
&& FETCH_BYTE (from_byte
- 1) != '\n')
1915 Lisp_Object propval
;
1917 XSETFASTINT (prevline
, find_next_newline_no_quit (from
, -1));
1918 while (XFASTINT (prevline
) > BEGV
1920 && indented_beyond_p (XFASTINT (prevline
),
1921 CHAR_TO_BYTE (XFASTINT (prevline
)),
1923 /* watch out for newlines with `invisible' property */
1924 || (propval
= Fget_char_property (prevline
, Qinvisible
,
1926 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1927 XSETFASTINT (prevline
,
1928 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1930 pos
= *compute_motion (XFASTINT (prevline
), 0,
1931 lmargin
+ (XFASTINT (prevline
) == BEG
1935 /* Don't care for VPOS... */
1936 1 << (BITS_PER_SHORT
- 1),
1938 1 << (BITS_PER_SHORT
- 1),
1940 (XFASTINT (prevline
) == BEG
? -start_hpos
: 0),
1946 pos
.hpos
= lmargin
+ (from
== BEG
? start_hpos
: 0);
1951 return compute_motion (from
, vpos
, pos
.hpos
, did_motion
,
1952 ZV
, vtarget
, - (1 << (BITS_PER_SHORT
- 1)),
1954 pos
.tab_offset
- (from
== BEG
? start_hpos
: 0),
1958 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
1959 "Move point to start of the screen line LINES lines down.\n\
1960 If LINES is negative, this means moving up.\n\
1962 This function is an ordinary cursor motion function\n\
1963 which calculates the new position based on how text would be displayed.\n\
1964 The new position may be the start of a line,\n\
1965 or just the start of a continuation line.\n\
1966 The function returns number of screen lines moved over;\n\
1967 that usually equals LINES, but may be closer to zero\n\
1968 if beginning or end of buffer was reached.\n\
1970 The optional second argument WINDOW specifies the window to use for\n\
1971 parameters such as width, horizontal scrolling, and so on.\n\
1972 The default is to use the selected window's parameters.\n\
1974 `vertical-motion' always uses the current buffer,\n\
1975 regardless of which buffer is displayed in WINDOW.\n\
1976 This is consistent with other cursor motion functions\n\
1977 and makes it possible to use `vertical-motion' in any buffer,\n\
1978 whether or not it is currently displayed in some window.")
1980 Lisp_Object lines
, window
;
1985 Lisp_Object old_buffer
;
1986 struct gcpro gcpro1
;
1988 CHECK_NUMBER (lines
, 0);
1989 if (! NILP (window
))
1990 CHECK_WINDOW (window
, 0);
1992 window
= selected_window
;
1993 w
= XWINDOW (window
);
1996 GCPRO1 (old_buffer
);
1997 if (XBUFFER (w
->buffer
) != current_buffer
)
1999 /* Set the window's buffer temporarily to the current buffer. */
2000 old_buffer
= w
->buffer
;
2001 XSETBUFFER (w
->buffer
, current_buffer
);
2004 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
2005 start_display (&it
, w
, pt
);
2006 move_it_by_lines (&it
, XINT (lines
), 0);
2007 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
2009 if (BUFFERP (old_buffer
))
2010 w
->buffer
= old_buffer
;
2012 RETURN_UNGCPRO (make_number (it
.vpos
));
2017 /* File's initialization. */
2022 DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode
,
2023 "*Indentation can insert tabs if this is non-nil.\n\
2024 Setting this variable automatically makes it local to the current buffer.");
2025 indent_tabs_mode
= 1;
2027 defsubr (&Scurrent_indentation
);
2028 defsubr (&Sindent_to
);
2029 defsubr (&Scurrent_column
);
2030 defsubr (&Smove_to_column
);
2031 defsubr (&Svertical_motion
);
2032 defsubr (&Scompute_motion
);