1 /* Indentation functions.
2 Copyright (C) 1985,86,87,88,93,94,95,98 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
33 #include "intervals.h"
34 #include "region-cache.h"
36 /* Indentation can insert tabs if this is non-zero;
37 otherwise always uses spaces */
40 #define min(a, b) ((a) < (b) ? (a) : (b))
41 #define max(a, b) ((a) > (b) ? (a) : (b))
45 /* These three values memoize the current column to avoid recalculation */
46 /* Some things in set last_known_column_point to -1
47 to mark the memoized value as invalid */
48 /* Last value returned by current_column */
49 int last_known_column
;
50 /* Value of point when current_column was called */
51 int last_known_column_point
;
52 /* Value of MODIFF when current_column was called */
53 int last_known_column_modified
;
55 static int current_column_1 ();
56 static int position_indentation ();
58 /* Cache of beginning of line found by the last call of
60 int current_column_bol_cache
;
62 /* Get the display table to use for the current buffer. */
64 struct Lisp_Char_Table
*
65 buffer_display_table ()
69 thisbuf
= current_buffer
->display_table
;
70 if (DISP_TABLE_P (thisbuf
))
71 return XCHAR_TABLE (thisbuf
);
72 if (DISP_TABLE_P (Vstandard_display_table
))
73 return XCHAR_TABLE (Vstandard_display_table
);
77 /* Width run cache considerations. */
79 /* Return the width of character C under display table DP. */
82 character_width (c
, dp
)
84 struct Lisp_Char_Table
*dp
;
88 /* These width computations were determined by examining the cases
89 in display_text_line. */
91 /* Everything can be handled by the display table, if it's
92 present and the element is right. */
93 if (dp
&& (elt
= DISP_CHAR_VECTOR (dp
, c
), VECTORP (elt
)))
94 return XVECTOR (elt
)->size
;
96 /* Some characters are special. */
97 if (c
== '\n' || c
== '\t' || c
== '\015')
100 /* Printing characters have width 1. */
101 else if (c
>= 040 && c
< 0177)
104 /* Everybody else (control characters, metacharacters) has other
105 widths. We could return their actual widths here, but they
106 depend on things like ctl_arrow and crud like that, and they're
107 not very common at all. So we'll just claim we don't know their
113 /* Return true iff the display table DISPTAB specifies the same widths
114 for characters as WIDTHTAB. We use this to decide when to
115 invalidate the buffer's width_run_cache. */
117 disptab_matches_widthtab (disptab
, widthtab
)
118 struct Lisp_Char_Table
*disptab
;
119 struct Lisp_Vector
*widthtab
;
123 if (widthtab
->size
!= 256)
126 for (i
= 0; i
< 256; i
++)
127 if (character_width (i
, disptab
)
128 != XFASTINT (widthtab
->contents
[i
]))
134 /* Recompute BUF's width table, using the display table DISPTAB. */
136 recompute_width_table (buf
, disptab
)
138 struct Lisp_Char_Table
*disptab
;
141 struct Lisp_Vector
*widthtab
;
143 if (!VECTORP (buf
->width_table
))
144 buf
->width_table
= Fmake_vector (make_number (256), make_number (0));
145 widthtab
= XVECTOR (buf
->width_table
);
146 if (widthtab
->size
!= 256)
149 for (i
= 0; i
< 256; i
++)
150 XSETFASTINT (widthtab
->contents
[i
], character_width (i
, disptab
));
153 /* Allocate or free the width run cache, as requested by the current
154 state of current_buffer's cache_long_line_scans variable. */
156 width_run_cache_on_off ()
158 if (NILP (current_buffer
->cache_long_line_scans
)
159 /* And, for the moment, this feature doesn't work on multibyte
161 || !NILP (current_buffer
->enable_multibyte_characters
))
163 /* It should be off. */
164 if (current_buffer
->width_run_cache
)
166 free_region_cache (current_buffer
->width_run_cache
);
167 current_buffer
->width_run_cache
= 0;
168 current_buffer
->width_table
= Qnil
;
173 /* It should be on. */
174 if (current_buffer
->width_run_cache
== 0)
176 current_buffer
->width_run_cache
= new_region_cache ();
177 recompute_width_table (current_buffer
, buffer_display_table ());
183 /* Skip some invisible characters starting from POS.
184 This includes characters invisible because of text properties
185 and characters invisible because of overlays.
187 If position POS is followed by invisible characters,
188 skip some of them and return the position after them.
189 Otherwise return POS itself.
191 Set *NEXT_BOUNDARY_P to the next position at which
192 it will be necessary to call this function again.
194 Don't scan past TO, and don't set *NEXT_BOUNDARY_P
195 to a value greater than TO.
197 If WINDOW is non-nil, and this buffer is displayed in WINDOW,
198 take account of overlays that apply only in WINDOW.
200 We don't necessarily skip all the invisible characters after POS
201 because that could take a long time. We skip a reasonable number
202 which can be skipped quickly. If there might be more invisible
203 characters immediately following, then *NEXT_BOUNDARY_P
204 will equal the return value. */
207 skip_invisible (pos
, next_boundary_p
, to
, window
)
209 int *next_boundary_p
;
213 Lisp_Object prop
, position
, overlay_limit
, proplimit
;
217 XSETFASTINT (position
, pos
);
218 XSETBUFFER (buffer
, current_buffer
);
220 /* Give faster response for overlay lookup near POS. */
221 recenter_overlay_lists (current_buffer
, pos
);
223 /* We must not advance farther than the next overlay change.
224 The overlay change might change the invisible property;
225 or there might be overlay strings to be displayed there. */
226 overlay_limit
= Fnext_overlay_change (position
);
227 /* As for text properties, this gives a lower bound
228 for where the invisible text property could change. */
229 proplimit
= Fnext_property_change (position
, buffer
, Qt
);
230 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
231 proplimit
= overlay_limit
;
232 /* PROPLIMIT is now a lower bound for the next change
233 in invisible status. If that is plenty far away,
234 use that lower bound. */
235 if (XFASTINT (proplimit
) > pos
+ 100 || XFASTINT (proplimit
) >= to
)
236 *next_boundary_p
= XFASTINT (proplimit
);
237 /* Otherwise, scan for the next `invisible' property change. */
240 /* Don't scan terribly far. */
241 XSETFASTINT (proplimit
, min (pos
+ 100, to
));
242 /* No matter what. don't go past next overlay change. */
243 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
244 proplimit
= overlay_limit
;
245 end
= XFASTINT (Fnext_single_property_change (position
, Qinvisible
,
248 /* Don't put the boundary in the middle of multibyte form if
249 there is no actual property change. */
251 && !NILP (current_buffer
->enable_multibyte_characters
)
253 while (pos
< end
&& !CHAR_HEAD_P (POS_ADDR (end
)))
256 *next_boundary_p
= end
;
258 /* if the `invisible' property is set, we can skip to
259 the next property change */
260 if (!NILP (window
) && EQ (XWINDOW (window
)->buffer
, buffer
))
261 prop
= Fget_char_property (position
, Qinvisible
, window
);
263 prop
= Fget_char_property (position
, Qinvisible
, buffer
);
264 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
265 return *next_boundary_p
;
269 /* Set variables WIDTH and BYTES for a multibyte sequence starting at P.
271 DP is a display table or NULL.
273 This macro is used in current_column_1, Fmove_to_column, and
276 #define MULTIBYTE_BYTES_WIDTH(p, dp) \
281 c = STRING_CHAR_AND_LENGTH (p, MAX_LENGTH_OF_MULTI_BYTE_FORM, bytes); \
282 if (BYTES_BY_CHAR_HEAD (*p) != bytes) \
286 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c))) \
287 width = XVECTOR (DISP_CHAR_VECTOR (dp, c))->size; \
289 width = WIDTH_BY_CHAR_HEAD (*p); \
291 wide_column = width; \
295 DEFUN ("current-column", Fcurrent_column
, Scurrent_column
, 0, 0, 0,
296 "Return the horizontal position of point. Beginning of line is column 0.\n\
297 This is calculated by adding together the widths of all the displayed\n\
298 representations of the character between the start of the previous line\n\
299 and point. (eg control characters will have a width of 2 or 4, tabs\n\
300 will have a variable width)\n\
301 Ignores finite width of frame, which means that this function may return\n\
302 values greater than (frame-width).\n\
303 Whether the line is visible (if `selective-display' is t) has no effect;\n\
304 however, ^M is treated as end of line when `selective-display' is t.")
308 XSETFASTINT (temp
, current_column ());
312 /* Cancel any recorded value of the horizontal position. */
315 invalidate_current_column ()
317 last_known_column_point
= 0;
324 register unsigned char *ptr
, *stop
;
325 register int tab_seen
;
328 register int tab_width
= XINT (current_buffer
->tab_width
);
329 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
330 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
333 if (PT
== last_known_column_point
334 && MODIFF
== last_known_column_modified
)
335 return last_known_column
;
337 /* If the buffer has overlays, text properties,
338 or multibyte characters, use a more general algorithm. */
339 if (BUF_INTERVALS (current_buffer
)
340 || !NILP (current_buffer
->overlays_before
)
341 || !NILP (current_buffer
->overlays_after
)
343 return current_column_1 ();
345 /* Scan backwards from point to the previous newline,
346 counting width. Tab characters are the only complicated case. */
348 /* Make a pointer for decrementing through the chars before point. */
349 ptr
= BYTE_POS_ADDR (PT_BYTE
- 1) + 1;
350 /* Make a pointer to where consecutive chars leave off,
351 going backwards from point. */
354 else if (PT
<= GPT
|| BEGV
> GPT
)
359 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
361 col
= 0, tab_seen
= 0, post_tab
= 0;
367 /* We stopped either for the beginning of the buffer
369 if (ptr
== BEGV_ADDR
)
371 /* It was the gap. Jump back over it. */
374 /* Check whether that brings us to beginning of buffer. */
375 if (BEGV
>= GPT
) break;
379 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
380 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
381 else if (c
>= 040 && c
< 0177)
384 || (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
)))
392 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
399 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
404 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
408 if (ptr
== BEGV_ADDR
)
409 current_column_bol_cache
= BEGV
;
411 current_column_bol_cache
= BYTE_TO_CHAR (PTR_BYTE_POS (ptr
));
413 last_known_column
= col
;
414 last_known_column_point
= PT
;
415 last_known_column_modified
= MODIFF
;
420 /* Return the column number of position POS
421 by scanning forward from the beginning of the line.
422 This function handles characters that are invisible
423 due to text properties or overlays. */
428 register int tab_width
= XINT (current_buffer
->tab_width
);
429 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
430 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
431 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
433 /* Start the scan at the beginning of this line with column number 0. */
434 register int col
= 0;
436 int next_boundary
, next_boundary_byte
;
437 int opoint
= PT
, opoint_byte
= PT_BYTE
;
439 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
440 current_column_bol_cache
= PT
;
441 scan
= PT
, scan_byte
= PT_BYTE
;
442 SET_PT_BOTH (opoint
, opoint_byte
);
443 next_boundary
= scan
;
444 next_boundary_byte
= scan_byte
;
446 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
448 /* Scan forward to the target position. */
449 while (scan
< opoint
)
453 /* Occasionally we may need to skip invisible text. */
454 while (scan
== next_boundary
)
457 /* This updates NEXT_BOUNDARY to the next place
458 where we might need to skip more invisible text. */
459 scan
= skip_invisible (scan
, &next_boundary
, opoint
, Qnil
);
462 if (scan
!= old_scan
)
463 scan_byte
= CHAR_TO_BYTE (scan
);
464 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
467 c
= FETCH_BYTE (scan_byte
);
469 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
470 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
472 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
479 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
487 col
= col
/ tab_width
* tab_width
;
489 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
492 int bytes
, width
, wide_column
;
495 ptr
= BYTE_POS_ADDR (scan_byte
);
496 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
500 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
502 else if (c
< 040 || c
>= 0177)
509 last_known_column
= col
;
510 last_known_column_point
= PT
;
511 last_known_column_modified
= MODIFF
;
516 /* Return the width in columns of the part of STRING from BEG to END.
517 If BEG is nil, that stands for the beginning of STRING.
518 If END is nil, that stands for the end of STRING. */
521 string_display_width (string
, beg
, end
)
522 Lisp_Object string
, beg
, end
;
525 register unsigned char *ptr
, *stop
;
526 register int tab_seen
;
529 register int tab_width
= XINT (current_buffer
->tab_width
);
530 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
531 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
535 e
= XSTRING (string
)->size
;
538 CHECK_NUMBER (end
, 0);
546 CHECK_NUMBER (beg
, 0);
550 /* Make a pointer for decrementing through the chars before point. */
551 ptr
= XSTRING (string
)->data
+ e
;
552 /* Make a pointer to where consecutive chars leave off,
553 going backwards from point. */
554 stop
= XSTRING (string
)->data
+ b
;
556 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
558 col
= 0, tab_seen
= 0, post_tab
= 0;
566 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
567 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
568 else if (c
>= 040 && c
< 0177)
575 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
582 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
587 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
594 DEFUN ("indent-to", Findent_to
, Sindent_to
, 1, 2, "NIndent to column: ",
595 "Indent from point with tabs and spaces until COLUMN is reached.\n\
596 Optional second argument MININUM says always do at least MININUM spaces\n\
597 even if that goes past COLUMN; by default, MININUM is zero.")
599 Lisp_Object column
, minimum
;
602 register int fromcol
;
603 register int tab_width
= XINT (current_buffer
->tab_width
);
605 CHECK_NUMBER (column
, 0);
607 XSETFASTINT (minimum
, 0);
608 CHECK_NUMBER (minimum
, 1);
610 fromcol
= current_column ();
611 mincol
= fromcol
+ XINT (minimum
);
612 if (mincol
< XINT (column
)) mincol
= XINT (column
);
614 if (fromcol
== mincol
)
615 return make_number (mincol
);
617 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
619 if (indent_tabs_mode
)
622 XSETFASTINT (n
, mincol
/ tab_width
- fromcol
/ tab_width
);
623 if (XFASTINT (n
) != 0)
625 Finsert_char (make_number ('\t'), n
, Qt
);
627 fromcol
= (mincol
/ tab_width
) * tab_width
;
631 XSETFASTINT (column
, mincol
- fromcol
);
632 Finsert_char (make_number (' '), column
, Qt
);
634 last_known_column
= mincol
;
635 last_known_column_point
= PT
;
636 last_known_column_modified
= MODIFF
;
638 XSETINT (column
, mincol
);
643 static int position_indentation
P_ ((int));
645 DEFUN ("current-indentation", Fcurrent_indentation
, Scurrent_indentation
,
647 "Return the indentation of the current line.\n\
648 This is the horizontal position of the character\n\
649 following any initial whitespace.")
653 int opoint
= PT
, opoint_byte
= PT_BYTE
;
655 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
657 XSETFASTINT (val
, position_indentation (PT_BYTE
));
658 SET_PT_BOTH (opoint
, opoint_byte
);
663 position_indentation (pos_byte
)
664 register int pos_byte
;
666 register int column
= 0;
667 register int tab_width
= XINT (current_buffer
->tab_width
);
668 register unsigned char *p
;
669 register unsigned char *stop
;
670 unsigned char *start
;
671 int next_boundary_byte
= pos_byte
;
672 int ceiling
= next_boundary_byte
;
674 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
676 p
= BYTE_POS_ADDR (pos_byte
);
677 /* STOP records the value of P at which we will need
678 to think about the gap, or about invisible text,
679 or about the end of the buffer. */
681 /* START records the starting value of P. */
689 /* If we have updated P, set POS_BYTE to match.
690 The first time we enter the loop, POS_BYTE is already right. */
692 pos_byte
= PTR_BYTE_POS (p
);
693 /* Consider the various reasons STOP might have been set here. */
694 if (pos_byte
== ZV_BYTE
)
696 if (pos_byte
== next_boundary_byte
)
699 int pos
= BYTE_TO_CHAR (pos_byte
);
700 pos
= skip_invisible (pos
, &next_boundary
, ZV
, Qnil
);
701 pos_byte
= CHAR_TO_BYTE (pos
);
702 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
704 if (pos_byte
>= ceiling
)
705 ceiling
= BUFFER_CEILING_OF (pos_byte
) + 1;
706 /* Compute the next place we need to stop and think,
707 and set STOP accordingly. */
708 stop_pos_byte
= min (ceiling
, next_boundary_byte
);
709 /* The -1 and +1 arrange to point at the first byte of gap
710 (if STOP_POS_BYTE is the position of the gap)
711 rather than at the data after the gap. */
713 stop
= BYTE_POS_ADDR (stop_pos_byte
- 1) + 1;
714 p
= BYTE_POS_ADDR (pos_byte
);
719 if (! NILP (current_buffer
->enable_multibyte_characters
))
725 column
+= tab_width
- column
% tab_width
;
728 if (ASCII_BYTE_P (p
[-1])
729 || NILP (current_buffer
->enable_multibyte_characters
))
733 pos_byte
= PTR_BYTE_POS (p
- 1);
734 c
= FETCH_MULTIBYTE_CHAR (pos_byte
);
735 if (CHAR_HAS_CATEGORY (c
, ' '))
739 p
= BYTE_POS_ADDR (pos_byte
);
748 /* Test whether the line beginning at POS is indented beyond COLUMN.
749 Blank lines are treated as if they had the same indentation as the
753 indented_beyond_p (pos
, pos_byte
, column
)
754 int pos
, pos_byte
, column
;
757 int opoint
= PT
, opoint_byte
= PT_BYTE
;
759 SET_PT_BOTH (pos
, pos_byte
);
760 while (PT
> BEGV
&& FETCH_BYTE (PT_BYTE
) == '\n')
761 scan_newline (PT
- 1, PT_BYTE
- 1, BEGV
, BEGV_BYTE
, -1, 0);
763 val
= position_indentation (PT_BYTE
);
764 SET_PT_BOTH (opoint
, opoint_byte
);
765 return val
>= column
;
768 DEFUN ("move-to-column", Fmove_to_column
, Smove_to_column
, 1, 2, "p",
769 "Move point to column COLUMN in the current line.\n\
770 The column of a character is calculated by adding together the widths\n\
771 as displayed of the previous characters in the line.\n\
772 This function ignores line-continuation;\n\
773 there is no upper limit on the column number a character can have\n\
774 and horizontal scrolling has no effect.\n\
776 If specified column is within a character, point goes after that character.\n\
777 If it's past end of line, point goes to end of line.\n\n\
778 A non-nil second (optional) argument FORCE means,\n\
779 if COLUMN is in the middle of a tab character, change it to spaces.\n\
780 In addition, if FORCE is t, and the line is too short\n\
781 to reach column COLUMN, add spaces/tabs to get there.\n\
783 The return value is the current column.")
785 Lisp_Object column
, force
;
788 register int col
= current_column ();
791 register int tab_width
= XINT (current_buffer
->tab_width
);
792 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
793 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
794 register int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
801 int pos_byte
, end_byte
, next_boundary_byte
;
803 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
804 CHECK_NATNUM (column
, 0);
805 goal
= XINT (column
);
812 next_boundary_byte
= PT_BYTE
;
814 /* If we're starting past the desired column,
815 back up to beginning of line and scan from there. */
819 pos
= current_column_bol_cache
;
820 pos_byte
= CHAR_TO_BYTE (pos
);
826 while (pos
== next_boundary
)
829 pos
= skip_invisible (pos
, &next_boundary
, end
, Qnil
);
831 pos_byte
= CHAR_TO_BYTE (pos
);
832 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
837 /* Test reaching the goal column. We do this after skipping
838 invisible characters, so that we put point before the
839 character on which the cursor will appear. */
843 c
= FETCH_BYTE (pos_byte
);
845 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
846 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
848 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
855 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
863 col
= col
/ tab_width
* tab_width
;
865 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
867 else if (c
< 040 || c
== 0177)
871 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
873 /* Start of multi-byte form. */
875 int bytes
, width
, wide_column
;
878 ptr
= BYTE_POS_ADDR (pos_byte
);
879 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
888 SET_PT_BOTH (pos
, pos_byte
);
890 /* If a tab char made us overshoot, change it to spaces
891 and scan through it again. */
892 if (!NILP (force
) && col
> goal
&& c
== '\t' && prev_col
< goal
)
894 int old_point
, old_point_byte
;
896 del_range (PT
- 1, PT
);
897 Findent_to (make_number (goal
), Qnil
);
899 old_point_byte
= PT_BYTE
;
900 Findent_to (make_number (col
), Qnil
);
901 SET_PT_BOTH (old_point
, old_point_byte
);
902 /* Set the last_known... vars consistently. */
906 /* If line ends prematurely, add space to the end. */
907 if (col
< goal
&& EQ (force
, Qt
))
908 Findent_to (make_number (col
= goal
), Qnil
);
910 last_known_column
= col
;
911 last_known_column_point
= PT
;
912 last_known_column_modified
= MODIFF
;
914 XSETFASTINT (val
, col
);
918 /* compute_motion: compute buffer posn given screen posn and vice versa */
920 struct position val_compute_motion
;
922 /* Scan the current buffer forward from offset FROM, pretending that
923 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
924 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
925 and return the ending buffer position and screen location. If we
926 can't hit the requested column exactly (because of a tab or other
927 multi-column character), overshoot.
929 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
930 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
931 earlier call to compute_motion. The other common case is that FROMHPOS
932 is zero and FROM is a position that "belongs" at column zero, but might
933 be shifted by overlay strings; in this case DID_MOTION should be 0.
935 WIDTH is the number of columns available to display text;
936 compute_motion uses this to handle continuation lines and such.
937 HSCROLL is the number of columns not being displayed at the left
938 margin; this is usually taken from a window's hscroll member.
939 TAB_OFFSET is the number of columns of the first tab that aren't
940 being displayed, perhaps because of a continuation line or
943 compute_motion returns a pointer to a struct position. The bufpos
944 member gives the buffer position at the end of the scan, and hpos
945 and vpos give its cartesian location. prevhpos is the column at
946 which the character before bufpos started, and contin is non-zero
947 if we reached the current line by continuing the previous.
949 Note that FROMHPOS and TOHPOS should be expressed in real screen
950 columns, taking HSCROLL and the truncation glyph at the left margin
951 into account. That is, beginning-of-line moves you to the hpos
952 -HSCROLL + (HSCROLL > 0).
954 For example, to find the buffer position of column COL of line LINE
955 of a certain window, pass the window's starting location as FROM
956 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
957 Pass the buffer's ZV as TO, to limit the scan to the end of the
958 visible section of the buffer, and pass LINE and COL as TOVPOS and
961 When displaying in window w, a typical formula for WIDTH is:
964 - (has_vertical_scroll_bars
965 ? FRAME_SCROLL_BAR_COLS (XFRAME (window->frame))
966 : (window_width + window_left != frame_width))
969 window_width is XFASTINT (w->width),
970 window_left is XFASTINT (w->left),
971 has_vertical_scroll_bars is
972 FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (WINDOW_FRAME (window)))
973 and frame_width = FRAME_WIDTH (XFRAME (window->frame))
975 Or you can let window_internal_width do this all for you, and write:
976 window_internal_width (w) - 1
978 The `-1' accounts for the continuation-line backslashes; the rest
979 accounts for window borders if the window is split horizontally, and
980 the scroll bars if they are turned on. */
983 compute_motion (from
, fromvpos
, fromhpos
, did_motion
, to
, tovpos
, tohpos
, width
, hscroll
, tab_offset
, win
)
984 int from
, fromvpos
, fromhpos
, to
, tovpos
, tohpos
;
987 int hscroll
, tab_offset
;
990 register int hpos
= fromhpos
;
991 register int vpos
= fromvpos
;
996 register int tab_width
= XFASTINT (current_buffer
->tab_width
);
997 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
998 register struct Lisp_Char_Table
*dp
= window_display_table (win
);
1000 = (INTEGERP (current_buffer
->selective_display
)
1001 ? XINT (current_buffer
->selective_display
)
1002 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1005 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
1006 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
: 0);
1007 /* The next location where the `invisible' property changes, or an
1008 overlay starts or ends. */
1009 int next_boundary
= from
;
1011 /* For computing runs of characters with similar widths.
1012 Invariant: width_run_width is zero, or all the characters
1013 from width_run_start to width_run_end have a fixed width of
1015 int width_run_start
= from
;
1016 int width_run_end
= from
;
1017 int width_run_width
= 0;
1018 Lisp_Object
*width_table
;
1021 /* The next buffer pos where we should consult the width run cache. */
1022 int next_width_run
= from
;
1025 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
1026 /* If previous char scanned was a wide character,
1027 this is the column where it ended. Otherwise, this is 0. */
1028 int wide_column_end_hpos
= 0;
1029 int prev_pos
; /* Previous buffer position. */
1030 int prev_pos_byte
; /* Previous buffer position. */
1031 int contin_hpos
; /* HPOS of last column of continued line. */
1032 int prev_tab_offset
; /* Previous tab offset. */
1034 XSETBUFFER (buffer
, current_buffer
);
1035 XSETWINDOW (window
, win
);
1037 width_run_cache_on_off ();
1038 if (dp
== buffer_display_table ())
1039 width_table
= (VECTORP (current_buffer
->width_table
)
1040 ? XVECTOR (current_buffer
->width_table
)->contents
1043 /* If the window has its own display table, we can't use the width
1044 run cache, because that's based on the buffer's display table. */
1047 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
1049 pos
= prev_pos
= from
;
1050 pos_byte
= prev_pos_byte
= CHAR_TO_BYTE (from
);
1052 prev_tab_offset
= tab_offset
;
1055 while (pos
== next_boundary
)
1060 /* Don't skip invisible if we are already at the margin. */
1061 if (vpos
> tovpos
|| vpos
== tovpos
&& hpos
>= tohpos
)
1063 if (contin_hpos
&& prev_hpos
== 0
1065 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1066 { /* Line breaks because we can't put the character at the
1067 previous line any more. It is not the multi-column
1068 character continued in middle. Go back to previous
1069 buffer position, screen position, and set tab offset
1070 to previous value. It's the beginning of the
1073 pos_byte
= prev_pos_byte
;
1075 tab_offset
= prev_tab_offset
;
1080 /* If the caller says that the screen position came from an earlier
1081 call to compute_motion, then we've already accounted for the
1082 overlay strings at point. This is only true the first time
1083 through, so clear the flag after testing it. */
1085 /* We need to skip past the overlay strings. Currently those
1086 strings must not contain TAB;
1087 if we want to relax that restriction, something will have
1088 to be changed here. */
1090 unsigned char *ovstr
;
1091 int ovlen
= overlay_strings (pos
, win
, &ovstr
);
1092 hpos
+= ((multibyte
&& ovlen
> 0)
1093 ? strwidth (ovstr
, ovlen
) : ovlen
);
1100 /* Advance POS past invisible characters
1101 (but not necessarily all that there are here),
1102 and store in next_boundary the next position where
1103 we need to call skip_invisible. */
1104 newpos
= skip_invisible (pos
, &next_boundary
, to
, window
);
1108 pos
= min (to
, newpos
);
1112 if (newpos
!= pos_here
)
1115 pos_byte
= CHAR_TO_BYTE (pos
);
1119 /* Handle right margin. */
1120 /* Note on a wide-column character.
1122 Characters are classified into the following three categories
1123 according to the width (columns occupied on screen).
1125 (1) single-column character: ex. `a'
1126 (2) multi-column character: ex. `^A', TAB, `\033'
1127 (3) wide-column character: ex. Japanese character, Chinese character
1128 (In the following example, `W_' stands for them.)
1130 Multi-column characters can be divided around the right margin,
1131 but wide-column characters cannot.
1135 (*) The cursor is placed on the next character after the point.
1139 j ^---- next after the point
1140 ^--- next char. after the point.
1142 In case of sigle-column character
1146 033 ^---- next after the point, next char. after the point.
1148 In case of multi-column character
1152 W_ ^---- next after the point
1153 ^---- next char. after the point.
1155 In case of wide-column character
1157 The problem here is continuation at a wide-column character.
1158 In this case, the line may shorter less than WIDTH.
1159 And we find the continuation AFTER it occurs.
1166 || (truncate_partial_width_windows
1167 && width
+ 1 < FRAME_WIDTH (XFRAME (WINDOW_FRAME (win
))))
1168 || !NILP (current_buffer
->truncate_lines
))
1170 /* Truncating: skip to newline, unless we are already past
1171 TO (we need to go back below). */
1174 pos
= find_before_next_newline (pos
, to
, 1);
1175 pos_byte
= CHAR_TO_BYTE (pos
);
1177 /* If we just skipped next_boundary,
1178 loop around in the main while
1180 if (pos
>= next_boundary
)
1181 next_boundary
= pos
+ 1;
1183 prev_tab_offset
= tab_offset
;
1189 /* Remember the previous value. */
1190 prev_tab_offset
= tab_offset
;
1192 if (wide_column_end_hpos
> width
)
1195 tab_offset
+= prev_hpos
;
1199 tab_offset
+= width
;
1203 contin_hpos
= prev_hpos
;
1208 /* Stop if past the target buffer position or screen position. */
1211 /* Go back to the previous position. */
1213 pos_byte
= prev_pos_byte
;
1215 tab_offset
= prev_tab_offset
;
1217 /* NOTE on contin_hpos, hpos, and prev_hpos.
1221 W_ ^---- contin_hpos
1227 if (contin_hpos
&& prev_hpos
== 0
1228 && contin_hpos
< width
&& !wide_column_end_hpos
)
1230 /* Line breaking occurs in the middle of multi-column
1231 character. Go back to previous line. */
1236 /* If previous character is NEWLINE,
1237 set VPOS back to previous line */
1242 if (vpos
> tovpos
|| vpos
== tovpos
&& hpos
>= tohpos
)
1244 if (contin_hpos
&& prev_hpos
== 0
1246 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1247 { /* Line breaks because we can't put the character at the
1248 previous line any more. It is not the multi-column
1249 character continued in middle. Go back to previous
1250 buffer position, screen position, and set tab offset
1251 to previous value. It's the beginning of the
1254 pos_byte
= prev_pos_byte
;
1256 tab_offset
= prev_tab_offset
;
1260 if (pos
== ZV
) /* We cannot go beyond ZV. Stop here. */
1265 prev_pos_byte
= pos_byte
;
1266 wide_column_end_hpos
= 0;
1268 /* Consult the width run cache to see if we can avoid inspecting
1269 the text character-by-character. */
1270 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
1274 = region_cache_forward (current_buffer
,
1275 current_buffer
->width_run_cache
,
1278 /* A width of zero means the character's width varies (like
1279 a tab), is meaningless (like a newline), or we just don't
1280 want to skip over it for some other reason. */
1281 if (common_width
!= 0)
1285 /* Don't go past the final buffer posn the user
1290 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1292 /* Don't go past the final horizontal position the user
1294 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
1296 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
1297 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1300 /* Don't go past the margin. */
1301 if (run_end_hpos
>= width
)
1303 run_end
= pos
+ (width
- hpos
) / common_width
;
1304 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1307 hpos
= run_end_hpos
;
1309 prev_hpos
= hpos
- common_width
;
1313 pos_byte
= CHAR_TO_BYTE (pos
);
1317 next_width_run
= run_end
+ 1;
1320 /* We have to scan the text character-by-character. */
1323 c
= FETCH_BYTE (pos_byte
);
1326 /* Perhaps add some info to the width_run_cache. */
1327 if (current_buffer
->width_run_cache
)
1329 /* Is this character part of the current run? If so, extend
1331 if (pos
- 1 == width_run_end
1332 && XFASTINT (width_table
[c
]) == width_run_width
)
1333 width_run_end
= pos
;
1335 /* The previous run is over, since this is a character at a
1336 different position, or a different width. */
1339 /* Have we accumulated a run to put in the cache?
1340 (Currently, we only cache runs of width == 1). */
1341 if (width_run_start
< width_run_end
1342 && width_run_width
== 1)
1343 know_region_cache (current_buffer
,
1344 current_buffer
->width_run_cache
,
1345 width_run_start
, width_run_end
);
1347 /* Start recording a new width run. */
1348 width_run_width
= XFASTINT (width_table
[c
]);
1349 width_run_start
= pos
- 1;
1350 width_run_end
= pos
;
1355 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
1356 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1357 hpos
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
1358 else if (c
>= 040 && c
< 0177)
1362 int tem
= (hpos
+ tab_offset
+ hscroll
- (hscroll
> 0)) % tab_width
;
1365 hpos
+= tab_width
- tem
;
1370 && indented_beyond_p (pos
, pos_byte
, selective
))
1372 /* If (pos == to), we don't have to take care of
1373 selective display. */
1376 /* Skip any number of invisible lines all at once */
1379 pos
= find_before_next_newline (pos
, to
, 1);
1382 pos_byte
= CHAR_TO_BYTE (pos
);
1385 && indented_beyond_p (pos
, pos_byte
, selective
));
1386 /* Allow for the " ..." that is displayed for them. */
1389 hpos
+= selective_rlen
;
1393 DEC_BOTH (pos
, pos_byte
);
1394 /* We have skipped the invis text, but not the
1400 /* A visible line. */
1404 /* Count the truncation glyph on column 0 */
1411 else if (c
== CR
&& selective
< 0)
1413 /* In selective display mode,
1414 everything from a ^M to the end of the line is invisible.
1415 Stop *before* the real newline. */
1418 pos
= find_before_next_newline (pos
, to
, 1);
1419 pos_byte
= CHAR_TO_BYTE (pos
);
1421 /* If we just skipped next_boundary,
1422 loop around in the main while
1424 if (pos
> next_boundary
)
1425 next_boundary
= pos
;
1426 /* Allow for the " ..." that is displayed for them. */
1429 hpos
+= selective_rlen
;
1434 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
1436 /* Start of multi-byte form. */
1438 int bytes
, width
, wide_column
;
1440 pos_byte
--; /* rewind POS_BYTE */
1441 ptr
= BYTE_POS_ADDR (pos_byte
);
1442 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
1445 wide_column_end_hpos
= hpos
+ wide_column
;
1449 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
1455 /* Remember any final width run in the cache. */
1456 if (current_buffer
->width_run_cache
1457 && width_run_width
== 1
1458 && width_run_start
< width_run_end
)
1459 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
1460 width_run_start
, width_run_end
);
1462 val_compute_motion
.bufpos
= pos
;
1463 val_compute_motion
.bytepos
= pos_byte
;
1464 val_compute_motion
.hpos
= hpos
;
1465 val_compute_motion
.vpos
= vpos
;
1466 if (contin_hpos
&& prev_hpos
== 0)
1467 val_compute_motion
.prevhpos
= contin_hpos
;
1469 val_compute_motion
.prevhpos
= prev_hpos
;
1470 /* We alalways handle all of them here; none of them remain to do. */
1471 val_compute_motion
.ovstring_chars_done
= 0;
1473 /* Nonzero if have just continued a line */
1474 val_compute_motion
.contin
= (contin_hpos
&& prev_hpos
== 0);
1476 return &val_compute_motion
;
1480 #if 0 /* The doc string is too long for some compilers,
1481 but make-docfile can find it in this comment. */
1482 DEFUN ("compute-motion", Ffoo
, Sfoo
, 7, 7, 0,
1483 "Scan through the current buffer, calculating screen position.\n\
1484 Scan the current buffer forward from offset FROM,\n\
1485 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--\n\
1486 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--\n\
1487 and return the ending buffer position and screen location.\n\
1489 There are three additional arguments:\n\
1491 WIDTH is the number of columns available to display text;\n\
1492 this affects handling of continuation lines.\n\
1493 This is usually the value returned by `window-width', less one (to allow\n\
1494 for the continuation glyph).\n\
1496 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).\n\
1497 HSCROLL is the number of columns not being displayed at the left\n\
1498 margin; this is usually taken from a window's hscroll member.\n\
1499 TAB-OFFSET is the number of columns of the first tab that aren't\n\
1500 being displayed, perhaps because the line was continued within it.\n\
1501 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.\n\
1503 WINDOW is the window to operate on. It is used to choose the display table;\n\
1504 if it is showing the current buffer, it is used also for\n\
1505 deciding which overlay properties apply.\n\
1506 Note that `compute-motion' always operates on the current buffer.\n\
1508 The value is a list of five elements:\n\
1509 (POS HPOS VPOS PREVHPOS CONTIN)\n\
1510 POS is the buffer position where the scan stopped.\n\
1511 VPOS is the vertical position where the scan stopped.\n\
1512 HPOS is the horizontal position where the scan stopped.\n\
1514 PREVHPOS is the horizontal position one character back from POS.\n\
1515 CONTIN is t if a line was continued after (or within) the previous character.\n\
1517 For example, to find the buffer position of column COL of line LINE\n\
1518 of a certain window, pass the window's starting location as FROM\n\
1519 and the window's upper-left coordinates as FROMPOS.\n\
1520 Pass the buffer's (point-max) as TO, to limit the scan to the end of the\n\
1521 visible section of the buffer, and pass LINE and COL as TOPOS.")
1522 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1525 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
1527 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1528 Lisp_Object from
, frompos
, to
, topos
;
1529 Lisp_Object width
, offsets
, window
;
1531 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
, contin
;
1532 struct position
*pos
;
1533 int hscroll
, tab_offset
;
1535 CHECK_NUMBER_COERCE_MARKER (from
, 0);
1536 CHECK_CONS (frompos
, 0);
1537 CHECK_NUMBER (XCAR (frompos
), 0);
1538 CHECK_NUMBER (XCDR (frompos
), 0);
1539 CHECK_NUMBER_COERCE_MARKER (to
, 0);
1540 CHECK_CONS (topos
, 0);
1541 CHECK_NUMBER (XCAR (topos
), 0);
1542 CHECK_NUMBER (XCDR (topos
), 0);
1543 CHECK_NUMBER (width
, 0);
1544 if (!NILP (offsets
))
1546 CHECK_CONS (offsets
, 0);
1547 CHECK_NUMBER (XCAR (offsets
), 0);
1548 CHECK_NUMBER (XCDR (offsets
), 0);
1549 hscroll
= XINT (XCAR (offsets
));
1550 tab_offset
= XINT (XCDR (offsets
));
1553 hscroll
= tab_offset
= 0;
1556 window
= Fselected_window ();
1558 CHECK_LIVE_WINDOW (window
, 0);
1560 if (XINT (from
) < BEGV
|| XINT (from
) > ZV
)
1561 args_out_of_range_3 (from
, make_number (BEGV
), make_number (ZV
));
1562 if (XINT (to
) < BEGV
|| XINT (to
) > ZV
)
1563 args_out_of_range_3 (to
, make_number (BEGV
), make_number (ZV
));
1565 pos
= compute_motion (XINT (from
), XINT (XCDR (frompos
)),
1566 XINT (XCAR (frompos
)), 0,
1567 XINT (to
), XINT (XCDR (topos
)),
1568 XINT (XCAR (topos
)),
1569 XINT (width
), hscroll
, tab_offset
,
1572 XSETFASTINT (bufpos
, pos
->bufpos
);
1573 XSETINT (hpos
, pos
->hpos
);
1574 XSETINT (vpos
, pos
->vpos
);
1575 XSETINT (prevhpos
, pos
->prevhpos
);
1577 return Fcons (bufpos
,
1581 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
1585 /* Fvertical_motion and vmotion */
1586 struct position val_vmotion
;
1589 vmotion (from
, vtarget
, w
)
1590 register int from
, vtarget
;
1593 int width
= window_internal_width (w
) - 1;
1594 int hscroll
= XINT (w
->hscroll
);
1595 struct position pos
;
1596 /* vpos is cumulative vertical position, changed as from is changed */
1597 register int vpos
= 0;
1598 Lisp_Object prevline
;
1601 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1603 = (INTEGERP (current_buffer
->selective_display
)
1604 ? XINT (current_buffer
->selective_display
)
1605 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1609 /* This is the object we use for fetching character properties. */
1610 Lisp_Object text_prop_object
;
1612 XSETWINDOW (window
, w
);
1614 /* If the window contains this buffer, use it for getting text properties.
1615 Otherwise use the current buffer as arg for doing that. */
1616 if (EQ (w
->buffer
, Fcurrent_buffer ()))
1617 text_prop_object
= window
;
1619 text_prop_object
= Fcurrent_buffer ();
1621 if (vpos
>= vtarget
)
1623 /* To move upward, go a line at a time until
1624 we have gone at least far enough. */
1628 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1630 Lisp_Object propval
;
1632 XSETFASTINT (prevline
, find_next_newline_no_quit (from
- 1, -1));
1633 while (XFASTINT (prevline
) > BEGV
1635 && indented_beyond_p (XFASTINT (prevline
),
1636 CHAR_TO_BYTE (XFASTINT (prevline
)),
1638 /* watch out for newlines with `invisible' property */
1639 || (propval
= Fget_char_property (prevline
,
1642 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1643 XSETFASTINT (prevline
,
1644 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1646 pos
= *compute_motion (XFASTINT (prevline
), 0,
1647 lmargin
+ (XFASTINT (prevline
) == BEG
1651 /* Don't care for VPOS... */
1652 1 << (BITS_PER_SHORT
- 1),
1654 1 << (BITS_PER_SHORT
- 1),
1656 /* This compensates for start_hpos
1657 so that a tab as first character
1658 still occupies 8 columns. */
1659 (XFASTINT (prevline
) == BEG
1664 from
= XFASTINT (prevline
);
1667 /* If we made exactly the desired vertical distance,
1668 or if we hit beginning of buffer,
1669 return point found */
1670 if (vpos
>= vtarget
)
1672 val_vmotion
.bufpos
= from
;
1673 val_vmotion
.bytepos
= CHAR_TO_BYTE (from
);
1674 val_vmotion
.vpos
= vpos
;
1675 val_vmotion
.hpos
= lmargin
;
1676 val_vmotion
.contin
= 0;
1677 val_vmotion
.prevhpos
= 0;
1678 val_vmotion
.ovstring_chars_done
= 0;
1679 val_vmotion
.tab_offset
= 0; /* For accumulating tab offset. */
1680 return &val_vmotion
;
1683 /* Otherwise find the correct spot by moving down */
1685 /* Moving downward is simple, but must calculate from beg of line
1686 to determine hpos of starting point */
1687 from_byte
= CHAR_TO_BYTE (from
);
1688 if (from
> BEGV
&& FETCH_BYTE (from_byte
- 1) != '\n')
1690 Lisp_Object propval
;
1692 XSETFASTINT (prevline
, find_next_newline_no_quit (from
, -1));
1693 while (XFASTINT (prevline
) > BEGV
1695 && indented_beyond_p (XFASTINT (prevline
),
1696 CHAR_TO_BYTE (XFASTINT (prevline
)),
1698 /* watch out for newlines with `invisible' property */
1699 || (propval
= Fget_char_property (prevline
, Qinvisible
,
1701 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1702 XSETFASTINT (prevline
,
1703 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1705 pos
= *compute_motion (XFASTINT (prevline
), 0,
1706 lmargin
+ (XFASTINT (prevline
) == BEG
1710 /* Don't care for VPOS... */
1711 1 << (BITS_PER_SHORT
- 1),
1713 1 << (BITS_PER_SHORT
- 1),
1715 (XFASTINT (prevline
) == BEG
? -start_hpos
: 0),
1721 pos
.hpos
= lmargin
+ (from
== BEG
? start_hpos
: 0);
1726 return compute_motion (from
, vpos
, pos
.hpos
, did_motion
,
1727 ZV
, vtarget
, - (1 << (BITS_PER_SHORT
- 1)),
1729 pos
.tab_offset
- (from
== BEG
? start_hpos
: 0),
1733 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
1734 "Move point to start of the screen line LINES lines down.\n\
1735 If LINES is negative, this means moving up.\n\
1737 This function is an ordinary cursor motion function\n\
1738 which calculates the new position based on how text would be displayed.\n\
1739 The new position may be the start of a line,\n\
1740 or just the start of a continuation line.\n\
1741 The function returns number of screen lines moved over;\n\
1742 that usually equals LINES, but may be closer to zero\n\
1743 if beginning or end of buffer was reached.\n\
1745 The optional second argument WINDOW specifies the window to use for\n\
1746 parameters such as width, horizontal scrolling, and so on.\n\
1747 The default is to use the selected window's parameters.\n\
1749 `vertical-motion' always uses the current buffer,\n\
1750 regardless of which buffer is displayed in WINDOW.\n\
1751 This is consistent with other cursor motion functions\n\
1752 and makes it possible to use `vertical-motion' in any buffer,\n\
1753 whether or not it is currently displayed in some window.")
1755 Lisp_Object lines
, window
;
1759 struct buffer
*old
, *b
;
1762 CHECK_NUMBER (lines
, 0);
1763 if (! NILP (window
))
1764 CHECK_WINDOW (window
, 0);
1766 window
= selected_window
;
1768 w
= XWINDOW (window
);
1769 b
= XBUFFER (w
->buffer
);
1770 if (b
!= current_buffer
)
1772 old
= current_buffer
;
1773 set_buffer_internal_1 (b
);
1778 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
1779 start_display (&it
, w
, pt
);
1780 move_it_by_lines (&it
, XINT (lines
), 0);
1781 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
1784 set_buffer_internal_1 (old
);
1786 return make_number (it
.vpos
);
1791 /* file's initialization. */
1796 DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode
,
1797 "*Indentation can insert tabs if this is non-nil.\n\
1798 Setting this variable automatically makes it local to the current buffer.");
1799 indent_tabs_mode
= 1;
1801 defsubr (&Scurrent_indentation
);
1802 defsubr (&Sindent_to
);
1803 defsubr (&Scurrent_column
);
1804 defsubr (&Smove_to_column
);
1805 defsubr (&Svertical_motion
);
1806 defsubr (&Scompute_motion
);