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) \
311 int ch = STRING_CHAR (p, bytes); \
313 if (CHAR_VALID_P (ch, 0)) \
315 if (dp && VECTORP (DISP_CHAR_VECTOR (dp, ch))) \
316 width = XVECTOR (DISP_CHAR_VECTOR (dp, ch))->size; \
318 width = WIDTH_BY_CHAR_HEAD (c); \
323 wide_column = width; \
331 if (p + bytes < pend) \
333 width += 4 * (pend - (p + bytes)); \
338 DEFUN ("current-column", Fcurrent_column
, Scurrent_column
, 0, 0, 0,
339 "Return the horizontal position of point. Beginning of line is column 0.\n\
340 This is calculated by adding together the widths of all the displayed\n\
341 representations of the character between the start of the previous line\n\
342 and point. (eg control characters will have a width of 2 or 4, tabs\n\
343 will have a variable width)\n\
344 Ignores finite width of frame, which means that this function may return\n\
345 values greater than (frame-width).\n\
346 Whether the line is visible (if `selective-display' is t) has no effect;\n\
347 however, ^M is treated as end of line when `selective-display' is t.")
351 XSETFASTINT (temp
, current_column ());
355 /* Cancel any recorded value of the horizontal position. */
358 invalidate_current_column ()
360 last_known_column_point
= 0;
367 register unsigned char *ptr
, *stop
;
368 register int tab_seen
;
371 register int tab_width
= XINT (current_buffer
->tab_width
);
372 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
373 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
376 if (PT
== last_known_column_point
377 && MODIFF
== last_known_column_modified
)
378 return last_known_column
;
380 /* If the buffer has overlays, text properties,
381 or multibyte characters, use a more general algorithm. */
382 if (BUF_INTERVALS (current_buffer
)
383 || !NILP (current_buffer
->overlays_before
)
384 || !NILP (current_buffer
->overlays_after
)
386 return current_column_1 ();
388 /* Scan backwards from point to the previous newline,
389 counting width. Tab characters are the only complicated case. */
391 /* Make a pointer for decrementing through the chars before point. */
392 ptr
= BYTE_POS_ADDR (PT_BYTE
- 1) + 1;
393 /* Make a pointer to where consecutive chars leave off,
394 going backwards from point. */
397 else if (PT
<= GPT
|| BEGV
> GPT
)
402 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
404 col
= 0, tab_seen
= 0, post_tab
= 0;
410 /* We stopped either for the beginning of the buffer
412 if (ptr
== BEGV_ADDR
)
414 /* It was the gap. Jump back over it. */
417 /* Check whether that brings us to beginning of buffer. */
418 if (BEGV
>= GPT
) break;
422 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
423 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
424 else if (c
>= 040 && c
< 0177)
427 || (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
)))
435 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
442 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
447 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
451 if (ptr
== BEGV_ADDR
)
452 current_column_bol_cache
= BEGV
;
454 current_column_bol_cache
= BYTE_TO_CHAR (PTR_BYTE_POS (ptr
));
456 last_known_column
= col
;
457 last_known_column_point
= PT
;
458 last_known_column_modified
= MODIFF
;
463 /* Return the column number of position POS
464 by scanning forward from the beginning of the line.
465 This function handles characters that are invisible
466 due to text properties or overlays. */
471 register int tab_width
= XINT (current_buffer
->tab_width
);
472 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
473 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
474 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
476 /* Start the scan at the beginning of this line with column number 0. */
477 register int col
= 0;
479 int next_boundary
, next_boundary_byte
;
480 int opoint
= PT
, opoint_byte
= PT_BYTE
;
482 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
483 current_column_bol_cache
= PT
;
484 scan
= PT
, scan_byte
= PT_BYTE
;
485 SET_PT_BOTH (opoint
, opoint_byte
);
486 next_boundary
= scan
;
487 next_boundary_byte
= scan_byte
;
489 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
491 /* Scan forward to the target position. */
492 while (scan
< opoint
)
496 /* Occasionally we may need to skip invisible text. */
497 while (scan
== next_boundary
)
500 /* This updates NEXT_BOUNDARY to the next place
501 where we might need to skip more invisible text. */
502 scan
= skip_invisible (scan
, &next_boundary
, opoint
, Qnil
);
505 if (scan
!= old_scan
)
506 scan_byte
= CHAR_TO_BYTE (scan
);
507 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
510 c
= FETCH_BYTE (scan_byte
);
512 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
513 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
515 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
522 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
530 col
= col
/ tab_width
* tab_width
;
532 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
535 int bytes
, width
, wide_column
;
538 ptr
= BYTE_POS_ADDR (scan_byte
);
539 MULTIBYTE_BYTES_WIDTH (ptr
, c
, dp
);
543 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
545 else if (c
< 040 || c
>= 0177)
552 last_known_column
= col
;
553 last_known_column_point
= PT
;
554 last_known_column_modified
= MODIFF
;
559 /* Return the width in columns of the part of STRING from BEG to END.
560 If BEG is nil, that stands for the beginning of STRING.
561 If END is nil, that stands for the end of STRING. */
564 string_display_width (string
, beg
, end
)
565 Lisp_Object string
, beg
, end
;
568 register unsigned char *ptr
, *stop
;
569 register int tab_seen
;
572 register int tab_width
= XINT (current_buffer
->tab_width
);
573 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
574 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
578 e
= XSTRING (string
)->size
;
581 CHECK_NUMBER (end
, 0);
589 CHECK_NUMBER (beg
, 0);
593 /* Make a pointer for decrementing through the chars before point. */
594 ptr
= XSTRING (string
)->data
+ e
;
595 /* Make a pointer to where consecutive chars leave off,
596 going backwards from point. */
597 stop
= XSTRING (string
)->data
+ b
;
599 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
601 col
= 0, tab_seen
= 0, post_tab
= 0;
609 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
610 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
611 else if (c
>= 040 && c
< 0177)
618 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
625 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
630 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
637 DEFUN ("indent-to", Findent_to
, Sindent_to
, 1, 2, "NIndent to column: ",
638 "Indent from point with tabs and spaces until COLUMN is reached.\n\
639 Optional second argument MININUM says always do at least MININUM spaces\n\
640 even if that goes past COLUMN; by default, MININUM is zero.")
642 Lisp_Object column
, minimum
;
645 register int fromcol
;
646 register int tab_width
= XINT (current_buffer
->tab_width
);
648 CHECK_NUMBER (column
, 0);
650 XSETFASTINT (minimum
, 0);
651 CHECK_NUMBER (minimum
, 1);
653 fromcol
= current_column ();
654 mincol
= fromcol
+ XINT (minimum
);
655 if (mincol
< XINT (column
)) mincol
= XINT (column
);
657 if (fromcol
== mincol
)
658 return make_number (mincol
);
660 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
662 if (indent_tabs_mode
)
665 XSETFASTINT (n
, mincol
/ tab_width
- fromcol
/ tab_width
);
666 if (XFASTINT (n
) != 0)
668 Finsert_char (make_number ('\t'), n
, Qt
);
670 fromcol
= (mincol
/ tab_width
) * tab_width
;
674 XSETFASTINT (column
, mincol
- fromcol
);
675 Finsert_char (make_number (' '), column
, Qt
);
677 last_known_column
= mincol
;
678 last_known_column_point
= PT
;
679 last_known_column_modified
= MODIFF
;
681 XSETINT (column
, mincol
);
686 static int position_indentation
P_ ((int));
688 DEFUN ("current-indentation", Fcurrent_indentation
, Scurrent_indentation
,
690 "Return the indentation of the current line.\n\
691 This is the horizontal position of the character\n\
692 following any initial whitespace.")
696 int opoint
= PT
, opoint_byte
= PT_BYTE
;
698 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
700 XSETFASTINT (val
, position_indentation (PT_BYTE
));
701 SET_PT_BOTH (opoint
, opoint_byte
);
706 position_indentation (pos_byte
)
707 register int pos_byte
;
709 register int column
= 0;
710 register int tab_width
= XINT (current_buffer
->tab_width
);
711 register unsigned char *p
;
712 register unsigned char *stop
;
713 unsigned char *start
;
714 int next_boundary_byte
= pos_byte
;
715 int ceiling
= next_boundary_byte
;
717 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
719 p
= BYTE_POS_ADDR (pos_byte
);
720 /* STOP records the value of P at which we will need
721 to think about the gap, or about invisible text,
722 or about the end of the buffer. */
724 /* START records the starting value of P. */
732 /* If we have updated P, set POS_BYTE to match.
733 The first time we enter the loop, POS_BYTE is already right. */
735 pos_byte
= PTR_BYTE_POS (p
);
736 /* Consider the various reasons STOP might have been set here. */
737 if (pos_byte
== ZV_BYTE
)
739 if (pos_byte
== next_boundary_byte
)
742 int pos
= BYTE_TO_CHAR (pos_byte
);
743 pos
= skip_invisible (pos
, &next_boundary
, ZV
, Qnil
);
744 pos_byte
= CHAR_TO_BYTE (pos
);
745 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
747 if (pos_byte
>= ceiling
)
748 ceiling
= BUFFER_CEILING_OF (pos_byte
) + 1;
749 /* Compute the next place we need to stop and think,
750 and set STOP accordingly. */
751 stop_pos_byte
= min (ceiling
, next_boundary_byte
);
752 /* The -1 and +1 arrange to point at the first byte of gap
753 (if STOP_POS_BYTE is the position of the gap)
754 rather than at the data after the gap. */
756 stop
= BYTE_POS_ADDR (stop_pos_byte
- 1) + 1;
757 p
= BYTE_POS_ADDR (pos_byte
);
762 if (! NILP (current_buffer
->enable_multibyte_characters
))
768 column
+= tab_width
- column
% tab_width
;
771 if (ASCII_BYTE_P (p
[-1])
772 || NILP (current_buffer
->enable_multibyte_characters
))
776 pos_byte
= PTR_BYTE_POS (p
- 1);
777 c
= FETCH_MULTIBYTE_CHAR (pos_byte
);
778 if (CHAR_HAS_CATEGORY (c
, ' '))
782 p
= BYTE_POS_ADDR (pos_byte
);
791 /* Test whether the line beginning at POS is indented beyond COLUMN.
792 Blank lines are treated as if they had the same indentation as the
796 indented_beyond_p (pos
, pos_byte
, column
)
797 int pos
, pos_byte
, column
;
800 int opoint
= PT
, opoint_byte
= PT_BYTE
;
802 SET_PT_BOTH (pos
, pos_byte
);
803 while (PT
> BEGV
&& FETCH_BYTE (PT_BYTE
) == '\n')
804 scan_newline (PT
- 1, PT_BYTE
- 1, BEGV
, BEGV_BYTE
, -1, 0);
806 val
= position_indentation (PT_BYTE
);
807 SET_PT_BOTH (opoint
, opoint_byte
);
808 return val
>= column
;
811 DEFUN ("move-to-column", Fmove_to_column
, Smove_to_column
, 1, 2, "p",
812 "Move point to column COLUMN in the current line.\n\
813 The column of a character is calculated by adding together the widths\n\
814 as displayed of the previous characters in the line.\n\
815 This function ignores line-continuation;\n\
816 there is no upper limit on the column number a character can have\n\
817 and horizontal scrolling has no effect.\n\
819 If specified column is within a character, point goes after that character.\n\
820 If it's past end of line, point goes to end of line.\n\n\
821 A non-nil second (optional) argument FORCE means,\n\
822 if COLUMN is in the middle of a tab character, change it to spaces.\n\
823 In addition, if FORCE is t, and the line is too short\n\
824 to reach column COLUMN, add spaces/tabs to get there.\n\
826 The return value is the current column.")
828 Lisp_Object column
, force
;
831 register int col
= current_column ();
834 register int tab_width
= XINT (current_buffer
->tab_width
);
835 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
836 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
837 register int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
844 int pos_byte
, end_byte
, next_boundary_byte
;
846 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
847 CHECK_NATNUM (column
, 0);
848 goal
= XINT (column
);
855 next_boundary_byte
= PT_BYTE
;
857 /* If we're starting past the desired column,
858 back up to beginning of line and scan from there. */
862 pos
= current_column_bol_cache
;
863 pos_byte
= CHAR_TO_BYTE (pos
);
869 while (pos
== next_boundary
)
872 pos
= skip_invisible (pos
, &next_boundary
, end
, Qnil
);
874 pos_byte
= CHAR_TO_BYTE (pos
);
875 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
880 /* Test reaching the goal column. We do this after skipping
881 invisible characters, so that we put point before the
882 character on which the cursor will appear. */
886 c
= FETCH_BYTE (pos_byte
);
888 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
889 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
891 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
898 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
906 col
= col
/ tab_width
* tab_width
;
908 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
910 else if (c
< 040 || c
== 0177)
914 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
916 /* Start of multi-byte form. */
918 int bytes
, width
, wide_column
;
921 ptr
= BYTE_POS_ADDR (pos_byte
);
922 MULTIBYTE_BYTES_WIDTH (ptr
, c
, dp
);
931 SET_PT_BOTH (pos
, pos_byte
);
933 /* If a tab char made us overshoot, change it to spaces
934 and scan through it again. */
935 if (!NILP (force
) && col
> goal
&& c
== '\t' && prev_col
< goal
)
937 int old_point
, old_point_byte
;
939 del_range (PT
- 1, PT
);
940 Findent_to (make_number (goal
), Qnil
);
942 old_point_byte
= PT_BYTE
;
943 Findent_to (make_number (col
), Qnil
);
944 SET_PT_BOTH (old_point
, old_point_byte
);
945 /* Set the last_known... vars consistently. */
949 /* If line ends prematurely, add space to the end. */
950 if (col
< goal
&& EQ (force
, Qt
))
951 Findent_to (make_number (col
= goal
), Qnil
);
953 last_known_column
= col
;
954 last_known_column_point
= PT
;
955 last_known_column_modified
= MODIFF
;
957 XSETFASTINT (val
, col
);
961 /* compute_motion: compute buffer posn given screen posn and vice versa */
963 struct position val_compute_motion
;
965 /* Scan the current buffer forward from offset FROM, pretending that
966 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
967 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
968 and return the ending buffer position and screen location. If we
969 can't hit the requested column exactly (because of a tab or other
970 multi-column character), overshoot.
972 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
973 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
974 earlier call to compute_motion. The other common case is that FROMHPOS
975 is zero and FROM is a position that "belongs" at column zero, but might
976 be shifted by overlay strings; in this case DID_MOTION should be 0.
978 WIDTH is the number of columns available to display text;
979 compute_motion uses this to handle continuation lines and such.
980 HSCROLL is the number of columns not being displayed at the left
981 margin; this is usually taken from a window's hscroll member.
982 TAB_OFFSET is the number of columns of the first tab that aren't
983 being displayed, perhaps because of a continuation line or
986 compute_motion returns a pointer to a struct position. The bufpos
987 member gives the buffer position at the end of the scan, and hpos
988 and vpos give its cartesian location. prevhpos is the column at
989 which the character before bufpos started, and contin is non-zero
990 if we reached the current line by continuing the previous.
992 Note that FROMHPOS and TOHPOS should be expressed in real screen
993 columns, taking HSCROLL and the truncation glyph at the left margin
994 into account. That is, beginning-of-line moves you to the hpos
995 -HSCROLL + (HSCROLL > 0).
997 For example, to find the buffer position of column COL of line LINE
998 of a certain window, pass the window's starting location as FROM
999 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
1000 Pass the buffer's ZV as TO, to limit the scan to the end of the
1001 visible section of the buffer, and pass LINE and COL as TOVPOS and
1004 When displaying in window w, a typical formula for WIDTH is:
1007 - (has_vertical_scroll_bars
1008 ? FRAME_SCROLL_BAR_COLS (XFRAME (window->frame))
1009 : (window_width + window_left != frame_width))
1012 window_width is XFASTINT (w->width),
1013 window_left is XFASTINT (w->left),
1014 has_vertical_scroll_bars is
1015 FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (WINDOW_FRAME (window)))
1016 and frame_width = FRAME_WIDTH (XFRAME (window->frame))
1018 Or you can let window_internal_width do this all for you, and write:
1019 window_internal_width (w) - 1
1021 The `-1' accounts for the continuation-line backslashes; the rest
1022 accounts for window borders if the window is split horizontally, and
1023 the scroll bars if they are turned on. */
1026 compute_motion (from
, fromvpos
, fromhpos
, did_motion
, to
, tovpos
, tohpos
, width
, hscroll
, tab_offset
, win
)
1027 int from
, fromvpos
, fromhpos
, to
, tovpos
, tohpos
;
1030 int hscroll
, tab_offset
;
1033 register int hpos
= fromhpos
;
1034 register int vpos
= fromvpos
;
1039 register int tab_width
= XFASTINT (current_buffer
->tab_width
);
1040 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
1041 register struct Lisp_Char_Table
*dp
= window_display_table (win
);
1043 = (INTEGERP (current_buffer
->selective_display
)
1044 ? XINT (current_buffer
->selective_display
)
1045 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1048 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
1049 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
: 0);
1050 /* The next location where the `invisible' property changes, or an
1051 overlay starts or ends. */
1052 int next_boundary
= from
;
1054 /* For computing runs of characters with similar widths.
1055 Invariant: width_run_width is zero, or all the characters
1056 from width_run_start to width_run_end have a fixed width of
1058 int width_run_start
= from
;
1059 int width_run_end
= from
;
1060 int width_run_width
= 0;
1061 Lisp_Object
*width_table
;
1064 /* The next buffer pos where we should consult the width run cache. */
1065 int next_width_run
= from
;
1068 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
1069 /* If previous char scanned was a wide character,
1070 this is the column where it ended. Otherwise, this is 0. */
1071 int wide_column_end_hpos
= 0;
1072 int prev_pos
; /* Previous buffer position. */
1073 int prev_pos_byte
; /* Previous buffer position. */
1074 int contin_hpos
; /* HPOS of last column of continued line. */
1075 int prev_tab_offset
; /* Previous tab offset. */
1077 XSETBUFFER (buffer
, current_buffer
);
1078 XSETWINDOW (window
, win
);
1080 width_run_cache_on_off ();
1081 if (dp
== buffer_display_table ())
1082 width_table
= (VECTORP (current_buffer
->width_table
)
1083 ? XVECTOR (current_buffer
->width_table
)->contents
1086 /* If the window has its own display table, we can't use the width
1087 run cache, because that's based on the buffer's display table. */
1090 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
1092 pos
= prev_pos
= from
;
1093 pos_byte
= prev_pos_byte
= CHAR_TO_BYTE (from
);
1095 prev_tab_offset
= tab_offset
;
1098 while (pos
== next_boundary
)
1103 /* Don't skip invisible if we are already at the margin. */
1104 if (vpos
> tovpos
|| vpos
== tovpos
&& hpos
>= tohpos
)
1106 if (contin_hpos
&& prev_hpos
== 0
1108 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1109 { /* Line breaks because we can't put the character at the
1110 previous line any more. It is not the multi-column
1111 character continued in middle. Go back to previous
1112 buffer position, screen position, and set tab offset
1113 to previous value. It's the beginning of the
1116 pos_byte
= prev_pos_byte
;
1118 tab_offset
= prev_tab_offset
;
1123 /* If the caller says that the screen position came from an earlier
1124 call to compute_motion, then we've already accounted for the
1125 overlay strings at point. This is only true the first time
1126 through, so clear the flag after testing it. */
1128 /* We need to skip past the overlay strings. Currently those
1129 strings must not contain TAB;
1130 if we want to relax that restriction, something will have
1131 to be changed here. */
1133 unsigned char *ovstr
;
1134 int ovlen
= overlay_strings (pos
, win
, &ovstr
);
1135 hpos
+= ((multibyte
&& ovlen
> 0)
1136 ? strwidth (ovstr
, ovlen
) : ovlen
);
1143 /* Advance POS past invisible characters
1144 (but not necessarily all that there are here),
1145 and store in next_boundary the next position where
1146 we need to call skip_invisible. */
1147 newpos
= skip_invisible (pos
, &next_boundary
, to
, window
);
1151 pos
= min (to
, newpos
);
1155 if (newpos
!= pos_here
)
1158 pos_byte
= CHAR_TO_BYTE (pos
);
1162 /* Handle right margin. */
1163 /* Note on a wide-column character.
1165 Characters are classified into the following three categories
1166 according to the width (columns occupied on screen).
1168 (1) single-column character: ex. `a'
1169 (2) multi-column character: ex. `^A', TAB, `\033'
1170 (3) wide-column character: ex. Japanese character, Chinese character
1171 (In the following example, `W_' stands for them.)
1173 Multi-column characters can be divided around the right margin,
1174 but wide-column characters cannot.
1178 (*) The cursor is placed on the next character after the point.
1182 j ^---- next after the point
1183 ^--- next char. after the point.
1185 In case of sigle-column character
1189 033 ^---- next after the point, next char. after the point.
1191 In case of multi-column character
1195 W_ ^---- next after the point
1196 ^---- next char. after the point.
1198 In case of wide-column character
1200 The problem here is continuation at a wide-column character.
1201 In this case, the line may shorter less than WIDTH.
1202 And we find the continuation AFTER it occurs.
1209 || (truncate_partial_width_windows
1210 && width
+ 1 < FRAME_WIDTH (XFRAME (WINDOW_FRAME (win
))))
1211 || !NILP (current_buffer
->truncate_lines
))
1213 /* Truncating: skip to newline, unless we are already past
1214 TO (we need to go back below). */
1217 pos
= find_before_next_newline (pos
, to
, 1);
1218 pos_byte
= CHAR_TO_BYTE (pos
);
1220 /* If we just skipped next_boundary,
1221 loop around in the main while
1223 if (pos
>= next_boundary
)
1224 next_boundary
= pos
+ 1;
1226 prev_tab_offset
= tab_offset
;
1232 /* Remember the previous value. */
1233 prev_tab_offset
= tab_offset
;
1235 if (wide_column_end_hpos
> width
)
1238 tab_offset
+= prev_hpos
;
1242 tab_offset
+= width
;
1246 contin_hpos
= prev_hpos
;
1251 /* Stop if past the target buffer position or screen position. */
1254 /* Go back to the previous position. */
1256 pos_byte
= prev_pos_byte
;
1258 tab_offset
= prev_tab_offset
;
1260 /* NOTE on contin_hpos, hpos, and prev_hpos.
1264 W_ ^---- contin_hpos
1270 if (contin_hpos
&& prev_hpos
== 0
1271 && contin_hpos
< width
&& !wide_column_end_hpos
)
1273 /* Line breaking occurs in the middle of multi-column
1274 character. Go back to previous line. */
1279 /* If previous character is NEWLINE,
1280 set VPOS back to previous line */
1285 if (vpos
> tovpos
|| vpos
== tovpos
&& hpos
>= tohpos
)
1287 if (contin_hpos
&& prev_hpos
== 0
1289 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1290 { /* Line breaks because we can't put the character at the
1291 previous line any more. It is not the multi-column
1292 character continued in middle. Go back to previous
1293 buffer position, screen position, and set tab offset
1294 to previous value. It's the beginning of the
1297 pos_byte
= prev_pos_byte
;
1299 tab_offset
= prev_tab_offset
;
1303 if (pos
== ZV
) /* We cannot go beyond ZV. Stop here. */
1308 prev_pos_byte
= pos_byte
;
1309 wide_column_end_hpos
= 0;
1311 /* Consult the width run cache to see if we can avoid inspecting
1312 the text character-by-character. */
1313 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
1317 = region_cache_forward (current_buffer
,
1318 current_buffer
->width_run_cache
,
1321 /* A width of zero means the character's width varies (like
1322 a tab), is meaningless (like a newline), or we just don't
1323 want to skip over it for some other reason. */
1324 if (common_width
!= 0)
1328 /* Don't go past the final buffer posn the user
1333 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1335 /* Don't go past the final horizontal position the user
1337 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
1339 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
1340 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1343 /* Don't go past the margin. */
1344 if (run_end_hpos
>= width
)
1346 run_end
= pos
+ (width
- hpos
) / common_width
;
1347 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1350 hpos
= run_end_hpos
;
1352 prev_hpos
= hpos
- common_width
;
1356 pos_byte
= CHAR_TO_BYTE (pos
);
1360 next_width_run
= run_end
+ 1;
1363 /* We have to scan the text character-by-character. */
1366 c
= FETCH_BYTE (pos_byte
);
1369 /* Perhaps add some info to the width_run_cache. */
1370 if (current_buffer
->width_run_cache
)
1372 /* Is this character part of the current run? If so, extend
1374 if (pos
- 1 == width_run_end
1375 && XFASTINT (width_table
[c
]) == width_run_width
)
1376 width_run_end
= pos
;
1378 /* The previous run is over, since this is a character at a
1379 different position, or a different width. */
1382 /* Have we accumulated a run to put in the cache?
1383 (Currently, we only cache runs of width == 1). */
1384 if (width_run_start
< width_run_end
1385 && width_run_width
== 1)
1386 know_region_cache (current_buffer
,
1387 current_buffer
->width_run_cache
,
1388 width_run_start
, width_run_end
);
1390 /* Start recording a new width run. */
1391 width_run_width
= XFASTINT (width_table
[c
]);
1392 width_run_start
= pos
- 1;
1393 width_run_end
= pos
;
1398 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
1399 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1400 hpos
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
1401 else if (c
>= 040 && c
< 0177)
1405 int tem
= (hpos
+ tab_offset
+ hscroll
- (hscroll
> 0)) % tab_width
;
1408 hpos
+= tab_width
- tem
;
1413 && indented_beyond_p (pos
, pos_byte
, selective
))
1415 /* If (pos == to), we don't have to take care of
1416 selective display. */
1419 /* Skip any number of invisible lines all at once */
1422 pos
= find_before_next_newline (pos
, to
, 1);
1425 pos_byte
= CHAR_TO_BYTE (pos
);
1428 && indented_beyond_p (pos
, pos_byte
, selective
));
1429 /* Allow for the " ..." that is displayed for them. */
1432 hpos
+= selective_rlen
;
1436 DEC_BOTH (pos
, pos_byte
);
1437 /* We have skipped the invis text, but not the
1443 /* A visible line. */
1447 /* Count the truncation glyph on column 0 */
1454 else if (c
== CR
&& selective
< 0)
1456 /* In selective display mode,
1457 everything from a ^M to the end of the line is invisible.
1458 Stop *before* the real newline. */
1461 pos
= find_before_next_newline (pos
, to
, 1);
1462 pos_byte
= CHAR_TO_BYTE (pos
);
1464 /* If we just skipped next_boundary,
1465 loop around in the main while
1467 if (pos
> next_boundary
)
1468 next_boundary
= pos
;
1469 /* Allow for the " ..." that is displayed for them. */
1472 hpos
+= selective_rlen
;
1477 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
1479 /* Start of multi-byte form. */
1481 int bytes
, width
, wide_column
;
1483 pos_byte
--; /* rewind POS_BYTE */
1484 ptr
= BYTE_POS_ADDR (pos_byte
);
1485 MULTIBYTE_BYTES_WIDTH (ptr
, c
, dp
);
1488 wide_column_end_hpos
= hpos
+ wide_column
;
1492 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
1498 /* Remember any final width run in the cache. */
1499 if (current_buffer
->width_run_cache
1500 && width_run_width
== 1
1501 && width_run_start
< width_run_end
)
1502 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
1503 width_run_start
, width_run_end
);
1505 val_compute_motion
.bufpos
= pos
;
1506 val_compute_motion
.bytepos
= pos_byte
;
1507 val_compute_motion
.hpos
= hpos
;
1508 val_compute_motion
.vpos
= vpos
;
1509 if (contin_hpos
&& prev_hpos
== 0)
1510 val_compute_motion
.prevhpos
= contin_hpos
;
1512 val_compute_motion
.prevhpos
= prev_hpos
;
1513 /* We alalways handle all of them here; none of them remain to do. */
1514 val_compute_motion
.ovstring_chars_done
= 0;
1516 /* Nonzero if have just continued a line */
1517 val_compute_motion
.contin
= (contin_hpos
&& prev_hpos
== 0);
1519 return &val_compute_motion
;
1523 #if 0 /* The doc string is too long for some compilers,
1524 but make-docfile can find it in this comment. */
1525 DEFUN ("compute-motion", Ffoo
, Sfoo
, 7, 7, 0,
1526 "Scan through the current buffer, calculating screen position.\n\
1527 Scan the current buffer forward from offset FROM,\n\
1528 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--\n\
1529 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--\n\
1530 and return the ending buffer position and screen location.\n\
1532 There are three additional arguments:\n\
1534 WIDTH is the number of columns available to display text;\n\
1535 this affects handling of continuation lines.\n\
1536 This is usually the value returned by `window-width', less one (to allow\n\
1537 for the continuation glyph).\n\
1539 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).\n\
1540 HSCROLL is the number of columns not being displayed at the left\n\
1541 margin; this is usually taken from a window's hscroll member.\n\
1542 TAB-OFFSET is the number of columns of the first tab that aren't\n\
1543 being displayed, perhaps because the line was continued within it.\n\
1544 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.\n\
1546 WINDOW is the window to operate on. It is used to choose the display table;\n\
1547 if it is showing the current buffer, it is used also for\n\
1548 deciding which overlay properties apply.\n\
1549 Note that `compute-motion' always operates on the current buffer.\n\
1551 The value is a list of five elements:\n\
1552 (POS HPOS VPOS PREVHPOS CONTIN)\n\
1553 POS is the buffer position where the scan stopped.\n\
1554 VPOS is the vertical position where the scan stopped.\n\
1555 HPOS is the horizontal position where the scan stopped.\n\
1557 PREVHPOS is the horizontal position one character back from POS.\n\
1558 CONTIN is t if a line was continued after (or within) the previous character.\n\
1560 For example, to find the buffer position of column COL of line LINE\n\
1561 of a certain window, pass the window's starting location as FROM\n\
1562 and the window's upper-left coordinates as FROMPOS.\n\
1563 Pass the buffer's (point-max) as TO, to limit the scan to the end of the\n\
1564 visible section of the buffer, and pass LINE and COL as TOPOS.")
1565 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1568 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
1570 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1571 Lisp_Object from
, frompos
, to
, topos
;
1572 Lisp_Object width
, offsets
, window
;
1574 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
, contin
;
1575 struct position
*pos
;
1576 int hscroll
, tab_offset
;
1578 CHECK_NUMBER_COERCE_MARKER (from
, 0);
1579 CHECK_CONS (frompos
, 0);
1580 CHECK_NUMBER (XCONS (frompos
)->car
, 0);
1581 CHECK_NUMBER (XCONS (frompos
)->cdr
, 0);
1582 CHECK_NUMBER_COERCE_MARKER (to
, 0);
1583 CHECK_CONS (topos
, 0);
1584 CHECK_NUMBER (XCONS (topos
)->car
, 0);
1585 CHECK_NUMBER (XCONS (topos
)->cdr
, 0);
1586 CHECK_NUMBER (width
, 0);
1587 if (!NILP (offsets
))
1589 CHECK_CONS (offsets
, 0);
1590 CHECK_NUMBER (XCONS (offsets
)->car
, 0);
1591 CHECK_NUMBER (XCONS (offsets
)->cdr
, 0);
1592 hscroll
= XINT (XCONS (offsets
)->car
);
1593 tab_offset
= XINT (XCONS (offsets
)->cdr
);
1596 hscroll
= tab_offset
= 0;
1599 window
= Fselected_window ();
1601 CHECK_LIVE_WINDOW (window
, 0);
1603 if (XINT (from
) < BEGV
|| XINT (from
) > ZV
)
1604 args_out_of_range_3 (from
, make_number (BEGV
), make_number (ZV
));
1605 if (XINT (to
) < BEGV
|| XINT (to
) > ZV
)
1606 args_out_of_range_3 (to
, make_number (BEGV
), make_number (ZV
));
1608 pos
= compute_motion (XINT (from
), XINT (XCONS (frompos
)->cdr
),
1609 XINT (XCONS (frompos
)->car
), 0,
1610 XINT (to
), XINT (XCONS (topos
)->cdr
),
1611 XINT (XCONS (topos
)->car
),
1612 XINT (width
), hscroll
, tab_offset
,
1615 XSETFASTINT (bufpos
, pos
->bufpos
);
1616 XSETINT (hpos
, pos
->hpos
);
1617 XSETINT (vpos
, pos
->vpos
);
1618 XSETINT (prevhpos
, pos
->prevhpos
);
1620 return Fcons (bufpos
,
1624 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
1628 /* Fvertical_motion and vmotion */
1629 struct position val_vmotion
;
1632 vmotion (from
, vtarget
, w
)
1633 register int from
, vtarget
;
1636 int width
= window_internal_width (w
) - 1;
1637 int hscroll
= XINT (w
->hscroll
);
1638 struct position pos
;
1639 /* vpos is cumulative vertical position, changed as from is changed */
1640 register int vpos
= 0;
1641 Lisp_Object prevline
;
1644 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1646 = (INTEGERP (current_buffer
->selective_display
)
1647 ? XINT (current_buffer
->selective_display
)
1648 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1652 /* This is the object we use for fetching character properties. */
1653 Lisp_Object text_prop_object
;
1655 XSETWINDOW (window
, w
);
1657 #if NO_PROMPT_IN_BUFFER
1658 /* The omission of the clause
1659 && marker_position (w->start) == BEG
1660 here is deliberate; I think we want to measure from the prompt
1661 position even if the minibuffer window has scrolled. */
1662 if (EQ (window
, minibuf_window
))
1664 if (minibuf_prompt_width
== 0 && STRINGP (minibuf_prompt
))
1665 minibuf_prompt_width
1666 = string_display_width (minibuf_prompt
, Qnil
, Qnil
);
1668 start_hpos
= minibuf_prompt_width
;
1670 #endif /* NO_PROMPT_IN_BUFFER */
1672 /* If the window contains this buffer, use it for getting text properties.
1673 Otherwise use the current buffer as arg for doing that. */
1674 if (EQ (w
->buffer
, Fcurrent_buffer ()))
1675 text_prop_object
= window
;
1677 text_prop_object
= Fcurrent_buffer ();
1679 if (vpos
>= vtarget
)
1681 /* To move upward, go a line at a time until
1682 we have gone at least far enough. */
1686 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1688 Lisp_Object propval
;
1690 XSETFASTINT (prevline
, find_next_newline_no_quit (from
- 1, -1));
1691 while (XFASTINT (prevline
) > BEGV
1693 && indented_beyond_p (XFASTINT (prevline
),
1694 CHAR_TO_BYTE (XFASTINT (prevline
)),
1696 #ifdef USE_TEXT_PROPERTIES
1697 /* watch out for newlines with `invisible' property */
1698 || (propval
= Fget_char_property (prevline
,
1701 TEXT_PROP_MEANS_INVISIBLE (propval
))
1704 XSETFASTINT (prevline
,
1705 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1707 pos
= *compute_motion (XFASTINT (prevline
), 0,
1708 lmargin
+ (XFASTINT (prevline
) == BEG
1712 /* Don't care for VPOS... */
1713 1 << (BITS_PER_SHORT
- 1),
1715 1 << (BITS_PER_SHORT
- 1),
1717 /* This compensates for start_hpos
1718 so that a tab as first character
1719 still occupies 8 columns. */
1720 (XFASTINT (prevline
) == BEG
1725 from
= XFASTINT (prevline
);
1728 /* If we made exactly the desired vertical distance,
1729 or if we hit beginning of buffer,
1730 return point found */
1731 if (vpos
>= vtarget
)
1733 val_vmotion
.bufpos
= from
;
1734 val_vmotion
.bytepos
= CHAR_TO_BYTE (from
);
1735 val_vmotion
.vpos
= vpos
;
1736 val_vmotion
.hpos
= lmargin
;
1737 val_vmotion
.contin
= 0;
1738 val_vmotion
.prevhpos
= 0;
1739 val_vmotion
.ovstring_chars_done
= 0;
1740 val_vmotion
.tab_offset
= 0; /* For accumulating tab offset. */
1741 return &val_vmotion
;
1744 /* Otherwise find the correct spot by moving down */
1746 /* Moving downward is simple, but must calculate from beg of line
1747 to determine hpos of starting point */
1748 from_byte
= CHAR_TO_BYTE (from
);
1749 if (from
> BEGV
&& FETCH_BYTE (from_byte
- 1) != '\n')
1751 Lisp_Object propval
;
1753 XSETFASTINT (prevline
, find_next_newline_no_quit (from
, -1));
1754 while (XFASTINT (prevline
) > BEGV
1756 && indented_beyond_p (XFASTINT (prevline
),
1757 CHAR_TO_BYTE (XFASTINT (prevline
)),
1759 #ifdef USE_TEXT_PROPERTIES
1760 /* watch out for newlines with `invisible' property */
1761 || (propval
= Fget_char_property (prevline
, Qinvisible
,
1763 TEXT_PROP_MEANS_INVISIBLE (propval
))
1766 XSETFASTINT (prevline
,
1767 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1769 pos
= *compute_motion (XFASTINT (prevline
), 0,
1770 lmargin
+ (XFASTINT (prevline
) == BEG
1774 /* Don't care for VPOS... */
1775 1 << (BITS_PER_SHORT
- 1),
1777 1 << (BITS_PER_SHORT
- 1),
1779 (XFASTINT (prevline
) == BEG
? -start_hpos
: 0),
1785 pos
.hpos
= lmargin
+ (from
== BEG
? start_hpos
: 0);
1790 return compute_motion (from
, vpos
, pos
.hpos
, did_motion
,
1791 ZV
, vtarget
, - (1 << (BITS_PER_SHORT
- 1)),
1793 pos
.tab_offset
- (from
== BEG
? start_hpos
: 0),
1797 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
1798 "Move point to start of the screen line LINES lines down.\n\
1799 If LINES is negative, this means moving up.\n\
1801 This function is an ordinary cursor motion function\n\
1802 which calculates the new position based on how text would be displayed.\n\
1803 The new position may be the start of a line,\n\
1804 or just the start of a continuation line.\n\
1805 The function returns number of screen lines moved over;\n\
1806 that usually equals LINES, but may be closer to zero\n\
1807 if beginning or end of buffer was reached.\n\
1809 The optional second argument WINDOW specifies the window to use for\n\
1810 parameters such as width, horizontal scrolling, and so on.\n\
1811 The default is to use the selected window's parameters.\n\
1813 `vertical-motion' always uses the current buffer,\n\
1814 regardless of which buffer is displayed in WINDOW.\n\
1815 This is consistent with other cursor motion functions\n\
1816 and makes it possible to use `vertical-motion' in any buffer,\n\
1817 whether or not it is currently displayed in some window.")
1819 Lisp_Object lines
, window
;
1823 struct buffer
*old
, *b
;
1826 CHECK_NUMBER (lines
, 0);
1827 if (! NILP (window
))
1828 CHECK_WINDOW (window
, 0);
1830 window
= selected_window
;
1832 w
= XWINDOW (window
);
1833 b
= XBUFFER (w
->buffer
);
1834 if (b
!= current_buffer
)
1836 old
= current_buffer
;
1837 set_buffer_internal_1 (b
);
1842 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
1843 start_display (&it
, w
, pt
);
1844 move_it_by_lines (&it
, XINT (lines
), 0);
1845 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
1848 set_buffer_internal_1 (old
);
1850 return make_number (it
.vpos
);
1855 /* file's initialization. */
1860 DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode
,
1861 "*Indentation can insert tabs if this is non-nil.\n\
1862 Setting this variable automatically makes it local to the current buffer.");
1863 indent_tabs_mode
= 1;
1865 defsubr (&Scurrent_indentation
);
1866 defsubr (&Sindent_to
);
1867 defsubr (&Scurrent_column
);
1868 defsubr (&Smove_to_column
);
1869 defsubr (&Svertical_motion
);
1870 defsubr (&Scompute_motion
);