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 C is *P which should satisfy `BASE_LEADING_CODE_P (c)'.
273 DP is a display table or NULL.
275 This macro is used in current_column_1, Fmove_to_column, and
278 #define MULTIBYTE_BYTES_WIDTH(p, c, dp) \
280 unsigned char *pend = p + 1; \
283 while (! CHAR_HEAD_P (*pend)) pend++; \
285 if (c == LEADING_CODE_COMPOSITION) \
287 int id = str_cmpchar_id (p, pend - p); \
288 int ch = MAKE_COMPOSITE_CHAR (id); \
292 bytes = cmpchar_table[id]->len; \
293 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, ch))) \
294 width = XVECTOR (DISP_CHAR_VECTOR (dp, ch))->size; \
296 width = cmpchar_table[id]->width; \
298 wide_column = width; \
308 bytes = BYTES_BY_CHAR_HEAD (c); \
309 if (bytes >= 2 && bytes <= pend - p) \
313 if (dp && (ch = STRING_CHAR (p, bytes), \
314 VECTORP (DISP_CHAR_VECTOR (dp, ch)))) \
315 width = XVECTOR (DISP_CHAR_VECTOR (dp, ch))->size; \
317 width = WIDTH_BY_CHAR_HEAD (c); \
319 wide_column = width; \
327 if (p + bytes < pend) \
329 width += 4 * (pend - (p + bytes)); \
334 DEFUN ("current-column", Fcurrent_column
, Scurrent_column
, 0, 0, 0,
335 "Return the horizontal position of point. Beginning of line is column 0.\n\
336 This is calculated by adding together the widths of all the displayed\n\
337 representations of the character between the start of the previous line\n\
338 and point. (eg control characters will have a width of 2 or 4, tabs\n\
339 will have a variable width)\n\
340 Ignores finite width of frame, which means that this function may return\n\
341 values greater than (frame-width).\n\
342 Whether the line is visible (if `selective-display' is t) has no effect;\n\
343 however, ^M is treated as end of line when `selective-display' is t.")
347 XSETFASTINT (temp
, current_column ());
351 /* Cancel any recorded value of the horizontal position. */
354 invalidate_current_column ()
356 last_known_column_point
= 0;
363 register unsigned char *ptr
, *stop
;
364 register int tab_seen
;
367 register int tab_width
= XINT (current_buffer
->tab_width
);
368 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
369 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 || !NILP (current_buffer
->overlays_before
)
380 || !NILP (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) tab_width
= 8;
400 col
= 0, tab_seen
= 0, post_tab
= 0;
406 /* We stopped either for the beginning of the buffer
408 if (ptr
== BEGV_ADDR
)
410 /* It was the gap. Jump back over it. */
413 /* Check whether that brings us to beginning of buffer. */
414 if (BEGV
>= GPT
) break;
418 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
419 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
420 else if (c
>= 040 && c
< 0177)
423 || (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
)))
431 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
438 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
443 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
447 if (ptr
== BEGV_ADDR
)
448 current_column_bol_cache
= BEGV
;
450 current_column_bol_cache
= BYTE_TO_CHAR (PTR_BYTE_POS (ptr
));
452 last_known_column
= col
;
453 last_known_column_point
= PT
;
454 last_known_column_modified
= MODIFF
;
459 /* Return the column number of position POS
460 by scanning forward from the beginning of the line.
461 This function handles characters that are invisible
462 due to text properties or overlays. */
467 register int tab_width
= XINT (current_buffer
->tab_width
);
468 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
469 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
470 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
472 /* Start the scan at the beginning of this line with column number 0. */
473 register int col
= 0;
475 int next_boundary
, next_boundary_byte
;
476 int opoint
= PT
, opoint_byte
= PT_BYTE
;
478 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
479 current_column_bol_cache
= PT
;
480 scan
= PT
, scan_byte
= PT_BYTE
;
481 SET_PT_BOTH (opoint
, opoint_byte
);
482 next_boundary
= scan
;
483 next_boundary_byte
= scan_byte
;
485 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
487 /* Scan forward to the target position. */
488 while (scan
< opoint
)
492 /* Occasionally we may need to skip invisible text. */
493 while (scan
== next_boundary
)
496 /* This updates NEXT_BOUNDARY to the next place
497 where we might need to skip more invisible text. */
498 scan
= skip_invisible (scan
, &next_boundary
, opoint
, Qnil
);
501 if (scan
!= old_scan
)
502 scan_byte
= CHAR_TO_BYTE (scan
);
503 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
506 c
= FETCH_BYTE (scan_byte
);
508 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
509 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
511 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
518 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
526 col
= col
/ tab_width
* tab_width
;
528 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
531 int bytes
, width
, wide_column
;
534 ptr
= BYTE_POS_ADDR (scan_byte
);
535 MULTIBYTE_BYTES_WIDTH (ptr
, c
, dp
);
539 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
541 else if (c
< 040 || c
>= 0177)
548 last_known_column
= col
;
549 last_known_column_point
= PT
;
550 last_known_column_modified
= MODIFF
;
555 /* Return the width in columns of the part of STRING from BEG to END.
556 If BEG is nil, that stands for the beginning of STRING.
557 If END is nil, that stands for the end of STRING. */
560 string_display_width (string
, beg
, end
)
561 Lisp_Object string
, beg
, end
;
564 register unsigned char *ptr
, *stop
;
565 register int tab_seen
;
568 register int tab_width
= XINT (current_buffer
->tab_width
);
569 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
570 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
574 e
= XSTRING (string
)->size
;
577 CHECK_NUMBER (end
, 0);
585 CHECK_NUMBER (beg
, 0);
589 /* Make a pointer for decrementing through the chars before point. */
590 ptr
= XSTRING (string
)->data
+ e
;
591 /* Make a pointer to where consecutive chars leave off,
592 going backwards from point. */
593 stop
= XSTRING (string
)->data
+ b
;
595 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
597 col
= 0, tab_seen
= 0, post_tab
= 0;
605 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
606 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
607 else if (c
>= 040 && c
< 0177)
614 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
621 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
626 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
633 DEFUN ("indent-to", Findent_to
, Sindent_to
, 1, 2, "NIndent to column: ",
634 "Indent from point with tabs and spaces until COLUMN is reached.\n\
635 Optional second argument MININUM says always do at least MININUM spaces\n\
636 even if that goes past COLUMN; by default, MININUM is zero.")
638 Lisp_Object column
, minimum
;
641 register int fromcol
;
642 register int tab_width
= XINT (current_buffer
->tab_width
);
644 CHECK_NUMBER (column
, 0);
646 XSETFASTINT (minimum
, 0);
647 CHECK_NUMBER (minimum
, 1);
649 fromcol
= current_column ();
650 mincol
= fromcol
+ XINT (minimum
);
651 if (mincol
< XINT (column
)) mincol
= XINT (column
);
653 if (fromcol
== mincol
)
654 return make_number (mincol
);
656 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
658 if (indent_tabs_mode
)
661 XSETFASTINT (n
, mincol
/ tab_width
- fromcol
/ tab_width
);
662 if (XFASTINT (n
) != 0)
664 Finsert_char (make_number ('\t'), n
, Qt
);
666 fromcol
= (mincol
/ tab_width
) * tab_width
;
670 XSETFASTINT (column
, mincol
- fromcol
);
671 Finsert_char (make_number (' '), column
, Qt
);
673 last_known_column
= mincol
;
674 last_known_column_point
= PT
;
675 last_known_column_modified
= MODIFF
;
677 XSETINT (column
, mincol
);
682 static int position_indentation
P_ ((int));
684 DEFUN ("current-indentation", Fcurrent_indentation
, Scurrent_indentation
,
686 "Return the indentation of the current line.\n\
687 This is the horizontal position of the character\n\
688 following any initial whitespace.")
692 int opoint
= PT
, opoint_byte
= PT_BYTE
;
694 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
696 XSETFASTINT (val
, position_indentation (PT_BYTE
));
697 SET_PT_BOTH (opoint
, opoint_byte
);
702 position_indentation (pos_byte
)
703 register int pos_byte
;
705 register int column
= 0;
706 register int tab_width
= XINT (current_buffer
->tab_width
);
707 register unsigned char *p
;
708 register unsigned char *stop
;
709 unsigned char *start
;
710 int next_boundary_byte
= pos_byte
;
711 int ceiling
= next_boundary_byte
;
713 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
715 p
= BYTE_POS_ADDR (pos_byte
);
716 /* STOP records the value of P at which we will need
717 to think about the gap, or about invisible text,
718 or about the end of the buffer. */
720 /* START records the starting value of P. */
728 /* If we have updated P, set POS_BYTE to match.
729 The first time we enter the loop, POS_BYTE is already right. */
731 pos_byte
= PTR_BYTE_POS (p
);
732 /* Consider the various reasons STOP might have been set here. */
733 if (pos_byte
== ZV_BYTE
)
735 if (pos_byte
== next_boundary_byte
)
738 int pos
= BYTE_TO_CHAR (pos_byte
);
739 pos
= skip_invisible (pos
, &next_boundary
, ZV
, Qnil
);
740 pos_byte
= CHAR_TO_BYTE (pos
);
741 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
743 if (pos_byte
>= ceiling
)
744 ceiling
= BUFFER_CEILING_OF (pos_byte
) + 1;
745 /* Compute the next place we need to stop and think,
746 and set STOP accordingly. */
747 stop_pos_byte
= min (ceiling
, next_boundary_byte
);
748 /* The -1 and +1 arrange to point at the first byte of gap
749 (if STOP_POS_BYTE is the position of the gap)
750 rather than at the data after the gap. */
752 stop
= BYTE_POS_ADDR (stop_pos_byte
- 1) + 1;
753 p
= BYTE_POS_ADDR (pos_byte
);
758 if (! NILP (current_buffer
->enable_multibyte_characters
))
764 column
+= tab_width
- column
% tab_width
;
767 if (ASCII_BYTE_P (p
[-1])
768 || NILP (current_buffer
->enable_multibyte_characters
))
772 pos_byte
= PTR_BYTE_POS (p
- 1);
773 c
= FETCH_MULTIBYTE_CHAR (pos_byte
);
774 if (CHAR_HAS_CATEGORY (c
, ' '))
778 p
= BYTE_POS_ADDR (pos_byte
);
787 /* Test whether the line beginning at POS is indented beyond COLUMN.
788 Blank lines are treated as if they had the same indentation as the
792 indented_beyond_p (pos
, pos_byte
, column
)
793 int pos
, pos_byte
, column
;
796 int opoint
= PT
, opoint_byte
= PT_BYTE
;
798 SET_PT_BOTH (pos
, pos_byte
);
799 while (PT
> BEGV
&& FETCH_BYTE (PT_BYTE
) == '\n')
800 scan_newline (PT
- 1, PT_BYTE
- 1, BEGV
, BEGV_BYTE
, -1, 0);
802 val
= position_indentation (PT_BYTE
);
803 SET_PT_BOTH (opoint
, opoint_byte
);
807 DEFUN ("move-to-column", Fmove_to_column
, Smove_to_column
, 1, 2, "p",
808 "Move point to column COLUMN in the current line.\n\
809 The column of a character is calculated by adding together the widths\n\
810 as displayed of the previous characters in the line.\n\
811 This function ignores line-continuation;\n\
812 there is no upper limit on the column number a character can have\n\
813 and horizontal scrolling has no effect.\n\
815 If specified column is within a character, point goes after that character.\n\
816 If it's past end of line, point goes to end of line.\n\n\
817 A non-nil second (optional) argument FORCE means, if the line\n\
818 is too short to reach column COLUMN then add spaces/tabs to get there,\n\
819 and if COLUMN is in the middle of a tab character, change it to spaces.\n\
821 The return value is the current column.")
823 Lisp_Object column
, force
;
826 register int col
= current_column ();
829 register int tab_width
= XINT (current_buffer
->tab_width
);
830 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
831 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
832 register int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
839 int pos_byte
, end_byte
, next_boundary_byte
;
841 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
842 CHECK_NATNUM (column
, 0);
843 goal
= XINT (column
);
850 next_boundary_byte
= PT_BYTE
;
852 /* If we're starting past the desired column,
853 back up to beginning of line and scan from there. */
857 pos
= current_column_bol_cache
;
858 pos_byte
= CHAR_TO_BYTE (pos
);
864 while (pos
== next_boundary
)
867 pos
= skip_invisible (pos
, &next_boundary
, end
, Qnil
);
869 pos_byte
= CHAR_TO_BYTE (pos
);
870 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
875 /* Test reaching the goal column. We do this after skipping
876 invisible characters, so that we put point before the
877 character on which the cursor will appear. */
881 c
= FETCH_BYTE (pos_byte
);
883 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
884 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
886 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
893 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
901 col
= col
/ tab_width
* tab_width
;
903 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
905 else if (c
< 040 || c
== 0177)
909 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
911 /* Start of multi-byte form. */
913 int bytes
, width
, wide_column
;
916 ptr
= BYTE_POS_ADDR (pos_byte
);
917 MULTIBYTE_BYTES_WIDTH (ptr
, c
, dp
);
926 SET_PT_BOTH (pos
, pos_byte
);
928 /* If a tab char made us overshoot, change it to spaces
929 and scan through it again. */
930 if (!NILP (force
) && col
> goal
&& c
== '\t' && prev_col
< goal
)
932 int old_point
, old_point_byte
;
934 del_range (PT
- 1, PT
);
935 Findent_to (make_number (goal
), Qnil
);
937 old_point_byte
= PT_BYTE
;
938 Findent_to (make_number (col
), Qnil
);
939 SET_PT_BOTH (old_point
, old_point_byte
);
940 /* Set the last_known... vars consistently. */
944 /* If line ends prematurely, add space to the end. */
945 if (col
< goal
&& !NILP (force
))
946 Findent_to (make_number (col
= goal
), Qnil
);
948 last_known_column
= col
;
949 last_known_column_point
= PT
;
950 last_known_column_modified
= MODIFF
;
952 XSETFASTINT (val
, col
);
956 /* compute_motion: compute buffer posn given screen posn and vice versa */
958 struct position val_compute_motion
;
960 /* Scan the current buffer forward from offset FROM, pretending that
961 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
962 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
963 and return the ending buffer position and screen location. If we
964 can't hit the requested column exactly (because of a tab or other
965 multi-column character), overshoot.
967 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
968 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
969 earlier call to compute_motion. The other common case is that FROMHPOS
970 is zero and FROM is a position that "belongs" at column zero, but might
971 be shifted by overlay strings; in this case DID_MOTION should be 0.
973 WIDTH is the number of columns available to display text;
974 compute_motion uses this to handle continuation lines and such.
975 HSCROLL is the number of columns not being displayed at the left
976 margin; this is usually taken from a window's hscroll member.
977 TAB_OFFSET is the number of columns of the first tab that aren't
978 being displayed, perhaps because of a continuation line or
981 compute_motion returns a pointer to a struct position. The bufpos
982 member gives the buffer position at the end of the scan, and hpos
983 and vpos give its cartesian location. prevhpos is the column at
984 which the character before bufpos started, and contin is non-zero
985 if we reached the current line by continuing the previous.
987 Note that FROMHPOS and TOHPOS should be expressed in real screen
988 columns, taking HSCROLL and the truncation glyph at the left margin
989 into account. That is, beginning-of-line moves you to the hpos
990 -HSCROLL + (HSCROLL > 0).
992 For example, to find the buffer position of column COL of line LINE
993 of a certain window, pass the window's starting location as FROM
994 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
995 Pass the buffer's ZV as TO, to limit the scan to the end of the
996 visible section of the buffer, and pass LINE and COL as TOVPOS and
999 When displaying in window w, a typical formula for WIDTH is:
1002 - (has_vertical_scroll_bars
1003 ? FRAME_SCROLL_BAR_COLS (XFRAME (window->frame))
1004 : (window_width + window_left != frame_width))
1007 window_width is XFASTINT (w->width),
1008 window_left is XFASTINT (w->left),
1009 has_vertical_scroll_bars is
1010 FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (WINDOW_FRAME (window)))
1011 and frame_width = FRAME_WIDTH (XFRAME (window->frame))
1013 Or you can let window_internal_width do this all for you, and write:
1014 window_internal_width (w) - 1
1016 The `-1' accounts for the continuation-line backslashes; the rest
1017 accounts for window borders if the window is split horizontally, and
1018 the scroll bars if they are turned on. */
1021 compute_motion (from
, fromvpos
, fromhpos
, did_motion
, to
, tovpos
, tohpos
, width
, hscroll
, tab_offset
, win
)
1022 int from
, fromvpos
, fromhpos
, to
, tovpos
, tohpos
;
1025 int hscroll
, tab_offset
;
1028 register int hpos
= fromhpos
;
1029 register int vpos
= fromvpos
;
1034 register int tab_width
= XFASTINT (current_buffer
->tab_width
);
1035 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
1036 register struct Lisp_Char_Table
*dp
= window_display_table (win
);
1038 = (INTEGERP (current_buffer
->selective_display
)
1039 ? XINT (current_buffer
->selective_display
)
1040 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1043 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
1044 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
: 0);
1045 /* The next location where the `invisible' property changes, or an
1046 overlay starts or ends. */
1047 int next_boundary
= from
;
1049 /* For computing runs of characters with similar widths.
1050 Invariant: width_run_width is zero, or all the characters
1051 from width_run_start to width_run_end have a fixed width of
1053 int width_run_start
= from
;
1054 int width_run_end
= from
;
1055 int width_run_width
= 0;
1056 Lisp_Object
*width_table
;
1059 /* The next buffer pos where we should consult the width run cache. */
1060 int next_width_run
= from
;
1063 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
1064 /* If previous char scanned was a wide character,
1065 this is the column where it ended. Otherwise, this is 0. */
1066 int wide_column_end_hpos
= 0;
1067 int prev_pos
; /* Previous buffer position. */
1068 int prev_pos_byte
; /* Previous buffer position. */
1069 int contin_hpos
; /* HPOS of last column of continued line. */
1070 int prev_tab_offset
; /* Previous tab offset. */
1072 XSETBUFFER (buffer
, current_buffer
);
1073 XSETWINDOW (window
, win
);
1075 width_run_cache_on_off ();
1076 if (dp
== buffer_display_table ())
1077 width_table
= (VECTORP (current_buffer
->width_table
)
1078 ? XVECTOR (current_buffer
->width_table
)->contents
1081 /* If the window has its own display table, we can't use the width
1082 run cache, because that's based on the buffer's display table. */
1085 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
1087 pos
= prev_pos
= from
;
1088 pos_byte
= prev_pos_byte
= CHAR_TO_BYTE (from
);
1090 prev_tab_offset
= tab_offset
;
1093 while (pos
== next_boundary
)
1098 /* If the caller says that the screen position came from an earlier
1099 call to compute_motion, then we've already accounted for the
1100 overlay strings at point. This is only true the first time
1101 through, so clear the flag after testing it. */
1103 /* We need to skip past the overlay strings. Currently those
1104 strings must not contain TAB;
1105 if we want to relax that restriction, something will have
1106 to be changed here. */
1108 unsigned char *ovstr
;
1109 int ovlen
= overlay_strings (pos
, win
, &ovstr
);
1110 hpos
+= ((multibyte
&& ovlen
> 0)
1111 ? strwidth (ovstr
, ovlen
) : ovlen
);
1118 /* Advance POS past invisible characters
1119 (but not necessarily all that there are here),
1120 and store in next_boundary the next position where
1121 we need to call skip_invisible. */
1122 newpos
= skip_invisible (pos
, &next_boundary
, to
, window
);
1126 pos
= min (to
, newpos
);
1130 if (newpos
!= pos_here
)
1133 pos_byte
= CHAR_TO_BYTE (pos
);
1137 /* Handle right margin. */
1138 /* Note on a wide-column character.
1140 Characters are classified into the following three categories
1141 according to the width (columns occupied on screen).
1143 (1) single-column character: ex. `a'
1144 (2) multi-column character: ex. `^A', TAB, `\033'
1145 (3) wide-column character: ex. Japanese character, Chinese character
1146 (In the following example, `W_' stands for them.)
1148 Multi-column characters can be divided around the right margin,
1149 but wide-column characters cannot.
1153 (*) The cursor is placed on the next character after the point.
1157 j ^---- next after the point
1158 ^--- next char. after the point.
1160 In case of sigle-column character
1164 033 ^---- next after the point, next char. after the point.
1166 In case of multi-column character
1170 W_ ^---- next after the point
1171 ^---- next char. after the point.
1173 In case of wide-column character
1175 The problem here is continuation at a wide-column character.
1176 In this case, the line may shorter less than WIDTH.
1177 And we find the continuation AFTER it occurs.
1184 || (truncate_partial_width_windows
1185 && width
+ 1 < FRAME_WIDTH (XFRAME (WINDOW_FRAME (win
))))
1186 || !NILP (current_buffer
->truncate_lines
))
1188 /* Truncating: skip to newline, unless we are already past
1189 TO (we need to go back below). */
1192 pos
= find_before_next_newline (pos
, to
, 1);
1193 pos_byte
= CHAR_TO_BYTE (pos
);
1195 /* If we just skipped next_boundary,
1196 loop around in the main while
1198 if (pos
>= next_boundary
)
1199 next_boundary
= pos
+ 1;
1201 prev_tab_offset
= tab_offset
;
1207 /* Remember the previous value. */
1208 prev_tab_offset
= tab_offset
;
1210 if (wide_column_end_hpos
> width
)
1213 tab_offset
+= prev_hpos
;
1217 tab_offset
+= width
;
1221 contin_hpos
= prev_hpos
;
1226 /* Stop if past the target buffer position or screen position. */
1229 /* Go back to the previous position. */
1231 pos_byte
= prev_pos_byte
;
1233 tab_offset
= prev_tab_offset
;
1235 /* NOTE on contin_hpos, hpos, and prev_hpos.
1239 W_ ^---- contin_hpos
1245 if (contin_hpos
&& prev_hpos
== 0
1246 && contin_hpos
< width
&& !wide_column_end_hpos
)
1248 /* Line breaking occurs in the middle of multi-column
1249 character. Go back to previous line. */
1254 /* If previous character is NEWLINE,
1255 set VPOS back to previous line */
1260 if (vpos
> tovpos
|| vpos
== tovpos
&& hpos
>= tohpos
)
1262 if (contin_hpos
&& prev_hpos
== 0
1264 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1265 { /* Line breaks because we can't put the character at the
1266 previous line any more. It is not the multi-column
1267 character continued in middle. Go back to previous
1268 buffer position, screen position, and set tab offset
1269 to previous value. It's the beginning of the
1272 pos_byte
= prev_pos_byte
;
1274 tab_offset
= prev_tab_offset
;
1278 if (pos
== ZV
) /* We cannot go beyond ZV. Stop here. */
1283 prev_pos_byte
= pos_byte
;
1284 wide_column_end_hpos
= 0;
1286 /* Consult the width run cache to see if we can avoid inspecting
1287 the text character-by-character. */
1288 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
1292 = region_cache_forward (current_buffer
,
1293 current_buffer
->width_run_cache
,
1296 /* A width of zero means the character's width varies (like
1297 a tab), is meaningless (like a newline), or we just don't
1298 want to skip over it for some other reason. */
1299 if (common_width
!= 0)
1303 /* Don't go past the final buffer posn the user
1308 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1310 /* Don't go past the final horizontal position the user
1312 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
1314 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
1315 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1318 /* Don't go past the margin. */
1319 if (run_end_hpos
>= width
)
1321 run_end
= pos
+ (width
- hpos
) / common_width
;
1322 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1325 hpos
= run_end_hpos
;
1327 prev_hpos
= hpos
- common_width
;
1331 pos_byte
= CHAR_TO_BYTE (pos
);
1335 next_width_run
= run_end
+ 1;
1338 /* We have to scan the text character-by-character. */
1341 c
= FETCH_BYTE (pos_byte
);
1344 /* Perhaps add some info to the width_run_cache. */
1345 if (current_buffer
->width_run_cache
)
1347 /* Is this character part of the current run? If so, extend
1349 if (pos
- 1 == width_run_end
1350 && XFASTINT (width_table
[c
]) == width_run_width
)
1351 width_run_end
= pos
;
1353 /* The previous run is over, since this is a character at a
1354 different position, or a different width. */
1357 /* Have we accumulated a run to put in the cache?
1358 (Currently, we only cache runs of width == 1). */
1359 if (width_run_start
< width_run_end
1360 && width_run_width
== 1)
1361 know_region_cache (current_buffer
,
1362 current_buffer
->width_run_cache
,
1363 width_run_start
, width_run_end
);
1365 /* Start recording a new width run. */
1366 width_run_width
= XFASTINT (width_table
[c
]);
1367 width_run_start
= pos
- 1;
1368 width_run_end
= pos
;
1373 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
1374 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1375 hpos
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
1376 else if (c
>= 040 && c
< 0177)
1380 int tem
= (hpos
+ tab_offset
+ hscroll
- (hscroll
> 0)) % tab_width
;
1383 hpos
+= tab_width
- tem
;
1388 && indented_beyond_p (pos
, pos_byte
, selective
))
1390 /* If (pos == to), we don't have to take care of
1391 selective display. */
1394 /* Skip any number of invisible lines all at once */
1397 pos
= find_before_next_newline (pos
, to
, 1) + 1;
1398 pos_byte
= CHAR_TO_BYTE (pos
);
1401 && indented_beyond_p (pos
, pos_byte
, selective
));
1402 /* Allow for the " ..." that is displayed for them. */
1405 hpos
+= selective_rlen
;
1409 DEC_BOTH (pos
, pos_byte
);
1410 /* We have skipped the invis text, but not the
1416 /* A visible line. */
1420 /* Count the truncation glyph on column 0 */
1427 else if (c
== CR
&& selective
< 0)
1429 /* In selective display mode,
1430 everything from a ^M to the end of the line is invisible.
1431 Stop *before* the real newline. */
1434 pos
= find_before_next_newline (pos
, to
, 1);
1435 pos_byte
= CHAR_TO_BYTE (pos
);
1437 /* If we just skipped next_boundary,
1438 loop around in the main while
1440 if (pos
> next_boundary
)
1441 next_boundary
= pos
;
1442 /* Allow for the " ..." that is displayed for them. */
1445 hpos
+= selective_rlen
;
1450 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
1452 /* Start of multi-byte form. */
1454 int bytes
, width
, wide_column
;
1456 pos_byte
--; /* rewind POS_BYTE */
1457 ptr
= BYTE_POS_ADDR (pos_byte
);
1458 MULTIBYTE_BYTES_WIDTH (ptr
, c
, dp
);
1461 wide_column_end_hpos
= hpos
+ wide_column
;
1465 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
1471 /* Remember any final width run in the cache. */
1472 if (current_buffer
->width_run_cache
1473 && width_run_width
== 1
1474 && width_run_start
< width_run_end
)
1475 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
1476 width_run_start
, width_run_end
);
1478 val_compute_motion
.bufpos
= pos
;
1479 val_compute_motion
.bytepos
= pos_byte
;
1480 val_compute_motion
.hpos
= hpos
;
1481 val_compute_motion
.vpos
= vpos
;
1482 if (contin_hpos
&& prev_hpos
== 0)
1483 val_compute_motion
.prevhpos
= contin_hpos
;
1485 val_compute_motion
.prevhpos
= prev_hpos
;
1486 /* We alalways handle all of them here; none of them remain to do. */
1487 val_compute_motion
.ovstring_chars_done
= 0;
1489 /* Nonzero if have just continued a line */
1490 val_compute_motion
.contin
= (contin_hpos
&& prev_hpos
== 0);
1492 return &val_compute_motion
;
1495 #if 0 /* The doc string is too long for some compilers,
1496 but make-docfile can find it in this comment. */
1497 DEFUN ("compute-motion", Ffoo
, Sfoo
, 7, 7, 0,
1498 "Scan through the current buffer, calculating screen position.\n\
1499 Scan the current buffer forward from offset FROM,\n\
1500 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--\n\
1501 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--\n\
1502 and return the ending buffer position and screen location.\n\
1504 There are three additional arguments:\n\
1506 WIDTH is the number of columns available to display text;\n\
1507 this affects handling of continuation lines.\n\
1508 This is usually the value returned by `window-width', less one (to allow\n\
1509 for the continuation glyph).\n\
1511 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).\n\
1512 HSCROLL is the number of columns not being displayed at the left\n\
1513 margin; this is usually taken from a window's hscroll member.\n\
1514 TAB-OFFSET is the number of columns of the first tab that aren't\n\
1515 being displayed, perhaps because the line was continued within it.\n\
1516 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.\n\
1518 WINDOW is the window to operate on. It is used to choose the display table;\n\
1519 if it is showing the current buffer, it is used also for\n\
1520 deciding which overlay properties apply.\n\
1521 Note that `compute-motion' always operates on the current buffer.\n\
1523 The value is a list of five elements:\n\
1524 (POS HPOS VPOS PREVHPOS CONTIN)\n\
1525 POS is the buffer position where the scan stopped.\n\
1526 VPOS is the vertical position where the scan stopped.\n\
1527 HPOS is the horizontal position where the scan stopped.\n\
1529 PREVHPOS is the horizontal position one character back from POS.\n\
1530 CONTIN is t if a line was continued after (or within) the previous character.\n\
1532 For example, to find the buffer position of column COL of line LINE\n\
1533 of a certain window, pass the window's starting location as FROM\n\
1534 and the window's upper-left coordinates as FROMPOS.\n\
1535 Pass the buffer's (point-max) as TO, to limit the scan to the end of the\n\
1536 visible section of the buffer, and pass LINE and COL as TOPOS.")
1537 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1540 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
1542 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1543 Lisp_Object from
, frompos
, to
, topos
;
1544 Lisp_Object width
, offsets
, window
;
1546 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
, contin
;
1547 struct position
*pos
;
1548 int hscroll
, tab_offset
;
1550 CHECK_NUMBER_COERCE_MARKER (from
, 0);
1551 CHECK_CONS (frompos
, 0);
1552 CHECK_NUMBER (XCONS (frompos
)->car
, 0);
1553 CHECK_NUMBER (XCONS (frompos
)->cdr
, 0);
1554 CHECK_NUMBER_COERCE_MARKER (to
, 0);
1555 CHECK_CONS (topos
, 0);
1556 CHECK_NUMBER (XCONS (topos
)->car
, 0);
1557 CHECK_NUMBER (XCONS (topos
)->cdr
, 0);
1558 CHECK_NUMBER (width
, 0);
1559 if (!NILP (offsets
))
1561 CHECK_CONS (offsets
, 0);
1562 CHECK_NUMBER (XCONS (offsets
)->car
, 0);
1563 CHECK_NUMBER (XCONS (offsets
)->cdr
, 0);
1564 hscroll
= XINT (XCONS (offsets
)->car
);
1565 tab_offset
= XINT (XCONS (offsets
)->cdr
);
1568 hscroll
= tab_offset
= 0;
1571 window
= Fselected_window ();
1573 CHECK_LIVE_WINDOW (window
, 0);
1575 if (XINT (from
) < BEGV
|| XINT (from
) > ZV
)
1576 args_out_of_range_3 (from
, make_number (BEGV
), make_number (ZV
));
1577 if (XINT (to
) < BEGV
|| XINT (to
) > ZV
)
1578 args_out_of_range_3 (to
, make_number (BEGV
), make_number (ZV
));
1580 pos
= compute_motion (XINT (from
), XINT (XCONS (frompos
)->cdr
),
1581 XINT (XCONS (frompos
)->car
), 0,
1582 XINT (to
), XINT (XCONS (topos
)->cdr
),
1583 XINT (XCONS (topos
)->car
),
1584 XINT (width
), hscroll
, tab_offset
,
1587 XSETFASTINT (bufpos
, pos
->bufpos
);
1588 XSETINT (hpos
, pos
->hpos
);
1589 XSETINT (vpos
, pos
->vpos
);
1590 XSETINT (prevhpos
, pos
->prevhpos
);
1592 return Fcons (bufpos
,
1596 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
1600 /* Fvertical_motion and vmotion */
1601 struct position val_vmotion
;
1604 vmotion (from
, vtarget
, w
)
1605 register int from
, vtarget
;
1608 int width
= window_internal_width (w
) - 1;
1609 int hscroll
= XINT (w
->hscroll
);
1610 struct position pos
;
1611 /* vpos is cumulative vertical position, changed as from is changed */
1612 register int vpos
= 0;
1613 Lisp_Object prevline
;
1616 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1618 = (INTEGERP (current_buffer
->selective_display
)
1619 ? XINT (current_buffer
->selective_display
)
1620 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1625 XSETWINDOW (window
, w
);
1627 /* The omission of the clause
1628 && marker_position (w->start) == BEG
1629 here is deliberate; I think we want to measure from the prompt
1630 position even if the minibuffer window has scrolled. */
1631 if (EQ (window
, minibuf_window
))
1633 if (minibuf_prompt_width
== 0 && STRINGP (minibuf_prompt
))
1634 minibuf_prompt_width
1635 = string_display_width (minibuf_prompt
, Qnil
, Qnil
);
1637 start_hpos
= minibuf_prompt_width
;
1640 if (vpos
>= vtarget
)
1642 /* To move upward, go a line at a time until
1643 we have gone at least far enough. */
1647 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1649 Lisp_Object propval
;
1651 XSETFASTINT (prevline
, find_next_newline_no_quit (from
- 1, -1));
1652 while (XFASTINT (prevline
) > BEGV
1654 && indented_beyond_p (XFASTINT (prevline
),
1655 CHAR_TO_BYTE (XFASTINT (prevline
)),
1657 #ifdef USE_TEXT_PROPERTIES
1658 /* watch out for newlines with `invisible' property */
1659 || (propval
= Fget_char_property (prevline
,
1662 TEXT_PROP_MEANS_INVISIBLE (propval
))
1665 XSETFASTINT (prevline
,
1666 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1668 pos
= *compute_motion (XFASTINT (prevline
), 0,
1669 lmargin
+ (XFASTINT (prevline
) == BEG
1673 /* Don't care for VPOS... */
1674 1 << (BITS_PER_SHORT
- 1),
1676 1 << (BITS_PER_SHORT
- 1),
1678 /* This compensates for start_hpos
1679 so that a tab as first character
1680 still occupies 8 columns. */
1681 (XFASTINT (prevline
) == BEG
1686 from
= XFASTINT (prevline
);
1689 /* If we made exactly the desired vertical distance,
1690 or if we hit beginning of buffer,
1691 return point found */
1692 if (vpos
>= vtarget
)
1694 val_vmotion
.bufpos
= from
;
1695 val_vmotion
.bytepos
= CHAR_TO_BYTE (from
);
1696 val_vmotion
.vpos
= vpos
;
1697 val_vmotion
.hpos
= lmargin
;
1698 val_vmotion
.contin
= 0;
1699 val_vmotion
.prevhpos
= 0;
1700 val_vmotion
.ovstring_chars_done
= 0;
1701 val_vmotion
.tab_offset
= 0; /* For accumulating tab offset. */
1702 return &val_vmotion
;
1705 /* Otherwise find the correct spot by moving down */
1707 /* Moving downward is simple, but must calculate from beg of line
1708 to determine hpos of starting point */
1709 from_byte
= CHAR_TO_BYTE (from
);
1710 if (from
> BEGV
&& FETCH_BYTE (from_byte
- 1) != '\n')
1712 Lisp_Object propval
;
1714 XSETFASTINT (prevline
, find_next_newline_no_quit (from
, -1));
1715 while (XFASTINT (prevline
) > BEGV
1717 && indented_beyond_p (XFASTINT (prevline
),
1718 CHAR_TO_BYTE (XFASTINT (prevline
)),
1720 #ifdef USE_TEXT_PROPERTIES
1721 /* watch out for newlines with `invisible' property */
1722 || (propval
= Fget_char_property (prevline
, Qinvisible
,
1724 TEXT_PROP_MEANS_INVISIBLE (propval
))
1727 XSETFASTINT (prevline
,
1728 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1730 pos
= *compute_motion (XFASTINT (prevline
), 0,
1731 lmargin
+ (XFASTINT (prevline
) == BEG
1735 /* Don't care for VPOS... */
1736 1 << (BITS_PER_SHORT
- 1),
1738 1 << (BITS_PER_SHORT
- 1),
1740 (XFASTINT (prevline
) == BEG
? -start_hpos
: 0),
1746 pos
.hpos
= lmargin
+ (from
== BEG
? start_hpos
: 0);
1751 return compute_motion (from
, vpos
, pos
.hpos
, did_motion
,
1752 ZV
, vtarget
, - (1 << (BITS_PER_SHORT
- 1)),
1754 pos
.tab_offset
- (from
== BEG
? start_hpos
: 0),
1758 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
1759 "Move point to start of the screen line LINES lines down.\n\
1760 If LINES is negative, this means moving up.\n\
1762 This function is an ordinary cursor motion function\n\
1763 which calculates the new position based on how text would be displayed.\n\
1764 The new position may be the start of a line,\n\
1765 or just the start of a continuation line.\n\
1766 The function returns number of screen lines moved over;\n\
1767 that usually equals LINES, but may be closer to zero\n\
1768 if beginning or end of buffer was reached.\n\
1770 The optional second argument WINDOW specifies the window to use for\n\
1771 parameters such as width, horizontal scrolling, and so on.\n\
1772 The default is to use the selected window's parameters.\n\
1774 `vertical-motion' always uses the current buffer,\n\
1775 regardless of which buffer is displayed in WINDOW.\n\
1776 This is consistent with other cursor motion functions\n\
1777 and makes it possible to use `vertical-motion' in any buffer,\n\
1778 whether or not it is currently displayed in some window.")
1780 Lisp_Object lines
, window
;
1782 struct position pos
;
1784 CHECK_NUMBER (lines
, 0);
1785 if (! NILP (window
))
1786 CHECK_WINDOW (window
, 0);
1788 window
= selected_window
;
1790 pos
= *vmotion (PT
, (int) XINT (lines
), XWINDOW (window
));
1792 SET_PT (pos
.bufpos
);
1793 return make_number (pos
.vpos
);
1796 /* file's initialization. */
1801 DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode
,
1802 "*Indentation can insert tabs if this is non-nil.\n\
1803 Setting this variable automatically makes it local to the current buffer.");
1804 indent_tabs_mode
= 1;
1806 defsubr (&Scurrent_indentation
);
1807 defsubr (&Sindent_to
);
1808 defsubr (&Scurrent_column
);
1809 defsubr (&Smove_to_column
);
1810 defsubr (&Svertical_motion
);
1811 defsubr (&Scompute_motion
);