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. */
36 #include "intervals.h"
37 #include "region-cache.h"
39 /* Indentation can insert tabs if this is non-zero;
40 otherwise always uses spaces. */
46 /* These three values memorize the current column to avoid recalculation. */
48 /* Last value returned by current_column.
49 Some things in set last_known_column_point to -1
50 to mark the memorized value as invalid. */
52 double last_known_column
;
54 /* Value of point when current_column was called. */
56 int last_known_column_point
;
58 /* Value of MODIFF when current_column was called. */
60 int last_known_column_modified
;
62 static double current_column_1
P_ ((void));
63 static double position_indentation
P_ ((int));
65 /* Cache of beginning of line found by the last call of
68 int current_column_bol_cache
;
70 /* Get the display table to use for the current buffer. */
72 struct Lisp_Char_Table
*
73 buffer_display_table ()
77 thisbuf
= current_buffer
->display_table
;
78 if (DISP_TABLE_P (thisbuf
))
79 return XCHAR_TABLE (thisbuf
);
80 if (DISP_TABLE_P (Vstandard_display_table
))
81 return XCHAR_TABLE (Vstandard_display_table
);
85 /* Width run cache considerations. */
87 /* Return the width of character C under display table DP. */
90 character_width (c
, dp
)
92 struct Lisp_Char_Table
*dp
;
96 /* These width computations were determined by examining the cases
97 in display_text_line. */
99 /* Everything can be handled by the display table, if it's
100 present and the element is right. */
101 if (dp
&& (elt
= DISP_CHAR_VECTOR (dp
, c
), VECTORP (elt
)))
102 return XVECTOR (elt
)->size
;
104 /* Some characters are special. */
105 if (c
== '\n' || c
== '\t' || c
== '\015')
108 /* Printing characters have width 1. */
109 else if (c
>= 040 && c
< 0177)
112 /* Everybody else (control characters, metacharacters) has other
113 widths. We could return their actual widths here, but they
114 depend on things like ctl_arrow and crud like that, and they're
115 not very common at all. So we'll just claim we don't know their
121 /* Return true iff the display table DISPTAB specifies the same widths
122 for characters as WIDTHTAB. We use this to decide when to
123 invalidate the buffer's width_run_cache. */
126 disptab_matches_widthtab (disptab
, widthtab
)
127 struct Lisp_Char_Table
*disptab
;
128 struct Lisp_Vector
*widthtab
;
132 if (widthtab
->size
!= 256)
135 for (i
= 0; i
< 256; i
++)
136 if (character_width (i
, disptab
)
137 != XFASTINT (widthtab
->contents
[i
]))
143 /* Recompute BUF's width table, using the display table DISPTAB. */
146 recompute_width_table (buf
, disptab
)
148 struct Lisp_Char_Table
*disptab
;
151 struct Lisp_Vector
*widthtab
;
153 if (!VECTORP (buf
->width_table
))
154 buf
->width_table
= Fmake_vector (make_number (256), make_number (0));
155 widthtab
= XVECTOR (buf
->width_table
);
156 if (widthtab
->size
!= 256)
159 for (i
= 0; i
< 256; i
++)
160 XSETFASTINT (widthtab
->contents
[i
], character_width (i
, disptab
));
163 /* Allocate or free the width run cache, as requested by the current
164 state of current_buffer's cache_long_line_scans variable. */
167 width_run_cache_on_off ()
169 if (NILP (current_buffer
->cache_long_line_scans
)
170 /* And, for the moment, this feature doesn't work on multibyte
172 || !NILP (current_buffer
->enable_multibyte_characters
))
174 /* It should be off. */
175 if (current_buffer
->width_run_cache
)
177 free_region_cache (current_buffer
->width_run_cache
);
178 current_buffer
->width_run_cache
= 0;
179 current_buffer
->width_table
= Qnil
;
184 /* It should be on. */
185 if (current_buffer
->width_run_cache
== 0)
187 current_buffer
->width_run_cache
= new_region_cache ();
188 recompute_width_table (current_buffer
, buffer_display_table ());
194 /* Skip some invisible characters starting from POS.
195 This includes characters invisible because of text properties
196 and characters invisible because of overlays.
198 If position POS is followed by invisible characters,
199 skip some of them and return the position after them.
200 Otherwise return POS itself.
202 Set *NEXT_BOUNDARY_P to the next position at which
203 it will be necessary to call this function again.
205 Don't scan past TO, and don't set *NEXT_BOUNDARY_P
206 to a value greater than TO.
208 If WINDOW is non-nil, and this buffer is displayed in WINDOW,
209 take account of overlays that apply only in WINDOW.
211 We don't necessarily skip all the invisible characters after POS
212 because that could take a long time. We skip a reasonable number
213 which can be skipped quickly. If there might be more invisible
214 characters immediately following, then *NEXT_BOUNDARY_P
215 will equal the return value. */
218 skip_invisible (pos
, next_boundary_p
, to
, window
)
220 int *next_boundary_p
;
224 Lisp_Object prop
, position
, overlay_limit
, proplimit
;
228 XSETFASTINT (position
, pos
);
229 XSETBUFFER (buffer
, current_buffer
);
231 /* Give faster response for overlay lookup near POS. */
232 recenter_overlay_lists (current_buffer
, pos
);
234 /* We must not advance farther than the next overlay change.
235 The overlay change might change the invisible property;
236 or there might be overlay strings to be displayed there. */
237 overlay_limit
= Fnext_overlay_change (position
);
238 /* As for text properties, this gives a lower bound
239 for where the invisible text property could change. */
240 proplimit
= Fnext_property_change (position
, buffer
, Qt
);
241 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
242 proplimit
= overlay_limit
;
243 /* PROPLIMIT is now a lower bound for the next change
244 in invisible status. If that is plenty far away,
245 use that lower bound. */
246 if (XFASTINT (proplimit
) > pos
+ 100 || XFASTINT (proplimit
) >= to
)
247 *next_boundary_p
= XFASTINT (proplimit
);
248 /* Otherwise, scan for the next `invisible' property change. */
251 /* Don't scan terribly far. */
252 XSETFASTINT (proplimit
, min (pos
+ 100, to
));
253 /* No matter what. don't go past next overlay change. */
254 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
255 proplimit
= overlay_limit
;
256 end
= XFASTINT (Fnext_single_property_change (position
, Qinvisible
,
259 /* Don't put the boundary in the middle of multibyte form if
260 there is no actual property change. */
262 && !NILP (current_buffer
->enable_multibyte_characters
)
264 while (pos
< end
&& !CHAR_HEAD_P (POS_ADDR (end
)))
267 *next_boundary_p
= end
;
269 /* if the `invisible' property is set, we can skip to
270 the next property change */
271 prop
= Fget_char_property (position
, Qinvisible
,
273 && EQ (XWINDOW (window
)->buffer
, buffer
))
275 inv_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
276 /* When counting columns (window == nil), don't skip over ellipsis text. */
277 if (NILP (window
) ? inv_p
== 1 : inv_p
)
278 return *next_boundary_p
;
282 /* If a composition starts at POS/POS_BYTE and it doesn't stride over
283 POINT, set *LEN / *LEN_BYTE to the character and byte lengths, *WIDTH
284 to the width, and return 1. Otherwise, return 0. */
287 check_composition (pos
, pos_byte
, point
, len
, len_byte
, width
)
288 int pos
, pos_byte
, point
;
289 int *len
, *len_byte
, *width
;
295 if (! find_composition (pos
, -1, &start
, &end
, &prop
, Qnil
)
296 || pos
!= start
|| point
< end
297 || !COMPOSITION_VALID_P (start
, end
, prop
))
299 if ((id
= get_composition_id (pos
, pos_byte
, end
- pos
, prop
, Qnil
)) < 0)
302 *len
= COMPOSITION_LENGTH (prop
);
303 *len_byte
= CHAR_TO_BYTE (end
) - pos_byte
;
304 *width
= composition_table
[id
]->width
;
308 /* Set variables WIDTH and BYTES for a multibyte sequence starting at P.
310 DP is a display table or NULL.
312 This macro is used in current_column_1, Fmove_to_column, and
315 #define MULTIBYTE_BYTES_WIDTH(p, dp) \
320 c = STRING_CHAR_AND_LENGTH (p, MAX_MULTIBYTE_LENGTH, bytes); \
321 if (BYTES_BY_CHAR_HEAD (*p) != bytes) \
325 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c))) \
326 width = XVECTOR (DISP_CHAR_VECTOR (dp, c))->size; \
328 width = WIDTH_BY_CHAR_HEAD (*p); \
330 wide_column = width; \
335 DEFUN ("current-column", Fcurrent_column
, Scurrent_column
, 0, 0, 0,
336 doc
: /* Return the horizontal position of point. Beginning of line is column 0.
337 This is calculated by adding together the widths of all the displayed
338 representations of the character between the start of the previous line
339 and point. (eg control characters will have a width of 2 or 4, tabs
340 will have a variable width)
341 Ignores finite width of frame, which means that this function may return
342 values greater than (frame-width).
343 Whether the line is visible (if `selective-display' is t) has no effect;
344 however, ^M is treated as end of line when `selective-display' is t. */)
348 XSETFASTINT (temp
, (int) current_column ()); /* iftc */
352 /* Cancel any recorded value of the horizontal position. */
355 invalidate_current_column ()
357 last_known_column_point
= 0;
364 register unsigned char *ptr
, *stop
;
365 register int tab_seen
;
368 register int tab_width
= XINT (current_buffer
->tab_width
);
369 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
370 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
372 if (PT
== last_known_column_point
373 && MODIFF
== last_known_column_modified
)
374 return last_known_column
;
376 /* If the buffer has overlays, text properties,
377 or multibyte characters, use a more general algorithm. */
378 if (BUF_INTERVALS (current_buffer
)
379 || current_buffer
->overlays_before
380 || current_buffer
->overlays_after
382 return current_column_1 ();
384 /* Scan backwards from point to the previous newline,
385 counting width. Tab characters are the only complicated case. */
387 /* Make a pointer for decrementing through the chars before point. */
388 ptr
= BYTE_POS_ADDR (PT_BYTE
- 1) + 1;
389 /* Make a pointer to where consecutive chars leave off,
390 going backwards from point. */
393 else if (PT
<= GPT
|| BEGV
> GPT
)
398 if (tab_width
<= 0 || tab_width
> 1000)
401 col
= 0, tab_seen
= 0, post_tab
= 0;
410 /* We stopped either for the beginning of the buffer
412 if (ptr
== BEGV_ADDR
)
415 /* It was the gap. Jump back over it. */
419 /* Check whether that brings us to beginning of buffer. */
426 if (dp
&& VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
428 charvec
= DISP_CHAR_VECTOR (dp
, c
);
437 for (i
= n
- 1; i
>= 0; --i
)
439 if (VECTORP (charvec
))
441 /* This should be handled the same as
442 next_element_from_display_vector does it. */
443 Lisp_Object entry
= AREF (charvec
, i
);
446 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
447 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
452 if (c
>= 040 && c
< 0177)
456 && EQ (current_buffer
->selective_display
, Qt
)))
459 goto start_of_line_found
;
464 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
470 else if (VECTORP (charvec
))
471 /* With a display table entry, C is displayed as is, and
472 not displayed as \NNN or as ^N. If C is a single-byte
473 character, it takes one column. If C is multi-byte in
474 an unibyte buffer, it's translated to unibyte, so it
475 also takes one column. */
478 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
486 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
490 if (ptr
== BEGV_ADDR
)
491 current_column_bol_cache
= BEGV
;
493 current_column_bol_cache
= BYTE_TO_CHAR (PTR_BYTE_POS (ptr
));
495 last_known_column
= col
;
496 last_known_column_point
= PT
;
497 last_known_column_modified
= MODIFF
;
502 /* Return the column number of position POS
503 by scanning forward from the beginning of the line.
504 This function handles characters that are invisible
505 due to text properties or overlays. */
510 register int tab_width
= XINT (current_buffer
->tab_width
);
511 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
512 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
513 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
515 /* Start the scan at the beginning of this line with column number 0. */
516 register int col
= 0;
519 int opoint
= PT
, opoint_byte
= PT_BYTE
;
521 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
522 current_column_bol_cache
= PT
;
523 scan
= PT
, scan_byte
= PT_BYTE
;
524 SET_PT_BOTH (opoint
, opoint_byte
);
525 next_boundary
= scan
;
527 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
529 /* Scan forward to the target position. */
530 while (scan
< opoint
)
534 /* Occasionally we may need to skip invisible text. */
535 while (scan
== next_boundary
)
538 /* This updates NEXT_BOUNDARY to the next place
539 where we might need to skip more invisible text. */
540 scan
= skip_invisible (scan
, &next_boundary
, opoint
, Qnil
);
543 if (scan
!= old_scan
)
544 scan_byte
= CHAR_TO_BYTE (scan
);
547 /* Check composition sequence. */
549 int len
, len_byte
, width
;
551 if (check_composition (scan
, scan_byte
, opoint
,
552 &len
, &len_byte
, &width
))
555 scan_byte
+= len_byte
;
562 c
= FETCH_BYTE (scan_byte
);
565 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
566 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
571 /* This character is displayed using a vector of glyphs.
572 Update the column based on those glyphs. */
574 charvec
= DISP_CHAR_VECTOR (dp
, c
);
577 for (i
= 0; i
< n
; i
++)
579 /* This should be handled the same as
580 next_element_from_display_vector does it. */
582 entry
= AREF (charvec
, i
);
585 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
586 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
592 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
597 col
= col
/ tab_width
* tab_width
;
605 /* The display table says nothing for this character.
606 Display it as itself. */
610 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
615 col
= col
/ tab_width
* tab_width
;
617 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
620 int bytes
, width
, wide_column
;
622 ptr
= BYTE_POS_ADDR (scan_byte
);
623 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
625 /* Subtract one to compensate for the increment
626 that is going to happen below. */
630 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
632 else if (c
< 040 || c
>= 0177)
643 last_known_column
= col
;
644 last_known_column_point
= PT
;
645 last_known_column_modified
= MODIFF
;
651 #if 0 /* Not used. */
653 /* Return the width in columns of the part of STRING from BEG to END.
654 If BEG is nil, that stands for the beginning of STRING.
655 If END is nil, that stands for the end of STRING. */
658 string_display_width (string
, beg
, end
)
659 Lisp_Object string
, beg
, end
;
662 register unsigned char *ptr
, *stop
;
663 register int tab_seen
;
666 register int tab_width
= XINT (current_buffer
->tab_width
);
667 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
668 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
687 /* Make a pointer for decrementing through the chars before point. */
688 ptr
= SDATA (string
) + e
;
689 /* Make a pointer to where consecutive chars leave off,
690 going backwards from point. */
691 stop
= SDATA (string
) + b
;
693 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
695 col
= 0, tab_seen
= 0, post_tab
= 0;
703 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
704 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
705 else if (c
>= 040 && c
< 0177)
712 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
719 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
724 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
734 DEFUN ("indent-to", Findent_to
, Sindent_to
, 1, 2, "NIndent to column: ",
735 doc
: /* Indent from point with tabs and spaces until COLUMN is reached.
736 Optional second argument MININUM says always do at least MININUM spaces
737 even if that goes past COLUMN; by default, MININUM is zero. */)
739 Lisp_Object column
, minimum
;
742 register int fromcol
;
743 register int tab_width
= XINT (current_buffer
->tab_width
);
745 CHECK_NUMBER (column
);
747 XSETFASTINT (minimum
, 0);
748 CHECK_NUMBER (minimum
);
750 fromcol
= current_column ();
751 mincol
= fromcol
+ XINT (minimum
);
752 if (mincol
< XINT (column
)) mincol
= XINT (column
);
754 if (fromcol
== mincol
)
755 return make_number (mincol
);
757 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
759 if (indent_tabs_mode
)
762 XSETFASTINT (n
, mincol
/ tab_width
- fromcol
/ tab_width
);
763 if (XFASTINT (n
) != 0)
765 Finsert_char (make_number ('\t'), n
, Qt
);
767 fromcol
= (mincol
/ tab_width
) * tab_width
;
771 XSETFASTINT (column
, mincol
- fromcol
);
772 Finsert_char (make_number (' '), column
, Qt
);
774 last_known_column
= mincol
;
775 last_known_column_point
= PT
;
776 last_known_column_modified
= MODIFF
;
778 XSETINT (column
, mincol
);
783 static double position_indentation
P_ ((int));
785 DEFUN ("current-indentation", Fcurrent_indentation
, Scurrent_indentation
,
787 doc
: /* Return the indentation of the current line.
788 This is the horizontal position of the character
789 following any initial whitespace. */)
793 int opoint
= PT
, opoint_byte
= PT_BYTE
;
795 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
797 XSETFASTINT (val
, (int) position_indentation (PT_BYTE
)); /* iftc */
798 SET_PT_BOTH (opoint
, opoint_byte
);
803 position_indentation (pos_byte
)
804 register int pos_byte
;
806 register int column
= 0;
807 register int tab_width
= XINT (current_buffer
->tab_width
);
808 register unsigned char *p
;
809 register unsigned char *stop
;
810 unsigned char *start
;
811 int next_boundary_byte
= pos_byte
;
812 int ceiling
= next_boundary_byte
;
814 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
816 p
= BYTE_POS_ADDR (pos_byte
);
817 /* STOP records the value of P at which we will need
818 to think about the gap, or about invisible text,
819 or about the end of the buffer. */
821 /* START records the starting value of P. */
829 /* If we have updated P, set POS_BYTE to match.
830 The first time we enter the loop, POS_BYTE is already right. */
832 pos_byte
= PTR_BYTE_POS (p
);
833 /* Consider the various reasons STOP might have been set here. */
834 if (pos_byte
== ZV_BYTE
)
836 if (pos_byte
== next_boundary_byte
)
839 int pos
= BYTE_TO_CHAR (pos_byte
);
840 pos
= skip_invisible (pos
, &next_boundary
, ZV
, Qnil
);
841 pos_byte
= CHAR_TO_BYTE (pos
);
842 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
844 if (pos_byte
>= ceiling
)
845 ceiling
= BUFFER_CEILING_OF (pos_byte
) + 1;
846 /* Compute the next place we need to stop and think,
847 and set STOP accordingly. */
848 stop_pos_byte
= min (ceiling
, next_boundary_byte
);
849 /* The -1 and +1 arrange to point at the first byte of gap
850 (if STOP_POS_BYTE is the position of the gap)
851 rather than at the data after the gap. */
853 stop
= BYTE_POS_ADDR (stop_pos_byte
- 1) + 1;
854 p
= BYTE_POS_ADDR (pos_byte
);
859 if (! NILP (current_buffer
->enable_multibyte_characters
))
865 column
+= tab_width
- column
% tab_width
;
868 if (ASCII_BYTE_P (p
[-1])
869 || NILP (current_buffer
->enable_multibyte_characters
))
873 pos_byte
= PTR_BYTE_POS (p
- 1);
874 c
= FETCH_MULTIBYTE_CHAR (pos_byte
);
875 if (CHAR_HAS_CATEGORY (c
, ' '))
879 p
= BYTE_POS_ADDR (pos_byte
);
888 /* Test whether the line beginning at POS is indented beyond COLUMN.
889 Blank lines are treated as if they had the same indentation as the
893 indented_beyond_p (pos
, pos_byte
, column
)
898 int opoint
= PT
, opoint_byte
= PT_BYTE
;
900 SET_PT_BOTH (pos
, pos_byte
);
901 while (PT
> BEGV
&& FETCH_BYTE (PT_BYTE
) == '\n')
902 scan_newline (PT
- 1, PT_BYTE
- 1, BEGV
, BEGV_BYTE
, -1, 0);
904 val
= position_indentation (PT_BYTE
);
905 SET_PT_BOTH (opoint
, opoint_byte
);
906 return val
>= column
; /* hmm, float comparison */
909 DEFUN ("move-to-column", Fmove_to_column
, Smove_to_column
, 1, 2, "p",
910 doc
: /* Move point to column COLUMN in the current line.
911 The column of a character is calculated by adding together the widths
912 as displayed of the previous characters in the line.
913 This function ignores line-continuation;
914 there is no upper limit on the column number a character can have
915 and horizontal scrolling has no effect.
917 If specified column is within a character, point goes after that character.
918 If it's past end of line, point goes to end of line.
920 A non-nil second (optional) argument FORCE means,
921 if COLUMN is in the middle of a tab character, change it to spaces.
922 In addition, if FORCE is t, and the line is too short
923 to reach column COLUMN, add spaces/tabs to get there.
925 The return value is the current column. */)
927 Lisp_Object column
, force
;
930 register int col
= current_column ();
933 register int tab_width
= XINT (current_buffer
->tab_width
);
934 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
935 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
936 register int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
941 int next_boundary
, pos_byte
;
943 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
944 CHECK_NATNUM (column
);
945 goal
= XINT (column
);
952 /* If we're starting past the desired column,
953 back up to beginning of line and scan from there. */
957 pos
= current_column_bol_cache
;
958 pos_byte
= CHAR_TO_BYTE (pos
);
964 while (pos
== next_boundary
)
967 pos
= skip_invisible (pos
, &next_boundary
, end
, Qnil
);
969 pos_byte
= CHAR_TO_BYTE (pos
);
974 /* Test reaching the goal column. We do this after skipping
975 invisible characters, so that we put point before the
976 character on which the cursor will appear. */
980 /* Check composition sequence. */
982 int len
, len_byte
, width
;
984 if (check_composition (pos
, pos_byte
, Z
, &len
, &len_byte
, &width
))
987 pos_byte
+= len_byte
;
993 c
= FETCH_BYTE (pos_byte
);
995 /* See if there is a display table and it relates
996 to this character. */
999 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
1000 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1002 Lisp_Object charvec
;
1005 /* This character is displayed using a vector of glyphs.
1006 Update the position based on those glyphs. */
1008 charvec
= DISP_CHAR_VECTOR (dp
, c
);
1009 n
= ASIZE (charvec
);
1011 for (i
= 0; i
< n
; i
++)
1013 /* This should be handled the same as
1014 next_element_from_display_vector does it. */
1017 entry
= AREF (charvec
, i
);
1019 if (INTEGERP (entry
)
1020 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
1021 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
1027 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
1033 col
= col
/ tab_width
* tab_width
;
1041 /* The display table doesn't affect this character;
1042 it displays as itself. */
1046 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
1052 col
= col
/ tab_width
* tab_width
;
1054 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
1056 else if (c
< 040 || c
== 0177)
1060 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
1062 /* Start of multi-byte form. */
1064 int bytes
, width
, wide_column
;
1066 ptr
= BYTE_POS_ADDR (pos_byte
);
1067 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
1068 pos_byte
+= bytes
- 1;
1080 SET_PT_BOTH (pos
, pos_byte
);
1082 /* If a tab char made us overshoot, change it to spaces
1083 and scan through it again. */
1084 if (!NILP (force
) && col
> goal
&& c
== '\t' && prev_col
< goal
)
1086 int goal_pt
, goal_pt_byte
;
1088 /* Insert spaces in front of the tab to reach GOAL. Do this
1089 first so that a marker at the end of the tab gets
1091 SET_PT_BOTH (PT
- 1, PT_BYTE
- 1);
1092 Finsert_char (make_number (' '), make_number (goal
- prev_col
), Qt
);
1094 /* Now delete the tab, and indent to COL. */
1095 del_range (PT
, PT
+ 1);
1097 goal_pt_byte
= PT_BYTE
;
1098 Findent_to (make_number (col
), Qnil
);
1099 SET_PT_BOTH (goal_pt
, goal_pt_byte
);
1101 /* Set the last_known... vars consistently. */
1105 /* If line ends prematurely, add space to the end. */
1106 if (col
< goal
&& EQ (force
, Qt
))
1107 Findent_to (make_number (col
= goal
), Qnil
);
1109 last_known_column
= col
;
1110 last_known_column_point
= PT
;
1111 last_known_column_modified
= MODIFF
;
1113 XSETFASTINT (val
, col
);
1117 /* compute_motion: compute buffer posn given screen posn and vice versa */
1119 struct position val_compute_motion
;
1121 /* Scan the current buffer forward from offset FROM, pretending that
1122 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
1123 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
1124 and return the ending buffer position and screen location. If we
1125 can't hit the requested column exactly (because of a tab or other
1126 multi-column character), overshoot.
1128 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
1129 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
1130 earlier call to compute_motion. The other common case is that FROMHPOS
1131 is zero and FROM is a position that "belongs" at column zero, but might
1132 be shifted by overlay strings; in this case DID_MOTION should be 0.
1134 WIDTH is the number of columns available to display text;
1135 compute_motion uses this to handle continuation lines and such.
1136 If WIDTH is -1, use width of window's text area adjusted for
1137 continuation glyph when needed.
1139 HSCROLL is the number of columns not being displayed at the left
1140 margin; this is usually taken from a window's hscroll member.
1141 TAB_OFFSET is the number of columns of the first tab that aren't
1142 being displayed, perhaps because of a continuation line or
1145 compute_motion returns a pointer to a struct position. The bufpos
1146 member gives the buffer position at the end of the scan, and hpos
1147 and vpos give its cartesian location. prevhpos is the column at
1148 which the character before bufpos started, and contin is non-zero
1149 if we reached the current line by continuing the previous.
1151 Note that FROMHPOS and TOHPOS should be expressed in real screen
1152 columns, taking HSCROLL and the truncation glyph at the left margin
1153 into account. That is, beginning-of-line moves you to the hpos
1154 -HSCROLL + (HSCROLL > 0).
1156 For example, to find the buffer position of column COL of line LINE
1157 of a certain window, pass the window's starting location as FROM
1158 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
1159 Pass the buffer's ZV as TO, to limit the scan to the end of the
1160 visible section of the buffer, and pass LINE and COL as TOVPOS and
1163 When displaying in window w, a typical formula for WIDTH is:
1166 - (has_vertical_scroll_bars
1167 ? WINDOW_CONFIG_SCROLL_BAR_COLS (window)
1168 : (window_width + window_left != frame_cols))
1171 window_width is XFASTINT (w->total_cols),
1172 window_left is XFASTINT (w->left_col),
1173 has_vertical_scroll_bars is
1174 WINDOW_HAS_VERTICAL_SCROLL_BAR (window)
1175 and frame_cols = FRAME_COLS (XFRAME (window->frame))
1177 Or you can let window_box_text_cols do this all for you, and write:
1178 window_box_text_cols (w) - 1
1180 The `-1' accounts for the continuation-line backslashes; the rest
1181 accounts for window borders if the window is split horizontally, and
1182 the scroll bars if they are turned on. */
1185 compute_motion (from
, fromvpos
, fromhpos
, did_motion
, to
, tovpos
, tohpos
, width
, hscroll
, tab_offset
, win
)
1186 int from
, fromvpos
, fromhpos
, to
, tovpos
, tohpos
;
1189 int hscroll
, tab_offset
;
1192 register int hpos
= fromhpos
;
1193 register int vpos
= fromvpos
;
1198 register int tab_width
= XFASTINT (current_buffer
->tab_width
);
1199 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
1200 register struct Lisp_Char_Table
*dp
= window_display_table (win
);
1202 = (INTEGERP (current_buffer
->selective_display
)
1203 ? XINT (current_buffer
->selective_display
)
1204 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1206 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
1207 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
: 0);
1208 /* The next location where the `invisible' property changes, or an
1209 overlay starts or ends. */
1210 int next_boundary
= from
;
1212 /* For computing runs of characters with similar widths.
1213 Invariant: width_run_width is zero, or all the characters
1214 from width_run_start to width_run_end have a fixed width of
1216 int width_run_start
= from
;
1217 int width_run_end
= from
;
1218 int width_run_width
= 0;
1219 Lisp_Object
*width_table
;
1222 /* The next buffer pos where we should consult the width run cache. */
1223 int next_width_run
= from
;
1226 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
1227 /* If previous char scanned was a wide character,
1228 this is the column where it ended. Otherwise, this is 0. */
1229 int wide_column_end_hpos
= 0;
1230 int prev_pos
; /* Previous buffer position. */
1231 int prev_pos_byte
; /* Previous buffer position. */
1234 int contin_hpos
; /* HPOS of last column of continued line. */
1235 int prev_tab_offset
; /* Previous tab offset. */
1236 int continuation_glyph_width
;
1238 XSETBUFFER (buffer
, current_buffer
);
1239 XSETWINDOW (window
, win
);
1241 width_run_cache_on_off ();
1242 if (dp
== buffer_display_table ())
1243 width_table
= (VECTORP (current_buffer
->width_table
)
1244 ? XVECTOR (current_buffer
->width_table
)->contents
1247 /* If the window has its own display table, we can't use the width
1248 run cache, because that's based on the buffer's display table. */
1251 if (tab_width
<= 0 || tab_width
> 1000)
1254 /* Negative width means use all available text columns. */
1257 width
= window_box_text_cols (win
);
1258 /* We must make room for continuation marks if we don't have fringes. */
1259 #ifdef HAVE_WINDOW_SYSTEM
1260 if (!FRAME_WINDOW_P (XFRAME (win
->frame
)))
1265 continuation_glyph_width
= 1;
1266 #ifdef HAVE_WINDOW_SYSTEM
1267 if (FRAME_WINDOW_P (XFRAME (win
->frame
)))
1268 continuation_glyph_width
= 0; /* In the fringe. */
1274 pos
= prev_pos
= from
;
1275 pos_byte
= prev_pos_byte
= CHAR_TO_BYTE (from
);
1277 prev_tab_offset
= tab_offset
;
1280 while (pos
== next_boundary
)
1285 /* Don't skip invisible if we are already at the margin. */
1286 if (vpos
> tovpos
|| (vpos
== tovpos
&& hpos
>= tohpos
))
1288 if (contin_hpos
&& prev_hpos
== 0
1290 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1291 { /* Line breaks because we can't put the character at the
1292 previous line any more. It is not the multi-column
1293 character continued in middle. Go back to previous
1294 buffer position, screen position, and set tab offset
1295 to previous value. It's the beginning of the
1298 pos_byte
= prev_pos_byte
;
1301 tab_offset
= prev_tab_offset
;
1306 /* If the caller says that the screen position came from an earlier
1307 call to compute_motion, then we've already accounted for the
1308 overlay strings at point. This is only true the first time
1309 through, so clear the flag after testing it. */
1311 /* We need to skip past the overlay strings. Currently those
1312 strings must not contain TAB;
1313 if we want to relax that restriction, something will have
1314 to be changed here. */
1316 unsigned char *ovstr
;
1317 int ovlen
= overlay_strings (pos
, win
, &ovstr
);
1318 hpos
+= ((multibyte
&& ovlen
> 0)
1319 ? strwidth (ovstr
, ovlen
) : ovlen
);
1326 /* Advance POS past invisible characters
1327 (but not necessarily all that there are here),
1328 and store in next_boundary the next position where
1329 we need to call skip_invisible. */
1330 newpos
= skip_invisible (pos
, &next_boundary
, to
, window
);
1334 pos
= min (to
, newpos
);
1335 pos_byte
= CHAR_TO_BYTE (pos
);
1339 if (newpos
!= pos_here
)
1342 pos_byte
= CHAR_TO_BYTE (pos
);
1346 /* Handle right margin. */
1347 /* Note on a wide-column character.
1349 Characters are classified into the following three categories
1350 according to the width (columns occupied on screen).
1352 (1) single-column character: ex. `a'
1353 (2) multi-column character: ex. `^A', TAB, `\033'
1354 (3) wide-column character: ex. Japanese character, Chinese character
1355 (In the following example, `W_' stands for them.)
1357 Multi-column characters can be divided around the right margin,
1358 but wide-column characters cannot.
1362 (*) The cursor is placed on the next character after the point.
1366 j ^---- next after the point
1367 ^--- next char. after the point.
1369 In case of sigle-column character
1373 033 ^---- next after the point, next char. after the point.
1375 In case of multi-column character
1379 W_ ^---- next after the point
1380 ^---- next char. after the point.
1382 In case of wide-column character
1384 The problem here is continuation at a wide-column character.
1385 In this case, the line may shorter less than WIDTH.
1386 And we find the continuation AFTER it occurs.
1393 || (truncate_partial_width_windows
1394 && ((width
+ continuation_glyph_width
)
1395 < FRAME_COLS (XFRAME (WINDOW_FRAME (win
)))))
1396 || !NILP (current_buffer
->truncate_lines
))
1398 /* Truncating: skip to newline, unless we are already past
1399 TO (we need to go back below). */
1402 pos
= find_before_next_newline (pos
, to
, 1);
1403 pos_byte
= CHAR_TO_BYTE (pos
);
1405 /* If we just skipped next_boundary,
1406 loop around in the main while
1408 if (pos
>= next_boundary
)
1409 next_boundary
= pos
+ 1;
1412 prev_tab_offset
= tab_offset
;
1418 /* Remember the previous value. */
1419 prev_tab_offset
= tab_offset
;
1421 if (wide_column_end_hpos
> width
)
1424 tab_offset
+= prev_hpos
;
1428 tab_offset
+= width
;
1432 contin_hpos
= prev_hpos
;
1438 /* Stop if past the target buffer position or screen position. */
1441 /* Go back to the previous position. */
1443 pos_byte
= prev_pos_byte
;
1446 tab_offset
= prev_tab_offset
;
1448 /* NOTE on contin_hpos, hpos, and prev_hpos.
1452 W_ ^---- contin_hpos
1458 if (contin_hpos
&& prev_hpos
== 0
1459 && contin_hpos
< width
&& !wide_column_end_hpos
)
1461 /* Line breaking occurs in the middle of multi-column
1462 character. Go back to previous line. */
1469 if (vpos
> tovpos
|| (vpos
== tovpos
&& hpos
>= tohpos
))
1471 if (contin_hpos
&& prev_hpos
== 0
1473 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1474 { /* Line breaks because we can't put the character at the
1475 previous line any more. It is not the multi-column
1476 character continued in middle. Go back to previous
1477 buffer position, screen position, and set tab offset
1478 to previous value. It's the beginning of the
1481 pos_byte
= prev_pos_byte
;
1484 tab_offset
= prev_tab_offset
;
1488 if (pos
== ZV
) /* We cannot go beyond ZV. Stop here. */
1494 prev_pos_byte
= pos_byte
;
1495 wide_column_end_hpos
= 0;
1497 /* Consult the width run cache to see if we can avoid inspecting
1498 the text character-by-character. */
1499 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
1503 = region_cache_forward (current_buffer
,
1504 current_buffer
->width_run_cache
,
1507 /* A width of zero means the character's width varies (like
1508 a tab), is meaningless (like a newline), or we just don't
1509 want to skip over it for some other reason. */
1510 if (common_width
!= 0)
1514 /* Don't go past the final buffer posn the user
1519 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1521 /* Don't go past the final horizontal position the user
1523 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
1525 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
1526 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1529 /* Don't go past the margin. */
1530 if (run_end_hpos
>= width
)
1532 run_end
= pos
+ (width
- hpos
) / common_width
;
1533 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1536 hpos
= run_end_hpos
;
1538 prev_hpos
= hpos
- common_width
;
1542 pos_byte
= CHAR_TO_BYTE (pos
);
1546 next_width_run
= run_end
+ 1;
1549 /* We have to scan the text character-by-character. */
1553 Lisp_Object charvec
;
1555 c
= FETCH_BYTE (pos_byte
);
1557 /* Check composition sequence. */
1559 int len
, len_byte
, width
;
1561 if (check_composition (pos
, pos_byte
, to
, &len
, &len_byte
, &width
))
1564 pos_byte
+= len_byte
;
1572 /* Perhaps add some info to the width_run_cache. */
1573 if (current_buffer
->width_run_cache
)
1575 /* Is this character part of the current run? If so, extend
1577 if (pos
- 1 == width_run_end
1578 && XFASTINT (width_table
[c
]) == width_run_width
)
1579 width_run_end
= pos
;
1581 /* The previous run is over, since this is a character at a
1582 different position, or a different width. */
1585 /* Have we accumulated a run to put in the cache?
1586 (Currently, we only cache runs of width == 1). */
1587 if (width_run_start
< width_run_end
1588 && width_run_width
== 1)
1589 know_region_cache (current_buffer
,
1590 current_buffer
->width_run_cache
,
1591 width_run_start
, width_run_end
);
1593 /* Start recording a new width run. */
1594 width_run_width
= XFASTINT (width_table
[c
]);
1595 width_run_start
= pos
- 1;
1596 width_run_end
= pos
;
1601 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
1602 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1604 charvec
= DISP_CHAR_VECTOR (dp
, c
);
1605 n
= ASIZE (charvec
);
1613 for (i
= n
- 1; i
>= 0; --i
)
1615 if (VECTORP (charvec
))
1617 /* This should be handled the same as
1618 next_element_from_display_vector does it. */
1619 Lisp_Object entry
= AREF (charvec
, i
);
1621 if (INTEGERP (entry
)
1622 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
1623 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
1628 if (c
>= 040 && c
< 0177)
1632 int tem
= ((hpos
+ tab_offset
+ hscroll
- (hscroll
> 0))
1636 hpos
+= tab_width
- tem
;
1641 && indented_beyond_p (pos
, pos_byte
,
1642 (double) selective
)) /* iftc */
1644 /* If (pos == to), we don't have to take care of
1645 selective display. */
1648 /* Skip any number of invisible lines all at once */
1651 pos
= find_before_next_newline (pos
, to
, 1);
1654 pos_byte
= CHAR_TO_BYTE (pos
);
1657 && indented_beyond_p (pos
, pos_byte
,
1658 (double) selective
)); /* iftc */
1659 /* Allow for the " ..." that is displayed for them. */
1662 hpos
+= selective_rlen
;
1666 DEC_BOTH (pos
, pos_byte
);
1667 /* We have skipped the invis text, but not the
1673 /* A visible line. */
1677 /* Count the truncation glyph on column 0 */
1679 hpos
+= continuation_glyph_width
;
1684 else if (c
== CR
&& selective
< 0)
1686 /* In selective display mode,
1687 everything from a ^M to the end of the line is invisible.
1688 Stop *before* the real newline. */
1691 pos
= find_before_next_newline (pos
, to
, 1);
1692 pos_byte
= CHAR_TO_BYTE (pos
);
1694 /* If we just skipped next_boundary,
1695 loop around in the main while
1697 if (pos
> next_boundary
)
1698 next_boundary
= pos
;
1699 /* Allow for the " ..." that is displayed for them. */
1702 hpos
+= selective_rlen
;
1707 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
1709 /* Start of multi-byte form. */
1711 int bytes
, width
, wide_column
;
1713 pos_byte
--; /* rewind POS_BYTE */
1714 ptr
= BYTE_POS_ADDR (pos_byte
);
1715 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
1718 wide_column_end_hpos
= hpos
+ wide_column
;
1721 else if (VECTORP (charvec
))
1724 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
1731 /* Remember any final width run in the cache. */
1732 if (current_buffer
->width_run_cache
1733 && width_run_width
== 1
1734 && width_run_start
< width_run_end
)
1735 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
1736 width_run_start
, width_run_end
);
1738 val_compute_motion
.bufpos
= pos
;
1739 val_compute_motion
.bytepos
= pos_byte
;
1740 val_compute_motion
.hpos
= hpos
;
1741 val_compute_motion
.vpos
= vpos
;
1742 if (contin_hpos
&& prev_hpos
== 0)
1743 val_compute_motion
.prevhpos
= contin_hpos
;
1745 val_compute_motion
.prevhpos
= prev_hpos
;
1746 /* We alalways handle all of them here; none of them remain to do. */
1747 val_compute_motion
.ovstring_chars_done
= 0;
1749 /* Nonzero if have just continued a line */
1750 val_compute_motion
.contin
= (contin_hpos
&& prev_hpos
== 0);
1753 return &val_compute_motion
;
1757 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
1758 doc
: /* Scan through the current buffer, calculating screen position.
1759 Scan the current buffer forward from offset FROM,
1760 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--
1761 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--
1762 and return the ending buffer position and screen location.
1764 If TOPOS is nil, the actual width and height of the window's
1767 There are three additional arguments:
1769 WIDTH is the number of columns available to display text;
1770 this affects handling of continuation lines. A value of nil
1771 corresponds to the actual number of available text columns.
1773 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).
1774 HSCROLL is the number of columns not being displayed at the left
1775 margin; this is usually taken from a window's hscroll member.
1776 TAB-OFFSET is the number of columns of the first tab that aren't
1777 being displayed, perhaps because the line was continued within it.
1778 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.
1780 WINDOW is the window to operate on. It is used to choose the display table;
1781 if it is showing the current buffer, it is used also for
1782 deciding which overlay properties apply.
1783 Note that `compute-motion' always operates on the current buffer.
1785 The value is a list of five elements:
1786 (POS HPOS VPOS PREVHPOS CONTIN)
1787 POS is the buffer position where the scan stopped.
1788 VPOS is the vertical position where the scan stopped.
1789 HPOS is the horizontal position where the scan stopped.
1791 PREVHPOS is the horizontal position one character back from POS.
1792 CONTIN is t if a line was continued after (or within) the previous character.
1794 For example, to find the buffer position of column COL of line LINE
1795 of a certain window, pass the window's starting location as FROM
1796 and the window's upper-left coordinates as FROMPOS.
1797 Pass the buffer's (point-max) as TO, to limit the scan to the end of the
1798 visible section of the buffer, and pass LINE and COL as TOPOS. */)
1799 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1800 Lisp_Object from
, frompos
, to
, topos
;
1801 Lisp_Object width
, offsets
, window
;
1804 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
;
1805 struct position
*pos
;
1806 int hscroll
, tab_offset
;
1808 CHECK_NUMBER_COERCE_MARKER (from
);
1809 CHECK_CONS (frompos
);
1810 CHECK_NUMBER_CAR (frompos
);
1811 CHECK_NUMBER_CDR (frompos
);
1812 CHECK_NUMBER_COERCE_MARKER (to
);
1816 CHECK_NUMBER_CAR (topos
);
1817 CHECK_NUMBER_CDR (topos
);
1820 CHECK_NUMBER (width
);
1822 if (!NILP (offsets
))
1824 CHECK_CONS (offsets
);
1825 CHECK_NUMBER_CAR (offsets
);
1826 CHECK_NUMBER_CDR (offsets
);
1827 hscroll
= XINT (XCAR (offsets
));
1828 tab_offset
= XINT (XCDR (offsets
));
1831 hscroll
= tab_offset
= 0;
1834 window
= Fselected_window ();
1836 CHECK_LIVE_WINDOW (window
);
1837 w
= XWINDOW (window
);
1839 if (XINT (from
) < BEGV
|| XINT (from
) > ZV
)
1840 args_out_of_range_3 (from
, make_number (BEGV
), make_number (ZV
));
1841 if (XINT (to
) < BEGV
|| XINT (to
) > ZV
)
1842 args_out_of_range_3 (to
, make_number (BEGV
), make_number (ZV
));
1844 pos
= compute_motion (XINT (from
), XINT (XCDR (frompos
)),
1845 XINT (XCAR (frompos
)), 0,
1848 ? window_internal_height (w
)
1849 : XINT (XCDR (topos
))),
1851 ? (window_box_text_cols (w
)
1853 #ifdef HAVE_WINDOW_SYSTEM
1854 FRAME_WINDOW_P (XFRAME (w
->frame
)) ? 0 :
1857 : XINT (XCAR (topos
))),
1858 (NILP (width
) ? -1 : XINT (width
)),
1859 hscroll
, tab_offset
,
1862 XSETFASTINT (bufpos
, pos
->bufpos
);
1863 XSETINT (hpos
, pos
->hpos
);
1864 XSETINT (vpos
, pos
->vpos
);
1865 XSETINT (prevhpos
, pos
->prevhpos
);
1867 return Fcons (bufpos
,
1871 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
1875 /* Fvertical_motion and vmotion */
1877 struct position val_vmotion
;
1880 vmotion (from
, vtarget
, w
)
1881 register int from
, vtarget
;
1884 int hscroll
= XINT (w
->hscroll
);
1885 struct position pos
;
1886 /* vpos is cumulative vertical position, changed as from is changed */
1887 register int vpos
= 0;
1888 Lisp_Object prevline
;
1891 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1893 = (INTEGERP (current_buffer
->selective_display
)
1894 ? XINT (current_buffer
->selective_display
)
1895 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1899 /* This is the object we use for fetching character properties. */
1900 Lisp_Object text_prop_object
;
1902 XSETWINDOW (window
, w
);
1904 /* If the window contains this buffer, use it for getting text properties.
1905 Otherwise use the current buffer as arg for doing that. */
1906 if (EQ (w
->buffer
, Fcurrent_buffer ()))
1907 text_prop_object
= window
;
1909 text_prop_object
= Fcurrent_buffer ();
1911 if (vpos
>= vtarget
)
1913 /* To move upward, go a line at a time until
1914 we have gone at least far enough. */
1918 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1920 Lisp_Object propval
;
1922 XSETFASTINT (prevline
, find_next_newline_no_quit (from
- 1, -1));
1923 while (XFASTINT (prevline
) > BEGV
1925 && indented_beyond_p (XFASTINT (prevline
),
1926 CHAR_TO_BYTE (XFASTINT (prevline
)),
1927 (double) selective
)) /* iftc */
1928 /* watch out for newlines with `invisible' property */
1929 || (propval
= Fget_char_property (prevline
,
1932 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1933 XSETFASTINT (prevline
,
1934 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1936 pos
= *compute_motion (XFASTINT (prevline
), 0,
1937 lmargin
+ (XFASTINT (prevline
) == BEG
1941 /* Don't care for VPOS... */
1942 1 << (BITS_PER_SHORT
- 1),
1944 1 << (BITS_PER_SHORT
- 1),
1946 /* This compensates for start_hpos
1947 so that a tab as first character
1948 still occupies 8 columns. */
1949 (XFASTINT (prevline
) == BEG
1954 from
= XFASTINT (prevline
);
1957 /* If we made exactly the desired vertical distance,
1958 or if we hit beginning of buffer,
1959 return point found */
1960 if (vpos
>= vtarget
)
1962 val_vmotion
.bufpos
= from
;
1963 val_vmotion
.bytepos
= CHAR_TO_BYTE (from
);
1964 val_vmotion
.vpos
= vpos
;
1965 val_vmotion
.hpos
= lmargin
;
1966 val_vmotion
.contin
= 0;
1967 val_vmotion
.prevhpos
= 0;
1968 val_vmotion
.ovstring_chars_done
= 0;
1969 val_vmotion
.tab_offset
= 0; /* For accumulating tab offset. */
1970 return &val_vmotion
;
1973 /* Otherwise find the correct spot by moving down */
1975 /* Moving downward is simple, but must calculate from beg of line
1976 to determine hpos of starting point */
1977 from_byte
= CHAR_TO_BYTE (from
);
1978 if (from
> BEGV
&& FETCH_BYTE (from_byte
- 1) != '\n')
1980 Lisp_Object propval
;
1982 XSETFASTINT (prevline
, find_next_newline_no_quit (from
, -1));
1983 while (XFASTINT (prevline
) > BEGV
1985 && indented_beyond_p (XFASTINT (prevline
),
1986 CHAR_TO_BYTE (XFASTINT (prevline
)),
1987 (double) selective
)) /* iftc */
1988 /* watch out for newlines with `invisible' property */
1989 || (propval
= Fget_char_property (prevline
, Qinvisible
,
1991 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1992 XSETFASTINT (prevline
,
1993 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1995 pos
= *compute_motion (XFASTINT (prevline
), 0,
1996 lmargin
+ (XFASTINT (prevline
) == BEG
2000 /* Don't care for VPOS... */
2001 1 << (BITS_PER_SHORT
- 1),
2003 1 << (BITS_PER_SHORT
- 1),
2005 (XFASTINT (prevline
) == BEG
? -start_hpos
: 0),
2011 pos
.hpos
= lmargin
+ (from
== BEG
? start_hpos
: 0);
2016 return compute_motion (from
, vpos
, pos
.hpos
, did_motion
,
2017 ZV
, vtarget
, - (1 << (BITS_PER_SHORT
- 1)),
2019 pos
.tab_offset
- (from
== BEG
? start_hpos
: 0),
2023 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
2024 doc
: /* Move point to start of the screen line LINES lines down.
2025 If LINES is negative, this means moving up.
2027 This function is an ordinary cursor motion function
2028 which calculates the new position based on how text would be displayed.
2029 The new position may be the start of a line,
2030 or just the start of a continuation line.
2031 The function returns number of screen lines moved over;
2032 that usually equals LINES, but may be closer to zero
2033 if beginning or end of buffer was reached.
2035 The optional second argument WINDOW specifies the window to use for
2036 parameters such as width, horizontal scrolling, and so on.
2037 The default is to use the selected window's parameters.
2039 `vertical-motion' always uses the current buffer,
2040 regardless of which buffer is displayed in WINDOW.
2041 This is consistent with other cursor motion functions
2042 and makes it possible to use `vertical-motion' in any buffer,
2043 whether or not it is currently displayed in some window. */)
2045 Lisp_Object lines
, window
;
2050 Lisp_Object old_buffer
;
2051 struct gcpro gcpro1
;
2053 CHECK_NUMBER (lines
);
2054 if (! NILP (window
))
2055 CHECK_WINDOW (window
);
2057 window
= selected_window
;
2058 w
= XWINDOW (window
);
2061 GCPRO1 (old_buffer
);
2062 if (XBUFFER (w
->buffer
) != current_buffer
)
2064 /* Set the window's buffer temporarily to the current buffer. */
2065 old_buffer
= w
->buffer
;
2066 XSETBUFFER (w
->buffer
, current_buffer
);
2069 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
2070 start_display (&it
, w
, pt
);
2072 /* Move to the start of the display line containing PT. If we don't
2073 do this, we start moving with IT->current_x == 0, while PT is
2074 really at some x > 0. The effect is, in continuation lines, that
2075 we end up with the iterator placed at where it thinks X is 0,
2076 while the end position is really at some X > 0, the same X that
2078 move_it_by_lines (&it
, 0, 0);
2080 if (XINT (lines
) != 0)
2081 move_it_by_lines (&it
, XINT (lines
), 0);
2083 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
2085 if (BUFFERP (old_buffer
))
2086 w
->buffer
= old_buffer
;
2088 RETURN_UNGCPRO (make_number (it
.vpos
));
2093 /* File's initialization. */
2098 DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode
,
2099 doc
: /* *Indentation can insert tabs if this is non-nil.
2100 Setting this variable automatically makes it local to the current buffer. */);
2101 indent_tabs_mode
= 1;
2103 defsubr (&Scurrent_indentation
);
2104 defsubr (&Sindent_to
);
2105 defsubr (&Scurrent_column
);
2106 defsubr (&Smove_to_column
);
2107 defsubr (&Svertical_motion
);
2108 defsubr (&Scompute_motion
);
2111 /* arch-tag: 9adfea44-71f7-4988-8ee3-96da15c502cc
2112 (do not change this comment) */