1 /* Indentation functions.
2 Copyright (C) 1985,86,87,88,93,94,95,98,2000,01,02,03,2004
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 double 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 double current_column_1
P_ ((void));
61 static double 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 prop
= Fget_char_property (position
, Qinvisible
,
271 && EQ (XWINDOW (window
)->buffer
, buffer
))
273 inv_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
274 /* When counting columns (window == nil), don't skip over ellipsis text. */
275 if (NILP (window
) ? inv_p
== 1 : inv_p
)
276 return *next_boundary_p
;
280 /* If a composition starts at POS/POS_BYTE and it doesn't stride over
281 POINT, set *LEN / *LEN_BYTE to the character and byte lengths, *WIDTH
282 to the width, and return 1. Otherwise, return 0. */
285 check_composition (pos
, pos_byte
, point
, len
, len_byte
, width
)
286 int pos
, pos_byte
, point
;
287 int *len
, *len_byte
, *width
;
293 if (! find_composition (pos
, -1, &start
, &end
, &prop
, Qnil
)
294 || pos
!= start
|| point
< end
295 || !COMPOSITION_VALID_P (start
, end
, prop
))
297 if ((id
= get_composition_id (pos
, pos_byte
, end
- pos
, prop
, Qnil
)) < 0)
300 *len
= COMPOSITION_LENGTH (prop
);
301 *len_byte
= CHAR_TO_BYTE (end
) - pos_byte
;
302 *width
= composition_table
[id
]->width
;
306 /* Set variables WIDTH and BYTES for a multibyte sequence starting at P.
308 DP is a display table or NULL.
310 This macro is used in current_column_1, Fmove_to_column, and
313 #define MULTIBYTE_BYTES_WIDTH(p, dp) \
318 c = STRING_CHAR_AND_LENGTH (p, MAX_MULTIBYTE_LENGTH, bytes); \
319 if (BYTES_BY_CHAR_HEAD (*p) != bytes) \
323 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c))) \
324 width = XVECTOR (DISP_CHAR_VECTOR (dp, c))->size; \
326 width = WIDTH_BY_CHAR_HEAD (*p); \
328 wide_column = width; \
333 DEFUN ("current-column", Fcurrent_column
, Scurrent_column
, 0, 0, 0,
334 doc
: /* Return the horizontal position of point. Beginning of line is column 0.
335 This is calculated by adding together the widths of all the displayed
336 representations of the character between the start of the previous line
337 and point. (eg control characters will have a width of 2 or 4, tabs
338 will have a variable width)
339 Ignores finite width of frame, which means that this function may return
340 values greater than (frame-width).
341 Whether the line is visible (if `selective-display' is t) has no effect;
342 however, ^M is treated as end of line when `selective-display' is t. */)
346 XSETFASTINT (temp
, (int) current_column ()); /* iftc */
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 || current_buffer
->overlays_before
378 || 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;
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
;
525 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
527 /* Scan forward to the target position. */
528 while (scan
< opoint
)
532 /* Occasionally we may need to skip invisible text. */
533 while (scan
== next_boundary
)
536 /* This updates NEXT_BOUNDARY to the next place
537 where we might need to skip more invisible text. */
538 scan
= skip_invisible (scan
, &next_boundary
, opoint
, Qnil
);
541 if (scan
!= old_scan
)
542 scan_byte
= CHAR_TO_BYTE (scan
);
545 /* Check composition sequence. */
547 int len
, len_byte
, width
;
549 if (check_composition (scan
, scan_byte
, opoint
,
550 &len
, &len_byte
, &width
))
553 scan_byte
+= len_byte
;
560 c
= FETCH_BYTE (scan_byte
);
563 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
564 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
569 /* This character is displayed using a vector of glyphs.
570 Update the column based on those glyphs. */
572 charvec
= DISP_CHAR_VECTOR (dp
, c
);
575 for (i
= 0; i
< n
; i
++)
577 /* This should be handled the same as
578 next_element_from_display_vector does it. */
580 entry
= AREF (charvec
, i
);
583 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
584 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
590 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
595 col
= col
/ tab_width
* tab_width
;
603 /* The display table says nothing for this character.
604 Display it as itself. */
608 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
613 col
= col
/ tab_width
* tab_width
;
615 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
618 int bytes
, width
, wide_column
;
620 ptr
= BYTE_POS_ADDR (scan_byte
);
621 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
623 /* Subtract one to compensate for the increment
624 that is going to happen below. */
628 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
630 else if (c
< 040 || c
>= 0177)
641 last_known_column
= col
;
642 last_known_column_point
= PT
;
643 last_known_column_modified
= MODIFF
;
649 #if 0 /* Not used. */
651 /* Return the width in columns of the part of STRING from BEG to END.
652 If BEG is nil, that stands for the beginning of STRING.
653 If END is nil, that stands for the end of STRING. */
656 string_display_width (string
, beg
, end
)
657 Lisp_Object string
, beg
, end
;
660 register unsigned char *ptr
, *stop
;
661 register int tab_seen
;
664 register int tab_width
= XINT (current_buffer
->tab_width
);
665 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
666 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
685 /* Make a pointer for decrementing through the chars before point. */
686 ptr
= SDATA (string
) + e
;
687 /* Make a pointer to where consecutive chars leave off,
688 going backwards from point. */
689 stop
= SDATA (string
) + b
;
691 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
693 col
= 0, tab_seen
= 0, post_tab
= 0;
701 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
702 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
703 else if (c
>= 040 && c
< 0177)
710 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
717 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
722 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
732 DEFUN ("indent-to", Findent_to
, Sindent_to
, 1, 2, "NIndent to column: ",
733 doc
: /* Indent from point with tabs and spaces until COLUMN is reached.
734 Optional second argument MININUM says always do at least MININUM spaces
735 even if that goes past COLUMN; by default, MININUM is zero. */)
737 Lisp_Object column
, minimum
;
740 register int fromcol
;
741 register int tab_width
= XINT (current_buffer
->tab_width
);
743 CHECK_NUMBER (column
);
745 XSETFASTINT (minimum
, 0);
746 CHECK_NUMBER (minimum
);
748 fromcol
= current_column ();
749 mincol
= fromcol
+ XINT (minimum
);
750 if (mincol
< XINT (column
)) mincol
= XINT (column
);
752 if (fromcol
== mincol
)
753 return make_number (mincol
);
755 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
757 if (indent_tabs_mode
)
760 XSETFASTINT (n
, mincol
/ tab_width
- fromcol
/ tab_width
);
761 if (XFASTINT (n
) != 0)
763 Finsert_char (make_number ('\t'), n
, Qt
);
765 fromcol
= (mincol
/ tab_width
) * tab_width
;
769 XSETFASTINT (column
, mincol
- fromcol
);
770 Finsert_char (make_number (' '), column
, Qt
);
772 last_known_column
= mincol
;
773 last_known_column_point
= PT
;
774 last_known_column_modified
= MODIFF
;
776 XSETINT (column
, mincol
);
781 static double position_indentation
P_ ((int));
783 DEFUN ("current-indentation", Fcurrent_indentation
, Scurrent_indentation
,
785 doc
: /* Return the indentation of the current line.
786 This is the horizontal position of the character
787 following any initial whitespace. */)
791 int opoint
= PT
, opoint_byte
= PT_BYTE
;
793 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
795 XSETFASTINT (val
, (int) position_indentation (PT_BYTE
)); /* iftc */
796 SET_PT_BOTH (opoint
, opoint_byte
);
801 position_indentation (pos_byte
)
802 register int pos_byte
;
804 register int column
= 0;
805 register int tab_width
= XINT (current_buffer
->tab_width
);
806 register unsigned char *p
;
807 register unsigned char *stop
;
808 unsigned char *start
;
809 int next_boundary_byte
= pos_byte
;
810 int ceiling
= next_boundary_byte
;
812 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
814 p
= BYTE_POS_ADDR (pos_byte
);
815 /* STOP records the value of P at which we will need
816 to think about the gap, or about invisible text,
817 or about the end of the buffer. */
819 /* START records the starting value of P. */
827 /* If we have updated P, set POS_BYTE to match.
828 The first time we enter the loop, POS_BYTE is already right. */
830 pos_byte
= PTR_BYTE_POS (p
);
831 /* Consider the various reasons STOP might have been set here. */
832 if (pos_byte
== ZV_BYTE
)
834 if (pos_byte
== next_boundary_byte
)
837 int pos
= BYTE_TO_CHAR (pos_byte
);
838 pos
= skip_invisible (pos
, &next_boundary
, ZV
, Qnil
);
839 pos_byte
= CHAR_TO_BYTE (pos
);
840 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
842 if (pos_byte
>= ceiling
)
843 ceiling
= BUFFER_CEILING_OF (pos_byte
) + 1;
844 /* Compute the next place we need to stop and think,
845 and set STOP accordingly. */
846 stop_pos_byte
= min (ceiling
, next_boundary_byte
);
847 /* The -1 and +1 arrange to point at the first byte of gap
848 (if STOP_POS_BYTE is the position of the gap)
849 rather than at the data after the gap. */
851 stop
= BYTE_POS_ADDR (stop_pos_byte
- 1) + 1;
852 p
= BYTE_POS_ADDR (pos_byte
);
857 if (! NILP (current_buffer
->enable_multibyte_characters
))
863 column
+= tab_width
- column
% tab_width
;
866 if (ASCII_BYTE_P (p
[-1])
867 || NILP (current_buffer
->enable_multibyte_characters
))
871 pos_byte
= PTR_BYTE_POS (p
- 1);
872 c
= FETCH_MULTIBYTE_CHAR (pos_byte
);
873 if (CHAR_HAS_CATEGORY (c
, ' '))
877 p
= BYTE_POS_ADDR (pos_byte
);
886 /* Test whether the line beginning at POS is indented beyond COLUMN.
887 Blank lines are treated as if they had the same indentation as the
891 indented_beyond_p (pos
, pos_byte
, column
)
896 int opoint
= PT
, opoint_byte
= PT_BYTE
;
898 SET_PT_BOTH (pos
, pos_byte
);
899 while (PT
> BEGV
&& FETCH_BYTE (PT_BYTE
) == '\n')
900 scan_newline (PT
- 1, PT_BYTE
- 1, BEGV
, BEGV_BYTE
, -1, 0);
902 val
= position_indentation (PT_BYTE
);
903 SET_PT_BOTH (opoint
, opoint_byte
);
904 return val
>= column
; /* hmm, float comparison */
907 DEFUN ("move-to-column", Fmove_to_column
, Smove_to_column
, 1, 2, "p",
908 doc
: /* Move point to column COLUMN in the current line.
909 The column of a character is calculated by adding together the widths
910 as displayed of the previous characters in the line.
911 This function ignores line-continuation;
912 there is no upper limit on the column number a character can have
913 and horizontal scrolling has no effect.
915 If specified column is within a character, point goes after that character.
916 If it's past end of line, point goes to end of line.
918 A non-nil second (optional) argument FORCE means,
919 if COLUMN is in the middle of a tab character, change it to spaces.
920 In addition, if FORCE is t, and the line is too short
921 to reach column COLUMN, add spaces/tabs to get there.
923 The return value is the current column. */)
925 Lisp_Object column
, force
;
928 register int col
= current_column ();
931 register int tab_width
= XINT (current_buffer
->tab_width
);
932 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
933 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
934 register int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
939 int next_boundary
, pos_byte
;
941 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
942 CHECK_NATNUM (column
);
943 goal
= XINT (column
);
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
);
972 /* Test reaching the goal column. We do this after skipping
973 invisible characters, so that we put point before the
974 character on which the cursor will appear. */
978 /* Check composition sequence. */
980 int len
, len_byte
, width
;
982 if (check_composition (pos
, pos_byte
, Z
, &len
, &len_byte
, &width
))
985 pos_byte
+= len_byte
;
991 c
= FETCH_BYTE (pos_byte
);
993 /* See if there is a display table and it relates
994 to this character. */
997 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
998 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1000 Lisp_Object charvec
;
1003 /* This character is displayed using a vector of glyphs.
1004 Update the position based on those glyphs. */
1006 charvec
= DISP_CHAR_VECTOR (dp
, c
);
1007 n
= ASIZE (charvec
);
1009 for (i
= 0; i
< n
; i
++)
1011 /* This should be handled the same as
1012 next_element_from_display_vector does it. */
1015 entry
= AREF (charvec
, i
);
1017 if (INTEGERP (entry
)
1018 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
1019 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
1025 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
1031 col
= col
/ tab_width
* tab_width
;
1039 /* The display table doesn't affect this character;
1040 it displays as itself. */
1044 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
1050 col
= col
/ tab_width
* tab_width
;
1052 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
1054 else if (c
< 040 || c
== 0177)
1058 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
1060 /* Start of multi-byte form. */
1062 int bytes
, width
, wide_column
;
1064 ptr
= BYTE_POS_ADDR (pos_byte
);
1065 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
1066 pos_byte
+= bytes
- 1;
1078 SET_PT_BOTH (pos
, pos_byte
);
1080 /* If a tab char made us overshoot, change it to spaces
1081 and scan through it again. */
1082 if (!NILP (force
) && col
> goal
&& c
== '\t' && prev_col
< goal
)
1084 int goal_pt
, goal_pt_byte
;
1086 /* Insert spaces in front of the tab to reach GOAL. Do this
1087 first so that a marker at the end of the tab gets
1089 SET_PT_BOTH (PT
- 1, PT_BYTE
- 1);
1090 Finsert_char (make_number (' '), make_number (goal
- prev_col
), Qt
);
1092 /* Now delete the tab, and indent to COL. */
1093 del_range (PT
, PT
+ 1);
1095 goal_pt_byte
= PT_BYTE
;
1096 Findent_to (make_number (col
), Qnil
);
1097 SET_PT_BOTH (goal_pt
, goal_pt_byte
);
1099 /* Set the last_known... vars consistently. */
1103 /* If line ends prematurely, add space to the end. */
1104 if (col
< goal
&& EQ (force
, Qt
))
1105 Findent_to (make_number (col
= goal
), Qnil
);
1107 last_known_column
= col
;
1108 last_known_column_point
= PT
;
1109 last_known_column_modified
= MODIFF
;
1111 XSETFASTINT (val
, col
);
1115 /* compute_motion: compute buffer posn given screen posn and vice versa */
1117 struct position val_compute_motion
;
1119 /* Scan the current buffer forward from offset FROM, pretending that
1120 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
1121 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
1122 and return the ending buffer position and screen location. If we
1123 can't hit the requested column exactly (because of a tab or other
1124 multi-column character), overshoot.
1126 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
1127 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
1128 earlier call to compute_motion. The other common case is that FROMHPOS
1129 is zero and FROM is a position that "belongs" at column zero, but might
1130 be shifted by overlay strings; in this case DID_MOTION should be 0.
1132 WIDTH is the number of columns available to display text;
1133 compute_motion uses this to handle continuation lines and such.
1134 HSCROLL is the number of columns not being displayed at the left
1135 margin; this is usually taken from a window's hscroll member.
1136 TAB_OFFSET is the number of columns of the first tab that aren't
1137 being displayed, perhaps because of a continuation line or
1140 compute_motion returns a pointer to a struct position. The bufpos
1141 member gives the buffer position at the end of the scan, and hpos
1142 and vpos give its cartesian location. prevhpos is the column at
1143 which the character before bufpos started, and contin is non-zero
1144 if we reached the current line by continuing the previous.
1146 Note that FROMHPOS and TOHPOS should be expressed in real screen
1147 columns, taking HSCROLL and the truncation glyph at the left margin
1148 into account. That is, beginning-of-line moves you to the hpos
1149 -HSCROLL + (HSCROLL > 0).
1151 For example, to find the buffer position of column COL of line LINE
1152 of a certain window, pass the window's starting location as FROM
1153 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
1154 Pass the buffer's ZV as TO, to limit the scan to the end of the
1155 visible section of the buffer, and pass LINE and COL as TOVPOS and
1158 When displaying in window w, a typical formula for WIDTH is:
1161 - (has_vertical_scroll_bars
1162 ? WINDOW_CONFIG_SCROLL_BAR_COLS (window)
1163 : (window_width + window_left != frame_cols))
1166 window_width is XFASTINT (w->total_cols),
1167 window_left is XFASTINT (w->left_col),
1168 has_vertical_scroll_bars is
1169 WINDOW_HAS_VERTICAL_SCROLL_BAR (window)
1170 and frame_cols = FRAME_COLS (XFRAME (window->frame))
1172 Or you can let window_box_text_cols do this all for you, and write:
1173 window_box_text_cols (w) - 1
1175 The `-1' accounts for the continuation-line backslashes; the rest
1176 accounts for window borders if the window is split horizontally, and
1177 the scroll bars if they are turned on. */
1180 compute_motion (from
, fromvpos
, fromhpos
, did_motion
, to
, tovpos
, tohpos
, width
, hscroll
, tab_offset
, win
)
1181 int from
, fromvpos
, fromhpos
, to
, tovpos
, tohpos
;
1184 int hscroll
, tab_offset
;
1187 register int hpos
= fromhpos
;
1188 register int vpos
= fromvpos
;
1193 register int tab_width
= XFASTINT (current_buffer
->tab_width
);
1194 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
1195 register struct Lisp_Char_Table
*dp
= window_display_table (win
);
1197 = (INTEGERP (current_buffer
->selective_display
)
1198 ? XINT (current_buffer
->selective_display
)
1199 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1201 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
1202 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
: 0);
1203 /* The next location where the `invisible' property changes, or an
1204 overlay starts or ends. */
1205 int next_boundary
= from
;
1207 /* For computing runs of characters with similar widths.
1208 Invariant: width_run_width is zero, or all the characters
1209 from width_run_start to width_run_end have a fixed width of
1211 int width_run_start
= from
;
1212 int width_run_end
= from
;
1213 int width_run_width
= 0;
1214 Lisp_Object
*width_table
;
1217 /* The next buffer pos where we should consult the width run cache. */
1218 int next_width_run
= from
;
1221 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
1222 /* If previous char scanned was a wide character,
1223 this is the column where it ended. Otherwise, this is 0. */
1224 int wide_column_end_hpos
= 0;
1225 int prev_pos
; /* Previous buffer position. */
1226 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
;
1278 tab_offset
= prev_tab_offset
;
1283 /* If the caller says that the screen position came from an earlier
1284 call to compute_motion, then we've already accounted for the
1285 overlay strings at point. This is only true the first time
1286 through, so clear the flag after testing it. */
1288 /* We need to skip past the overlay strings. Currently those
1289 strings must not contain TAB;
1290 if we want to relax that restriction, something will have
1291 to be changed here. */
1293 unsigned char *ovstr
;
1294 int ovlen
= overlay_strings (pos
, win
, &ovstr
);
1295 hpos
+= ((multibyte
&& ovlen
> 0)
1296 ? strwidth (ovstr
, ovlen
) : ovlen
);
1303 /* Advance POS past invisible characters
1304 (but not necessarily all that there are here),
1305 and store in next_boundary the next position where
1306 we need to call skip_invisible. */
1307 newpos
= skip_invisible (pos
, &next_boundary
, to
, window
);
1311 pos
= min (to
, newpos
);
1312 pos_byte
= CHAR_TO_BYTE (pos
);
1316 if (newpos
!= pos_here
)
1319 pos_byte
= CHAR_TO_BYTE (pos
);
1323 /* Handle right margin. */
1324 /* Note on a wide-column character.
1326 Characters are classified into the following three categories
1327 according to the width (columns occupied on screen).
1329 (1) single-column character: ex. `a'
1330 (2) multi-column character: ex. `^A', TAB, `\033'
1331 (3) wide-column character: ex. Japanese character, Chinese character
1332 (In the following example, `W_' stands for them.)
1334 Multi-column characters can be divided around the right margin,
1335 but wide-column characters cannot.
1339 (*) The cursor is placed on the next character after the point.
1343 j ^---- next after the point
1344 ^--- next char. after the point.
1346 In case of sigle-column character
1350 033 ^---- next after the point, next char. after the point.
1352 In case of multi-column character
1356 W_ ^---- next after the point
1357 ^---- next char. after the point.
1359 In case of wide-column character
1361 The problem here is continuation at a wide-column character.
1362 In this case, the line may shorter less than WIDTH.
1363 And we find the continuation AFTER it occurs.
1370 || (truncate_partial_width_windows
1371 && width
+ 1 < FRAME_COLS (XFRAME (WINDOW_FRAME (win
))))
1372 || !NILP (current_buffer
->truncate_lines
))
1374 /* Truncating: skip to newline, unless we are already past
1375 TO (we need to go back below). */
1378 pos
= find_before_next_newline (pos
, to
, 1);
1379 pos_byte
= CHAR_TO_BYTE (pos
);
1381 /* If we just skipped next_boundary,
1382 loop around in the main while
1384 if (pos
>= next_boundary
)
1385 next_boundary
= pos
+ 1;
1388 prev_tab_offset
= tab_offset
;
1394 /* Remember the previous value. */
1395 prev_tab_offset
= tab_offset
;
1397 if (wide_column_end_hpos
> width
)
1400 tab_offset
+= prev_hpos
;
1404 tab_offset
+= width
;
1408 contin_hpos
= prev_hpos
;
1414 /* Stop if past the target buffer position or screen position. */
1417 /* Go back to the previous position. */
1419 pos_byte
= prev_pos_byte
;
1422 tab_offset
= prev_tab_offset
;
1424 /* NOTE on contin_hpos, hpos, and prev_hpos.
1428 W_ ^---- contin_hpos
1434 if (contin_hpos
&& prev_hpos
== 0
1435 && contin_hpos
< width
&& !wide_column_end_hpos
)
1437 /* Line breaking occurs in the middle of multi-column
1438 character. Go 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
;
1460 tab_offset
= prev_tab_offset
;
1464 if (pos
== ZV
) /* We cannot go beyond ZV. Stop here. */
1470 prev_pos_byte
= pos_byte
;
1471 wide_column_end_hpos
= 0;
1473 /* Consult the width run cache to see if we can avoid inspecting
1474 the text character-by-character. */
1475 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
1479 = region_cache_forward (current_buffer
,
1480 current_buffer
->width_run_cache
,
1483 /* A width of zero means the character's width varies (like
1484 a tab), is meaningless (like a newline), or we just don't
1485 want to skip over it for some other reason. */
1486 if (common_width
!= 0)
1490 /* Don't go past the final buffer posn the user
1495 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1497 /* Don't go past the final horizontal position the user
1499 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
1501 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
1502 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1505 /* Don't go past the margin. */
1506 if (run_end_hpos
>= width
)
1508 run_end
= pos
+ (width
- hpos
) / common_width
;
1509 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1512 hpos
= run_end_hpos
;
1514 prev_hpos
= hpos
- common_width
;
1518 pos_byte
= CHAR_TO_BYTE (pos
);
1522 next_width_run
= run_end
+ 1;
1525 /* We have to scan the text character-by-character. */
1529 Lisp_Object charvec
;
1531 c
= FETCH_BYTE (pos_byte
);
1533 /* Check composition sequence. */
1535 int len
, len_byte
, width
;
1537 if (check_composition (pos
, pos_byte
, to
, &len
, &len_byte
, &width
))
1540 pos_byte
+= len_byte
;
1548 /* Perhaps add some info to the width_run_cache. */
1549 if (current_buffer
->width_run_cache
)
1551 /* Is this character part of the current run? If so, extend
1553 if (pos
- 1 == width_run_end
1554 && XFASTINT (width_table
[c
]) == width_run_width
)
1555 width_run_end
= pos
;
1557 /* The previous run is over, since this is a character at a
1558 different position, or a different width. */
1561 /* Have we accumulated a run to put in the cache?
1562 (Currently, we only cache runs of width == 1). */
1563 if (width_run_start
< width_run_end
1564 && width_run_width
== 1)
1565 know_region_cache (current_buffer
,
1566 current_buffer
->width_run_cache
,
1567 width_run_start
, width_run_end
);
1569 /* Start recording a new width run. */
1570 width_run_width
= XFASTINT (width_table
[c
]);
1571 width_run_start
= pos
- 1;
1572 width_run_end
= pos
;
1577 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
1578 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1580 charvec
= DISP_CHAR_VECTOR (dp
, c
);
1581 n
= ASIZE (charvec
);
1589 for (i
= n
- 1; i
>= 0; --i
)
1591 if (VECTORP (charvec
))
1593 /* This should be handled the same as
1594 next_element_from_display_vector does it. */
1595 Lisp_Object entry
= AREF (charvec
, i
);
1597 if (INTEGERP (entry
)
1598 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
1599 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
1604 if (c
>= 040 && c
< 0177)
1608 int tem
= ((hpos
+ tab_offset
+ hscroll
- (hscroll
> 0))
1612 hpos
+= tab_width
- tem
;
1617 && indented_beyond_p (pos
, pos_byte
,
1618 (double) selective
)) /* iftc */
1620 /* If (pos == to), we don't have to take care of
1621 selective display. */
1624 /* Skip any number of invisible lines all at once */
1627 pos
= find_before_next_newline (pos
, to
, 1);
1630 pos_byte
= CHAR_TO_BYTE (pos
);
1633 && indented_beyond_p (pos
, pos_byte
,
1634 (double) selective
)); /* iftc */
1635 /* Allow for the " ..." that is displayed for them. */
1638 hpos
+= selective_rlen
;
1642 DEC_BOTH (pos
, pos_byte
);
1643 /* We have skipped the invis text, but not the
1649 /* A visible line. */
1653 /* Count the truncation glyph on column 0 */
1660 else if (c
== CR
&& selective
< 0)
1662 /* In selective display mode,
1663 everything from a ^M to the end of the line is invisible.
1664 Stop *before* the real newline. */
1667 pos
= find_before_next_newline (pos
, to
, 1);
1668 pos_byte
= CHAR_TO_BYTE (pos
);
1670 /* If we just skipped next_boundary,
1671 loop around in the main while
1673 if (pos
> next_boundary
)
1674 next_boundary
= pos
;
1675 /* Allow for the " ..." that is displayed for them. */
1678 hpos
+= selective_rlen
;
1683 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
1685 /* Start of multi-byte form. */
1687 int bytes
, width
, wide_column
;
1689 pos_byte
--; /* rewind POS_BYTE */
1690 ptr
= BYTE_POS_ADDR (pos_byte
);
1691 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
1694 wide_column_end_hpos
= hpos
+ wide_column
;
1697 else if (VECTORP (charvec
))
1700 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
1707 /* Remember any final width run in the cache. */
1708 if (current_buffer
->width_run_cache
1709 && width_run_width
== 1
1710 && width_run_start
< width_run_end
)
1711 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
1712 width_run_start
, width_run_end
);
1714 val_compute_motion
.bufpos
= pos
;
1715 val_compute_motion
.bytepos
= pos_byte
;
1716 val_compute_motion
.hpos
= hpos
;
1717 val_compute_motion
.vpos
= vpos
;
1718 if (contin_hpos
&& prev_hpos
== 0)
1719 val_compute_motion
.prevhpos
= contin_hpos
;
1721 val_compute_motion
.prevhpos
= prev_hpos
;
1722 /* We alalways handle all of them here; none of them remain to do. */
1723 val_compute_motion
.ovstring_chars_done
= 0;
1725 /* Nonzero if have just continued a line */
1726 val_compute_motion
.contin
= (contin_hpos
&& prev_hpos
== 0);
1729 return &val_compute_motion
;
1733 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
1734 doc
: /* Scan through the current buffer, calculating screen position.
1735 Scan the current buffer forward from offset FROM,
1736 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--
1737 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--
1738 and return the ending buffer position and screen location.
1740 There are three additional arguments:
1742 WIDTH is the number of columns available to display text;
1743 this affects handling of continuation lines.
1744 This is usually the value returned by `window-width', less one (to allow
1745 for the continuation glyph).
1747 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).
1748 HSCROLL is the number of columns not being displayed at the left
1749 margin; this is usually taken from a window's hscroll member.
1750 TAB-OFFSET is the number of columns of the first tab that aren't
1751 being displayed, perhaps because the line was continued within it.
1752 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.
1754 WINDOW is the window to operate on. It is used to choose the display table;
1755 if it is showing the current buffer, it is used also for
1756 deciding which overlay properties apply.
1757 Note that `compute-motion' always operates on the current buffer.
1759 The value is a list of five elements:
1760 (POS HPOS VPOS PREVHPOS CONTIN)
1761 POS is the buffer position where the scan stopped.
1762 VPOS is the vertical position where the scan stopped.
1763 HPOS is the horizontal position where the scan stopped.
1765 PREVHPOS is the horizontal position one character back from POS.
1766 CONTIN is t if a line was continued after (or within) the previous character.
1768 For example, to find the buffer position of column COL of line LINE
1769 of a certain window, pass the window's starting location as FROM
1770 and the window's upper-left coordinates as FROMPOS.
1771 Pass the buffer's (point-max) as TO, to limit the scan to the end of the
1772 visible section of the buffer, and pass LINE and COL as TOPOS. */)
1773 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1774 Lisp_Object from
, frompos
, to
, topos
;
1775 Lisp_Object width
, offsets
, window
;
1777 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
;
1778 struct position
*pos
;
1779 int hscroll
, tab_offset
;
1781 CHECK_NUMBER_COERCE_MARKER (from
);
1782 CHECK_CONS (frompos
);
1783 CHECK_NUMBER_CAR (frompos
);
1784 CHECK_NUMBER_CDR (frompos
);
1785 CHECK_NUMBER_COERCE_MARKER (to
);
1787 CHECK_NUMBER_CAR (topos
);
1788 CHECK_NUMBER_CDR (topos
);
1789 CHECK_NUMBER (width
);
1790 if (!NILP (offsets
))
1792 CHECK_CONS (offsets
);
1793 CHECK_NUMBER_CAR (offsets
);
1794 CHECK_NUMBER_CDR (offsets
);
1795 hscroll
= XINT (XCAR (offsets
));
1796 tab_offset
= XINT (XCDR (offsets
));
1799 hscroll
= tab_offset
= 0;
1802 window
= Fselected_window ();
1804 CHECK_LIVE_WINDOW (window
);
1806 if (XINT (from
) < BEGV
|| XINT (from
) > ZV
)
1807 args_out_of_range_3 (from
, make_number (BEGV
), make_number (ZV
));
1808 if (XINT (to
) < BEGV
|| XINT (to
) > ZV
)
1809 args_out_of_range_3 (to
, make_number (BEGV
), make_number (ZV
));
1811 pos
= compute_motion (XINT (from
), XINT (XCDR (frompos
)),
1812 XINT (XCAR (frompos
)), 0,
1813 XINT (to
), XINT (XCDR (topos
)),
1814 XINT (XCAR (topos
)),
1815 XINT (width
), hscroll
, tab_offset
,
1818 XSETFASTINT (bufpos
, pos
->bufpos
);
1819 XSETINT (hpos
, pos
->hpos
);
1820 XSETINT (vpos
, pos
->vpos
);
1821 XSETINT (prevhpos
, pos
->prevhpos
);
1823 return Fcons (bufpos
,
1827 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
1831 /* Fvertical_motion and vmotion */
1833 struct position val_vmotion
;
1836 vmotion (from
, vtarget
, w
)
1837 register int from
, vtarget
;
1840 int width
= window_box_text_cols (w
);
1841 int hscroll
= XINT (w
->hscroll
);
1842 struct position pos
;
1843 /* vpos is cumulative vertical position, changed as from is changed */
1844 register int vpos
= 0;
1845 Lisp_Object prevline
;
1848 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1850 = (INTEGERP (current_buffer
->selective_display
)
1851 ? XINT (current_buffer
->selective_display
)
1852 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1856 /* This is the object we use for fetching character properties. */
1857 Lisp_Object text_prop_object
;
1859 XSETWINDOW (window
, w
);
1861 /* We must make room for continuation marks if we don't have fringes. */
1862 #ifdef HAVE_WINDOW_SYSTEM
1863 if (!FRAME_WINDOW_P (XFRAME (w
->frame
)))
1867 /* If the window contains this buffer, use it for getting text properties.
1868 Otherwise use the current buffer as arg for doing that. */
1869 if (EQ (w
->buffer
, Fcurrent_buffer ()))
1870 text_prop_object
= window
;
1872 text_prop_object
= Fcurrent_buffer ();
1874 if (vpos
>= vtarget
)
1876 /* To move upward, go a line at a time until
1877 we have gone at least far enough. */
1881 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1883 Lisp_Object propval
;
1885 XSETFASTINT (prevline
, find_next_newline_no_quit (from
- 1, -1));
1886 while (XFASTINT (prevline
) > BEGV
1888 && indented_beyond_p (XFASTINT (prevline
),
1889 CHAR_TO_BYTE (XFASTINT (prevline
)),
1890 (double) selective
)) /* iftc */
1891 /* watch out for newlines with `invisible' property */
1892 || (propval
= Fget_char_property (prevline
,
1895 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1896 XSETFASTINT (prevline
,
1897 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1899 pos
= *compute_motion (XFASTINT (prevline
), 0,
1900 lmargin
+ (XFASTINT (prevline
) == BEG
1904 /* Don't care for VPOS... */
1905 1 << (BITS_PER_SHORT
- 1),
1907 1 << (BITS_PER_SHORT
- 1),
1909 /* This compensates for start_hpos
1910 so that a tab as first character
1911 still occupies 8 columns. */
1912 (XFASTINT (prevline
) == BEG
1917 from
= XFASTINT (prevline
);
1920 /* If we made exactly the desired vertical distance,
1921 or if we hit beginning of buffer,
1922 return point found */
1923 if (vpos
>= vtarget
)
1925 val_vmotion
.bufpos
= from
;
1926 val_vmotion
.bytepos
= CHAR_TO_BYTE (from
);
1927 val_vmotion
.vpos
= vpos
;
1928 val_vmotion
.hpos
= lmargin
;
1929 val_vmotion
.contin
= 0;
1930 val_vmotion
.prevhpos
= 0;
1931 val_vmotion
.ovstring_chars_done
= 0;
1932 val_vmotion
.tab_offset
= 0; /* For accumulating tab offset. */
1933 return &val_vmotion
;
1936 /* Otherwise find the correct spot by moving down */
1938 /* Moving downward is simple, but must calculate from beg of line
1939 to determine hpos of starting point */
1940 from_byte
= CHAR_TO_BYTE (from
);
1941 if (from
> BEGV
&& FETCH_BYTE (from_byte
- 1) != '\n')
1943 Lisp_Object propval
;
1945 XSETFASTINT (prevline
, find_next_newline_no_quit (from
, -1));
1946 while (XFASTINT (prevline
) > BEGV
1948 && indented_beyond_p (XFASTINT (prevline
),
1949 CHAR_TO_BYTE (XFASTINT (prevline
)),
1950 (double) selective
)) /* iftc */
1951 /* watch out for newlines with `invisible' property */
1952 || (propval
= Fget_char_property (prevline
, Qinvisible
,
1954 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1955 XSETFASTINT (prevline
,
1956 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1958 pos
= *compute_motion (XFASTINT (prevline
), 0,
1959 lmargin
+ (XFASTINT (prevline
) == BEG
1963 /* Don't care for VPOS... */
1964 1 << (BITS_PER_SHORT
- 1),
1966 1 << (BITS_PER_SHORT
- 1),
1968 (XFASTINT (prevline
) == BEG
? -start_hpos
: 0),
1974 pos
.hpos
= lmargin
+ (from
== BEG
? start_hpos
: 0);
1979 return compute_motion (from
, vpos
, pos
.hpos
, did_motion
,
1980 ZV
, vtarget
, - (1 << (BITS_PER_SHORT
- 1)),
1982 pos
.tab_offset
- (from
== BEG
? start_hpos
: 0),
1986 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
1987 doc
: /* Move point to start of the screen line LINES lines down.
1988 If LINES is negative, this means moving up.
1990 This function is an ordinary cursor motion function
1991 which calculates the new position based on how text would be displayed.
1992 The new position may be the start of a line,
1993 or just the start of a continuation line.
1994 The function returns number of screen lines moved over;
1995 that usually equals LINES, but may be closer to zero
1996 if beginning or end of buffer was reached.
1998 The optional second argument WINDOW specifies the window to use for
1999 parameters such as width, horizontal scrolling, and so on.
2000 The default is to use the selected window's parameters.
2002 `vertical-motion' always uses the current buffer,
2003 regardless of which buffer is displayed in WINDOW.
2004 This is consistent with other cursor motion functions
2005 and makes it possible to use `vertical-motion' in any buffer,
2006 whether or not it is currently displayed in some window. */)
2008 Lisp_Object lines
, window
;
2013 Lisp_Object old_buffer
;
2014 struct gcpro gcpro1
;
2016 CHECK_NUMBER (lines
);
2017 if (! NILP (window
))
2018 CHECK_WINDOW (window
);
2020 window
= selected_window
;
2021 w
= XWINDOW (window
);
2024 GCPRO1 (old_buffer
);
2025 if (XBUFFER (w
->buffer
) != current_buffer
)
2027 /* Set the window's buffer temporarily to the current buffer. */
2028 old_buffer
= w
->buffer
;
2029 XSETBUFFER (w
->buffer
, current_buffer
);
2032 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
2033 start_display (&it
, w
, pt
);
2035 /* Move to the start of the display line containing PT. If we don't
2036 do this, we start moving with IT->current_x == 0, while PT is
2037 really at some x > 0. The effect is, in continuation lines, that
2038 we end up with the iterator placed at where it thinks X is 0,
2039 while the end position is really at some X > 0, the same X that
2041 move_it_by_lines (&it
, 0, 0);
2043 if (XINT (lines
) != 0)
2044 move_it_by_lines (&it
, XINT (lines
), 0);
2046 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
2048 if (BUFFERP (old_buffer
))
2049 w
->buffer
= old_buffer
;
2051 RETURN_UNGCPRO (make_number (it
.vpos
));
2056 /* File's initialization. */
2061 DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode
,
2062 doc
: /* *Indentation can insert tabs if this is non-nil.
2063 Setting this variable automatically makes it local to the current buffer. */);
2064 indent_tabs_mode
= 1;
2066 defsubr (&Scurrent_indentation
);
2067 defsubr (&Sindent_to
);
2068 defsubr (&Scurrent_column
);
2069 defsubr (&Smove_to_column
);
2070 defsubr (&Svertical_motion
);
2071 defsubr (&Scompute_motion
);
2074 /* arch-tag: 9adfea44-71f7-4988-8ee3-96da15c502cc
2075 (do not change this comment) */