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. */
34 #include "intervals.h"
35 #include "region-cache.h"
37 /* Indentation can insert tabs if this is non-zero;
38 otherwise always uses spaces */
41 #define min(a, b) ((a) < (b) ? (a) : (b))
42 #define max(a, b) ((a) > (b) ? (a) : (b))
46 /* These three values memoize the current column to avoid recalculation */
47 /* Some things in set last_known_column_point to -1
48 to mark the memoized value as invalid */
49 /* Last value returned by current_column */
50 int last_known_column
;
51 /* Value of point when current_column was called */
52 int last_known_column_point
;
53 /* Value of MODIFF when current_column was called */
54 int last_known_column_modified
;
56 static int current_column_1 ();
57 static int position_indentation ();
59 /* Cache of beginning of line found by the last call of
61 int current_column_bol_cache
;
63 /* Get the display table to use for the current buffer. */
65 struct Lisp_Char_Table
*
66 buffer_display_table ()
70 thisbuf
= current_buffer
->display_table
;
71 if (DISP_TABLE_P (thisbuf
))
72 return XCHAR_TABLE (thisbuf
);
73 if (DISP_TABLE_P (Vstandard_display_table
))
74 return XCHAR_TABLE (Vstandard_display_table
);
78 /* Width run cache considerations. */
80 /* Return the width of character C under display table DP. */
83 character_width (c
, dp
)
85 struct Lisp_Char_Table
*dp
;
89 /* These width computations were determined by examining the cases
90 in display_text_line. */
92 /* Everything can be handled by the display table, if it's
93 present and the element is right. */
94 if (dp
&& (elt
= DISP_CHAR_VECTOR (dp
, c
), VECTORP (elt
)))
95 return XVECTOR (elt
)->size
;
97 /* Some characters are special. */
98 if (c
== '\n' || c
== '\t' || c
== '\015')
101 /* Printing characters have width 1. */
102 else if (c
>= 040 && c
< 0177)
105 /* Everybody else (control characters, metacharacters) has other
106 widths. We could return their actual widths here, but they
107 depend on things like ctl_arrow and crud like that, and they're
108 not very common at all. So we'll just claim we don't know their
114 /* Return true iff the display table DISPTAB specifies the same widths
115 for characters as WIDTHTAB. We use this to decide when to
116 invalidate the buffer's width_run_cache. */
118 disptab_matches_widthtab (disptab
, widthtab
)
119 struct Lisp_Char_Table
*disptab
;
120 struct Lisp_Vector
*widthtab
;
124 if (widthtab
->size
!= 256)
127 for (i
= 0; i
< 256; i
++)
128 if (character_width (i
, disptab
)
129 != XFASTINT (widthtab
->contents
[i
]))
135 /* Recompute BUF's width table, using the display table DISPTAB. */
137 recompute_width_table (buf
, disptab
)
139 struct Lisp_Char_Table
*disptab
;
142 struct Lisp_Vector
*widthtab
;
144 if (!VECTORP (buf
->width_table
))
145 buf
->width_table
= Fmake_vector (make_number (256), make_number (0));
146 widthtab
= XVECTOR (buf
->width_table
);
147 if (widthtab
->size
!= 256)
150 for (i
= 0; i
< 256; i
++)
151 XSETFASTINT (widthtab
->contents
[i
], character_width (i
, disptab
));
154 /* Allocate or free the width run cache, as requested by the current
155 state of current_buffer's cache_long_line_scans variable. */
157 width_run_cache_on_off ()
159 if (NILP (current_buffer
->cache_long_line_scans
)
160 /* And, for the moment, this feature doesn't work on multibyte
162 || !NILP (current_buffer
->enable_multibyte_characters
))
164 /* It should be off. */
165 if (current_buffer
->width_run_cache
)
167 free_region_cache (current_buffer
->width_run_cache
);
168 current_buffer
->width_run_cache
= 0;
169 current_buffer
->width_table
= Qnil
;
174 /* It should be on. */
175 if (current_buffer
->width_run_cache
== 0)
177 current_buffer
->width_run_cache
= new_region_cache ();
178 recompute_width_table (current_buffer
, buffer_display_table ());
184 /* Skip some invisible characters starting from POS.
185 This includes characters invisible because of text properties
186 and characters invisible because of overlays.
188 If position POS is followed by invisible characters,
189 skip some of them and return the position after them.
190 Otherwise return POS itself.
192 Set *NEXT_BOUNDARY_P to the next position at which
193 it will be necessary to call this function again.
195 Don't scan past TO, and don't set *NEXT_BOUNDARY_P
196 to a value greater than TO.
198 If WINDOW is non-nil, and this buffer is displayed in WINDOW,
199 take account of overlays that apply only in WINDOW.
201 We don't necessarily skip all the invisible characters after POS
202 because that could take a long time. We skip a reasonable number
203 which can be skipped quickly. If there might be more invisible
204 characters immediately following, then *NEXT_BOUNDARY_P
205 will equal the return value. */
208 skip_invisible (pos
, next_boundary_p
, to
, window
)
210 int *next_boundary_p
;
214 Lisp_Object prop
, position
, overlay_limit
, proplimit
;
218 XSETFASTINT (position
, pos
);
219 XSETBUFFER (buffer
, current_buffer
);
221 /* Give faster response for overlay lookup near POS. */
222 recenter_overlay_lists (current_buffer
, pos
);
224 /* We must not advance farther than the next overlay change.
225 The overlay change might change the invisible property;
226 or there might be overlay strings to be displayed there. */
227 overlay_limit
= Fnext_overlay_change (position
);
228 /* As for text properties, this gives a lower bound
229 for where the invisible text property could change. */
230 proplimit
= Fnext_property_change (position
, buffer
, Qt
);
231 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
232 proplimit
= overlay_limit
;
233 /* PROPLIMIT is now a lower bound for the next change
234 in invisible status. If that is plenty far away,
235 use that lower bound. */
236 if (XFASTINT (proplimit
) > pos
+ 100 || XFASTINT (proplimit
) >= to
)
237 *next_boundary_p
= XFASTINT (proplimit
);
238 /* Otherwise, scan for the next `invisible' property change. */
241 /* Don't scan terribly far. */
242 XSETFASTINT (proplimit
, min (pos
+ 100, to
));
243 /* No matter what. don't go past next overlay change. */
244 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
245 proplimit
= overlay_limit
;
246 end
= XFASTINT (Fnext_single_property_change (position
, Qinvisible
,
249 /* Don't put the boundary in the middle of multibyte form if
250 there is no actual property change. */
252 && !NILP (current_buffer
->enable_multibyte_characters
)
254 while (pos
< end
&& !CHAR_HEAD_P (POS_ADDR (end
)))
257 *next_boundary_p
= end
;
259 /* if the `invisible' property is set, we can skip to
260 the next property change */
261 if (!NILP (window
) && EQ (XWINDOW (window
)->buffer
, buffer
))
262 prop
= Fget_char_property (position
, Qinvisible
, window
);
264 prop
= Fget_char_property (position
, Qinvisible
, buffer
);
265 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
266 return *next_boundary_p
;
270 /* If a composition starts at POS/POS_BYTE and it doesn't stride over
271 POINT, set *LEN / *LEN_BYTE to the character and byte lengths, *WIDTH
272 to the width, and return 1. Otherwise, return 0. */
275 check_composition (pos
, pos_byte
, point
, len
, len_byte
, width
)
276 int pos
, pos_byte
, point
;
277 int *len
, *len_byte
, *width
;
283 if (! find_composition (pos
, -1, &start
, &end
, &prop
, Qnil
)
284 || pos
!= start
|| point
< end
)
286 if ((id
= get_composition_id (pos
, pos_byte
, end
- pos
, prop
, Qnil
)) < 0)
289 *len
= COMPOSITION_LENGTH (prop
);
290 *len_byte
= CHAR_TO_BYTE (end
) - pos_byte
;
291 *width
= composition_table
[id
]->width
;
295 /* Set variables WIDTH and BYTES for a multibyte sequence starting at P.
297 DP is a display table or NULL.
299 This macro is used in current_column_1, Fmove_to_column, and
302 #define MULTIBYTE_BYTES_WIDTH(p, dp) \
307 c = STRING_CHAR_AND_LENGTH (p, MAX_MULTIBYTE_LENGTH, bytes); \
308 if (BYTES_BY_CHAR_HEAD (*p) != bytes) \
312 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c))) \
313 width = XVECTOR (DISP_CHAR_VECTOR (dp, c))->size; \
315 width = WIDTH_BY_CHAR_HEAD (*p); \
317 wide_column = width; \
321 DEFUN ("current-column", Fcurrent_column
, Scurrent_column
, 0, 0, 0,
322 "Return the horizontal position of point. Beginning of line is column 0.\n\
323 This is calculated by adding together the widths of all the displayed\n\
324 representations of the character between the start of the previous line\n\
325 and point. (eg control characters will have a width of 2 or 4, tabs\n\
326 will have a variable width)\n\
327 Ignores finite width of frame, which means that this function may return\n\
328 values greater than (frame-width).\n\
329 Whether the line is visible (if `selective-display' is t) has no effect;\n\
330 however, ^M is treated as end of line when `selective-display' is t.")
334 XSETFASTINT (temp
, current_column ());
338 /* Cancel any recorded value of the horizontal position. */
341 invalidate_current_column ()
343 last_known_column_point
= 0;
350 register unsigned char *ptr
, *stop
;
351 register int tab_seen
;
354 register int tab_width
= XINT (current_buffer
->tab_width
);
355 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
356 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
358 if (PT
== last_known_column_point
359 && MODIFF
== last_known_column_modified
)
360 return last_known_column
;
362 /* If the buffer has overlays, text properties,
363 or multibyte characters, use a more general algorithm. */
364 if (BUF_INTERVALS (current_buffer
)
365 || !NILP (current_buffer
->overlays_before
)
366 || !NILP (current_buffer
->overlays_after
)
368 return current_column_1 ();
370 /* Scan backwards from point to the previous newline,
371 counting width. Tab characters are the only complicated case. */
373 /* Make a pointer for decrementing through the chars before point. */
374 ptr
= BYTE_POS_ADDR (PT_BYTE
- 1) + 1;
375 /* Make a pointer to where consecutive chars leave off,
376 going backwards from point. */
379 else if (PT
<= GPT
|| BEGV
> GPT
)
384 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
386 col
= 0, tab_seen
= 0, post_tab
= 0;
392 /* We stopped either for the beginning of the buffer
394 if (ptr
== BEGV_ADDR
)
396 /* It was the gap. Jump back over it. */
399 /* Check whether that brings us to beginning of buffer. */
400 if (BEGV
>= GPT
) break;
404 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
405 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
406 else if (c
>= 040 && c
< 0177)
409 || (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
)))
417 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
424 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
429 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
433 if (ptr
== BEGV_ADDR
)
434 current_column_bol_cache
= BEGV
;
436 current_column_bol_cache
= BYTE_TO_CHAR (PTR_BYTE_POS (ptr
));
438 last_known_column
= col
;
439 last_known_column_point
= PT
;
440 last_known_column_modified
= MODIFF
;
445 /* Return the column number of position POS
446 by scanning forward from the beginning of the line.
447 This function handles characters that are invisible
448 due to text properties or overlays. */
453 register int tab_width
= XINT (current_buffer
->tab_width
);
454 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
455 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
456 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
458 /* Start the scan at the beginning of this line with column number 0. */
459 register int col
= 0;
461 int next_boundary
, next_boundary_byte
;
462 int opoint
= PT
, opoint_byte
= PT_BYTE
;
464 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
465 current_column_bol_cache
= PT
;
466 scan
= PT
, scan_byte
= PT_BYTE
;
467 SET_PT_BOTH (opoint
, opoint_byte
);
468 next_boundary
= scan
;
469 next_boundary_byte
= scan_byte
;
471 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
473 /* Scan forward to the target position. */
474 while (scan
< opoint
)
478 /* Occasionally we may need to skip invisible text. */
479 while (scan
== next_boundary
)
482 /* This updates NEXT_BOUNDARY to the next place
483 where we might need to skip more invisible text. */
484 scan
= skip_invisible (scan
, &next_boundary
, opoint
, Qnil
);
487 if (scan
!= old_scan
)
488 scan_byte
= CHAR_TO_BYTE (scan
);
489 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
492 /* Check composition sequence. */
494 int len
, len_byte
, width
;
496 if (check_composition (scan
, scan_byte
, opoint
,
497 &len
, &len_byte
, &width
))
500 scan_byte
+= len_byte
;
507 c
= FETCH_BYTE (scan_byte
);
509 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
510 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
512 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
519 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
527 col
= col
/ tab_width
* tab_width
;
529 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
532 int bytes
, width
, wide_column
;
535 ptr
= BYTE_POS_ADDR (scan_byte
);
536 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
540 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
542 else if (c
< 040 || c
>= 0177)
549 last_known_column
= col
;
550 last_known_column_point
= PT
;
551 last_known_column_modified
= MODIFF
;
556 /* Return the width in columns of the part of STRING from BEG to END.
557 If BEG is nil, that stands for the beginning of STRING.
558 If END is nil, that stands for the end of STRING. */
561 string_display_width (string
, beg
, end
)
562 Lisp_Object string
, beg
, end
;
565 register unsigned char *ptr
, *stop
;
566 register int tab_seen
;
569 register int tab_width
= XINT (current_buffer
->tab_width
);
570 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
571 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
575 e
= XSTRING (string
)->size
;
578 CHECK_NUMBER (end
, 0);
586 CHECK_NUMBER (beg
, 0);
590 /* Make a pointer for decrementing through the chars before point. */
591 ptr
= XSTRING (string
)->data
+ e
;
592 /* Make a pointer to where consecutive chars leave off,
593 going backwards from point. */
594 stop
= XSTRING (string
)->data
+ b
;
596 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
598 col
= 0, tab_seen
= 0, post_tab
= 0;
606 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
607 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
608 else if (c
>= 040 && c
< 0177)
615 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
622 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
627 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
634 DEFUN ("indent-to", Findent_to
, Sindent_to
, 1, 2, "NIndent to column: ",
635 "Indent from point with tabs and spaces until COLUMN is reached.\n\
636 Optional second argument MININUM says always do at least MININUM spaces\n\
637 even if that goes past COLUMN; by default, MININUM is zero.")
639 Lisp_Object column
, minimum
;
642 register int fromcol
;
643 register int tab_width
= XINT (current_buffer
->tab_width
);
645 CHECK_NUMBER (column
, 0);
647 XSETFASTINT (minimum
, 0);
648 CHECK_NUMBER (minimum
, 1);
650 fromcol
= current_column ();
651 mincol
= fromcol
+ XINT (minimum
);
652 if (mincol
< XINT (column
)) mincol
= XINT (column
);
654 if (fromcol
== mincol
)
655 return make_number (mincol
);
657 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
659 if (indent_tabs_mode
)
662 XSETFASTINT (n
, mincol
/ tab_width
- fromcol
/ tab_width
);
663 if (XFASTINT (n
) != 0)
665 Finsert_char (make_number ('\t'), n
, Qt
);
667 fromcol
= (mincol
/ tab_width
) * tab_width
;
671 XSETFASTINT (column
, mincol
- fromcol
);
672 Finsert_char (make_number (' '), column
, Qt
);
674 last_known_column
= mincol
;
675 last_known_column_point
= PT
;
676 last_known_column_modified
= MODIFF
;
678 XSETINT (column
, mincol
);
683 static int position_indentation
P_ ((int));
685 DEFUN ("current-indentation", Fcurrent_indentation
, Scurrent_indentation
,
687 "Return the indentation of the current line.\n\
688 This is the horizontal position of the character\n\
689 following any initial whitespace.")
693 int opoint
= PT
, opoint_byte
= PT_BYTE
;
695 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
697 XSETFASTINT (val
, position_indentation (PT_BYTE
));
698 SET_PT_BOTH (opoint
, opoint_byte
);
703 position_indentation (pos_byte
)
704 register int pos_byte
;
706 register int column
= 0;
707 register int tab_width
= XINT (current_buffer
->tab_width
);
708 register unsigned char *p
;
709 register unsigned char *stop
;
710 unsigned char *start
;
711 int next_boundary_byte
= pos_byte
;
712 int ceiling
= next_boundary_byte
;
714 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
716 p
= BYTE_POS_ADDR (pos_byte
);
717 /* STOP records the value of P at which we will need
718 to think about the gap, or about invisible text,
719 or about the end of the buffer. */
721 /* START records the starting value of P. */
729 /* If we have updated P, set POS_BYTE to match.
730 The first time we enter the loop, POS_BYTE is already right. */
732 pos_byte
= PTR_BYTE_POS (p
);
733 /* Consider the various reasons STOP might have been set here. */
734 if (pos_byte
== ZV_BYTE
)
736 if (pos_byte
== next_boundary_byte
)
739 int pos
= BYTE_TO_CHAR (pos_byte
);
740 pos
= skip_invisible (pos
, &next_boundary
, ZV
, Qnil
);
741 pos_byte
= CHAR_TO_BYTE (pos
);
742 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
744 if (pos_byte
>= ceiling
)
745 ceiling
= BUFFER_CEILING_OF (pos_byte
) + 1;
746 /* Compute the next place we need to stop and think,
747 and set STOP accordingly. */
748 stop_pos_byte
= min (ceiling
, next_boundary_byte
);
749 /* The -1 and +1 arrange to point at the first byte of gap
750 (if STOP_POS_BYTE is the position of the gap)
751 rather than at the data after the gap. */
753 stop
= BYTE_POS_ADDR (stop_pos_byte
- 1) + 1;
754 p
= BYTE_POS_ADDR (pos_byte
);
759 if (! NILP (current_buffer
->enable_multibyte_characters
))
765 column
+= tab_width
- column
% tab_width
;
768 if (ASCII_BYTE_P (p
[-1])
769 || NILP (current_buffer
->enable_multibyte_characters
))
773 pos_byte
= PTR_BYTE_POS (p
- 1);
774 c
= FETCH_MULTIBYTE_CHAR (pos_byte
);
775 if (CHAR_HAS_CATEGORY (c
, ' '))
779 p
= BYTE_POS_ADDR (pos_byte
);
788 /* Test whether the line beginning at POS is indented beyond COLUMN.
789 Blank lines are treated as if they had the same indentation as the
793 indented_beyond_p (pos
, pos_byte
, column
)
794 int pos
, pos_byte
, column
;
797 int opoint
= PT
, opoint_byte
= PT_BYTE
;
799 SET_PT_BOTH (pos
, pos_byte
);
800 while (PT
> BEGV
&& FETCH_BYTE (PT_BYTE
) == '\n')
801 scan_newline (PT
- 1, PT_BYTE
- 1, BEGV
, BEGV_BYTE
, -1, 0);
803 val
= position_indentation (PT_BYTE
);
804 SET_PT_BOTH (opoint
, opoint_byte
);
805 return val
>= column
;
808 DEFUN ("move-to-column", Fmove_to_column
, Smove_to_column
, 1, 2, "p",
809 "Move point to column COLUMN in the current line.\n\
810 The column of a character is calculated by adding together the widths\n\
811 as displayed of the previous characters in the line.\n\
812 This function ignores line-continuation;\n\
813 there is no upper limit on the column number a character can have\n\
814 and horizontal scrolling has no effect.\n\
816 If specified column is within a character, point goes after that character.\n\
817 If it's past end of line, point goes to end of line.\n\n\
818 A non-nil second (optional) argument FORCE means,\n\
819 if COLUMN is in the middle of a tab character, change it to spaces.\n\
820 In addition, if FORCE is t, and the line is too short\n\
821 to reach column COLUMN, add spaces/tabs to get there.\n\
823 The return value is the current column.")
825 Lisp_Object column
, force
;
828 register int col
= current_column ();
831 register int tab_width
= XINT (current_buffer
->tab_width
);
832 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
833 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
834 register int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
841 int pos_byte
, end_byte
, next_boundary_byte
;
843 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
844 CHECK_NATNUM (column
, 0);
845 goal
= XINT (column
);
852 next_boundary_byte
= PT_BYTE
;
854 /* If we're starting past the desired column,
855 back up to beginning of line and scan from there. */
859 pos
= current_column_bol_cache
;
860 pos_byte
= CHAR_TO_BYTE (pos
);
866 while (pos
== next_boundary
)
869 pos
= skip_invisible (pos
, &next_boundary
, end
, Qnil
);
871 pos_byte
= CHAR_TO_BYTE (pos
);
872 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
877 /* Test reaching the goal column. We do this after skipping
878 invisible characters, so that we put point before the
879 character on which the cursor will appear. */
883 /* Check composition sequence. */
885 int len
, len_byte
, width
;
887 if (check_composition (pos
, pos_byte
, Z
, &len
, &len_byte
, &width
))
890 pos_byte
+= len_byte
;
896 c
= FETCH_BYTE (pos_byte
);
898 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
899 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
901 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
908 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
916 col
= col
/ tab_width
* tab_width
;
918 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
920 else if (c
< 040 || c
== 0177)
924 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
926 /* Start of multi-byte form. */
928 int bytes
, width
, wide_column
;
931 ptr
= BYTE_POS_ADDR (pos_byte
);
932 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
941 SET_PT_BOTH (pos
, pos_byte
);
943 /* If a tab char made us overshoot, change it to spaces
944 and scan through it again. */
945 if (!NILP (force
) && col
> goal
&& c
== '\t' && prev_col
< goal
)
947 int goal_pt
, goal_pt_byte
;
949 /* Insert spaces in front of the tab to reach GOAL. Do this
950 first so that a marker at the end of the tab gets
952 SET_PT_BOTH (PT
- 1, PT_BYTE
- 1);
953 Finsert_char (make_number (' '), make_number (goal
- prev_col
), Qt
);
955 /* Now delete the tab, and indent to COL. */
956 del_range (PT
, PT
+ 1);
958 goal_pt_byte
= PT_BYTE
;
959 Findent_to (make_number (col
), Qnil
);
960 SET_PT_BOTH (goal_pt
, goal_pt_byte
);
962 /* Set the last_known... vars consistently. */
966 /* If line ends prematurely, add space to the end. */
967 if (col
< goal
&& EQ (force
, Qt
))
968 Findent_to (make_number (col
= goal
), Qnil
);
970 last_known_column
= col
;
971 last_known_column_point
= PT
;
972 last_known_column_modified
= MODIFF
;
974 XSETFASTINT (val
, col
);
978 /* compute_motion: compute buffer posn given screen posn and vice versa */
980 struct position val_compute_motion
;
982 /* Scan the current buffer forward from offset FROM, pretending that
983 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
984 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
985 and return the ending buffer position and screen location. If we
986 can't hit the requested column exactly (because of a tab or other
987 multi-column character), overshoot.
989 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
990 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
991 earlier call to compute_motion. The other common case is that FROMHPOS
992 is zero and FROM is a position that "belongs" at column zero, but might
993 be shifted by overlay strings; in this case DID_MOTION should be 0.
995 WIDTH is the number of columns available to display text;
996 compute_motion uses this to handle continuation lines and such.
997 HSCROLL is the number of columns not being displayed at the left
998 margin; this is usually taken from a window's hscroll member.
999 TAB_OFFSET is the number of columns of the first tab that aren't
1000 being displayed, perhaps because of a continuation line or
1003 compute_motion returns a pointer to a struct position. The bufpos
1004 member gives the buffer position at the end of the scan, and hpos
1005 and vpos give its cartesian location. prevhpos is the column at
1006 which the character before bufpos started, and contin is non-zero
1007 if we reached the current line by continuing the previous.
1009 Note that FROMHPOS and TOHPOS should be expressed in real screen
1010 columns, taking HSCROLL and the truncation glyph at the left margin
1011 into account. That is, beginning-of-line moves you to the hpos
1012 -HSCROLL + (HSCROLL > 0).
1014 For example, to find the buffer position of column COL of line LINE
1015 of a certain window, pass the window's starting location as FROM
1016 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
1017 Pass the buffer's ZV as TO, to limit the scan to the end of the
1018 visible section of the buffer, and pass LINE and COL as TOVPOS and
1021 When displaying in window w, a typical formula for WIDTH is:
1024 - (has_vertical_scroll_bars
1025 ? FRAME_SCROLL_BAR_COLS (XFRAME (window->frame))
1026 : (window_width + window_left != frame_width))
1029 window_width is XFASTINT (w->width),
1030 window_left is XFASTINT (w->left),
1031 has_vertical_scroll_bars is
1032 FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (WINDOW_FRAME (window)))
1033 and frame_width = FRAME_WIDTH (XFRAME (window->frame))
1035 Or you can let window_internal_width do this all for you, and write:
1036 window_internal_width (w) - 1
1038 The `-1' accounts for the continuation-line backslashes; the rest
1039 accounts for window borders if the window is split horizontally, and
1040 the scroll bars if they are turned on. */
1043 compute_motion (from
, fromvpos
, fromhpos
, did_motion
, to
, tovpos
, tohpos
, width
, hscroll
, tab_offset
, win
)
1044 int from
, fromvpos
, fromhpos
, to
, tovpos
, tohpos
;
1047 int hscroll
, tab_offset
;
1050 register int hpos
= fromhpos
;
1051 register int vpos
= fromvpos
;
1056 register int tab_width
= XFASTINT (current_buffer
->tab_width
);
1057 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
1058 register struct Lisp_Char_Table
*dp
= window_display_table (win
);
1060 = (INTEGERP (current_buffer
->selective_display
)
1061 ? XINT (current_buffer
->selective_display
)
1062 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1065 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
1066 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
: 0);
1067 /* The next location where the `invisible' property changes, or an
1068 overlay starts or ends. */
1069 int next_boundary
= from
;
1071 /* For computing runs of characters with similar widths.
1072 Invariant: width_run_width is zero, or all the characters
1073 from width_run_start to width_run_end have a fixed width of
1075 int width_run_start
= from
;
1076 int width_run_end
= from
;
1077 int width_run_width
= 0;
1078 Lisp_Object
*width_table
;
1081 /* The next buffer pos where we should consult the width run cache. */
1082 int next_width_run
= from
;
1085 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
1086 /* If previous char scanned was a wide character,
1087 this is the column where it ended. Otherwise, this is 0. */
1088 int wide_column_end_hpos
= 0;
1089 int prev_pos
; /* Previous buffer position. */
1090 int prev_pos_byte
; /* Previous buffer position. */
1091 int contin_hpos
; /* HPOS of last column of continued line. */
1092 int prev_tab_offset
; /* Previous tab offset. */
1094 XSETBUFFER (buffer
, current_buffer
);
1095 XSETWINDOW (window
, win
);
1097 width_run_cache_on_off ();
1098 if (dp
== buffer_display_table ())
1099 width_table
= (VECTORP (current_buffer
->width_table
)
1100 ? XVECTOR (current_buffer
->width_table
)->contents
1103 /* If the window has its own display table, we can't use the width
1104 run cache, because that's based on the buffer's display table. */
1107 if (tab_width
<= 0 || tab_width
> 1000)
1113 pos
= prev_pos
= from
;
1114 pos_byte
= prev_pos_byte
= CHAR_TO_BYTE (from
);
1116 prev_tab_offset
= tab_offset
;
1119 while (pos
== next_boundary
)
1124 /* Don't skip invisible if we are already at the margin. */
1125 if (vpos
> tovpos
|| vpos
== tovpos
&& hpos
>= tohpos
)
1127 if (contin_hpos
&& prev_hpos
== 0
1129 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1130 { /* Line breaks because we can't put the character at the
1131 previous line any more. It is not the multi-column
1132 character continued in middle. Go back to previous
1133 buffer position, screen position, and set tab offset
1134 to previous value. It's the beginning of the
1137 pos_byte
= prev_pos_byte
;
1139 tab_offset
= prev_tab_offset
;
1144 /* If the caller says that the screen position came from an earlier
1145 call to compute_motion, then we've already accounted for the
1146 overlay strings at point. This is only true the first time
1147 through, so clear the flag after testing it. */
1149 /* We need to skip past the overlay strings. Currently those
1150 strings must not contain TAB;
1151 if we want to relax that restriction, something will have
1152 to be changed here. */
1154 unsigned char *ovstr
;
1155 int ovlen
= overlay_strings (pos
, win
, &ovstr
);
1156 hpos
+= ((multibyte
&& ovlen
> 0)
1157 ? strwidth (ovstr
, ovlen
) : ovlen
);
1164 /* Advance POS past invisible characters
1165 (but not necessarily all that there are here),
1166 and store in next_boundary the next position where
1167 we need to call skip_invisible. */
1168 newpos
= skip_invisible (pos
, &next_boundary
, to
, window
);
1172 pos
= min (to
, newpos
);
1173 pos_byte
= CHAR_TO_BYTE (pos
);
1177 if (newpos
!= pos_here
)
1180 pos_byte
= CHAR_TO_BYTE (pos
);
1184 /* Handle right margin. */
1185 /* Note on a wide-column character.
1187 Characters are classified into the following three categories
1188 according to the width (columns occupied on screen).
1190 (1) single-column character: ex. `a'
1191 (2) multi-column character: ex. `^A', TAB, `\033'
1192 (3) wide-column character: ex. Japanese character, Chinese character
1193 (In the following example, `W_' stands for them.)
1195 Multi-column characters can be divided around the right margin,
1196 but wide-column characters cannot.
1200 (*) The cursor is placed on the next character after the point.
1204 j ^---- next after the point
1205 ^--- next char. after the point.
1207 In case of sigle-column character
1211 033 ^---- next after the point, next char. after the point.
1213 In case of multi-column character
1217 W_ ^---- next after the point
1218 ^---- next char. after the point.
1220 In case of wide-column character
1222 The problem here is continuation at a wide-column character.
1223 In this case, the line may shorter less than WIDTH.
1224 And we find the continuation AFTER it occurs.
1231 || (truncate_partial_width_windows
1232 && width
+ 1 < FRAME_WIDTH (XFRAME (WINDOW_FRAME (win
))))
1233 || !NILP (current_buffer
->truncate_lines
))
1235 /* Truncating: skip to newline, unless we are already past
1236 TO (we need to go back below). */
1239 pos
= find_before_next_newline (pos
, to
, 1);
1240 pos_byte
= CHAR_TO_BYTE (pos
);
1242 /* If we just skipped next_boundary,
1243 loop around in the main while
1245 if (pos
>= next_boundary
)
1246 next_boundary
= pos
+ 1;
1248 prev_tab_offset
= tab_offset
;
1254 /* Remember the previous value. */
1255 prev_tab_offset
= tab_offset
;
1257 if (wide_column_end_hpos
> width
)
1260 tab_offset
+= prev_hpos
;
1264 tab_offset
+= width
;
1268 contin_hpos
= prev_hpos
;
1273 /* Stop if past the target buffer position or screen position. */
1276 /* Go back to the previous position. */
1278 pos_byte
= prev_pos_byte
;
1280 tab_offset
= prev_tab_offset
;
1282 /* NOTE on contin_hpos, hpos, and prev_hpos.
1286 W_ ^---- contin_hpos
1292 if (contin_hpos
&& prev_hpos
== 0
1293 && contin_hpos
< width
&& !wide_column_end_hpos
)
1295 /* Line breaking occurs in the middle of multi-column
1296 character. Go back to previous line. */
1301 /* If previous character is NEWLINE,
1302 set VPOS back to previous line */
1307 if (vpos
> tovpos
|| vpos
== tovpos
&& hpos
>= tohpos
)
1309 if (contin_hpos
&& prev_hpos
== 0
1311 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1312 { /* Line breaks because we can't put the character at the
1313 previous line any more. It is not the multi-column
1314 character continued in middle. Go back to previous
1315 buffer position, screen position, and set tab offset
1316 to previous value. It's the beginning of the
1319 pos_byte
= prev_pos_byte
;
1321 tab_offset
= prev_tab_offset
;
1325 if (pos
== ZV
) /* We cannot go beyond ZV. Stop here. */
1330 prev_pos_byte
= pos_byte
;
1331 wide_column_end_hpos
= 0;
1333 /* Consult the width run cache to see if we can avoid inspecting
1334 the text character-by-character. */
1335 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
1339 = region_cache_forward (current_buffer
,
1340 current_buffer
->width_run_cache
,
1343 /* A width of zero means the character's width varies (like
1344 a tab), is meaningless (like a newline), or we just don't
1345 want to skip over it for some other reason. */
1346 if (common_width
!= 0)
1350 /* Don't go past the final buffer posn the user
1355 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1357 /* Don't go past the final horizontal position the user
1359 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
1361 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
1362 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1365 /* Don't go past the margin. */
1366 if (run_end_hpos
>= width
)
1368 run_end
= pos
+ (width
- hpos
) / common_width
;
1369 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1372 hpos
= run_end_hpos
;
1374 prev_hpos
= hpos
- common_width
;
1378 pos_byte
= CHAR_TO_BYTE (pos
);
1382 next_width_run
= run_end
+ 1;
1385 /* We have to scan the text character-by-character. */
1388 c
= FETCH_BYTE (pos_byte
);
1390 /* Check composition sequence. */
1392 int len
, len_byte
, width
;
1394 if (check_composition (pos
, pos_byte
, to
, &len
, &len_byte
, &width
))
1397 pos_byte
+= len_byte
;
1405 /* Perhaps add some info to the width_run_cache. */
1406 if (current_buffer
->width_run_cache
)
1408 /* Is this character part of the current run? If so, extend
1410 if (pos
- 1 == width_run_end
1411 && XFASTINT (width_table
[c
]) == width_run_width
)
1412 width_run_end
= pos
;
1414 /* The previous run is over, since this is a character at a
1415 different position, or a different width. */
1418 /* Have we accumulated a run to put in the cache?
1419 (Currently, we only cache runs of width == 1). */
1420 if (width_run_start
< width_run_end
1421 && width_run_width
== 1)
1422 know_region_cache (current_buffer
,
1423 current_buffer
->width_run_cache
,
1424 width_run_start
, width_run_end
);
1426 /* Start recording a new width run. */
1427 width_run_width
= XFASTINT (width_table
[c
]);
1428 width_run_start
= pos
- 1;
1429 width_run_end
= pos
;
1434 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
1435 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1436 hpos
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
1437 else if (c
>= 040 && c
< 0177)
1441 int tem
= (hpos
+ tab_offset
+ hscroll
- (hscroll
> 0)) % tab_width
;
1444 hpos
+= tab_width
- tem
;
1449 && indented_beyond_p (pos
, pos_byte
, selective
))
1451 /* If (pos == to), we don't have to take care of
1452 selective display. */
1455 /* Skip any number of invisible lines all at once */
1458 pos
= find_before_next_newline (pos
, to
, 1);
1461 pos_byte
= CHAR_TO_BYTE (pos
);
1464 && indented_beyond_p (pos
, pos_byte
, selective
));
1465 /* Allow for the " ..." that is displayed for them. */
1468 hpos
+= selective_rlen
;
1472 DEC_BOTH (pos
, pos_byte
);
1473 /* We have skipped the invis text, but not the
1479 /* A visible line. */
1483 /* Count the truncation glyph on column 0 */
1490 else if (c
== CR
&& selective
< 0)
1492 /* In selective display mode,
1493 everything from a ^M to the end of the line is invisible.
1494 Stop *before* the real newline. */
1497 pos
= find_before_next_newline (pos
, to
, 1);
1498 pos_byte
= CHAR_TO_BYTE (pos
);
1500 /* If we just skipped next_boundary,
1501 loop around in the main while
1503 if (pos
> next_boundary
)
1504 next_boundary
= pos
;
1505 /* Allow for the " ..." that is displayed for them. */
1508 hpos
+= selective_rlen
;
1513 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
1515 /* Start of multi-byte form. */
1517 int bytes
, width
, wide_column
;
1519 pos_byte
--; /* rewind POS_BYTE */
1520 ptr
= BYTE_POS_ADDR (pos_byte
);
1521 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
1524 wide_column_end_hpos
= hpos
+ wide_column
;
1528 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
1534 /* Remember any final width run in the cache. */
1535 if (current_buffer
->width_run_cache
1536 && width_run_width
== 1
1537 && width_run_start
< width_run_end
)
1538 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
1539 width_run_start
, width_run_end
);
1541 val_compute_motion
.bufpos
= pos
;
1542 val_compute_motion
.bytepos
= pos_byte
;
1543 val_compute_motion
.hpos
= hpos
;
1544 val_compute_motion
.vpos
= vpos
;
1545 if (contin_hpos
&& prev_hpos
== 0)
1546 val_compute_motion
.prevhpos
= contin_hpos
;
1548 val_compute_motion
.prevhpos
= prev_hpos
;
1549 /* We alalways handle all of them here; none of them remain to do. */
1550 val_compute_motion
.ovstring_chars_done
= 0;
1552 /* Nonzero if have just continued a line */
1553 val_compute_motion
.contin
= (contin_hpos
&& prev_hpos
== 0);
1556 return &val_compute_motion
;
1560 #if 0 /* The doc string is too long for some compilers,
1561 but make-docfile can find it in this comment. */
1562 DEFUN ("compute-motion", Ffoo
, Sfoo
, 7, 7, 0,
1563 "Scan through the current buffer, calculating screen position.\n\
1564 Scan the current buffer forward from offset FROM,\n\
1565 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--\n\
1566 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--\n\
1567 and return the ending buffer position and screen location.\n\
1569 There are three additional arguments:\n\
1571 WIDTH is the number of columns available to display text;\n\
1572 this affects handling of continuation lines.\n\
1573 This is usually the value returned by `window-width', less one (to allow\n\
1574 for the continuation glyph).\n\
1576 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).\n\
1577 HSCROLL is the number of columns not being displayed at the left\n\
1578 margin; this is usually taken from a window's hscroll member.\n\
1579 TAB-OFFSET is the number of columns of the first tab that aren't\n\
1580 being displayed, perhaps because the line was continued within it.\n\
1581 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.\n\
1583 WINDOW is the window to operate on. It is used to choose the display table;\n\
1584 if it is showing the current buffer, it is used also for\n\
1585 deciding which overlay properties apply.\n\
1586 Note that `compute-motion' always operates on the current buffer.\n\
1588 The value is a list of five elements:\n\
1589 (POS HPOS VPOS PREVHPOS CONTIN)\n\
1590 POS is the buffer position where the scan stopped.\n\
1591 VPOS is the vertical position where the scan stopped.\n\
1592 HPOS is the horizontal position where the scan stopped.\n\
1594 PREVHPOS is the horizontal position one character back from POS.\n\
1595 CONTIN is t if a line was continued after (or within) the previous character.\n\
1597 For example, to find the buffer position of column COL of line LINE\n\
1598 of a certain window, pass the window's starting location as FROM\n\
1599 and the window's upper-left coordinates as FROMPOS.\n\
1600 Pass the buffer's (point-max) as TO, to limit the scan to the end of the\n\
1601 visible section of the buffer, and pass LINE and COL as TOPOS.")
1602 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1605 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
1607 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1608 Lisp_Object from
, frompos
, to
, topos
;
1609 Lisp_Object width
, offsets
, window
;
1611 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
;
1612 struct position
*pos
;
1613 int hscroll
, tab_offset
;
1615 CHECK_NUMBER_COERCE_MARKER (from
, 0);
1616 CHECK_CONS (frompos
, 0);
1617 CHECK_NUMBER (XCAR (frompos
), 0);
1618 CHECK_NUMBER (XCDR (frompos
), 0);
1619 CHECK_NUMBER_COERCE_MARKER (to
, 0);
1620 CHECK_CONS (topos
, 0);
1621 CHECK_NUMBER (XCAR (topos
), 0);
1622 CHECK_NUMBER (XCDR (topos
), 0);
1623 CHECK_NUMBER (width
, 0);
1624 if (!NILP (offsets
))
1626 CHECK_CONS (offsets
, 0);
1627 CHECK_NUMBER (XCAR (offsets
), 0);
1628 CHECK_NUMBER (XCDR (offsets
), 0);
1629 hscroll
= XINT (XCAR (offsets
));
1630 tab_offset
= XINT (XCDR (offsets
));
1633 hscroll
= tab_offset
= 0;
1636 window
= Fselected_window ();
1638 CHECK_LIVE_WINDOW (window
, 0);
1640 if (XINT (from
) < BEGV
|| XINT (from
) > ZV
)
1641 args_out_of_range_3 (from
, make_number (BEGV
), make_number (ZV
));
1642 if (XINT (to
) < BEGV
|| XINT (to
) > ZV
)
1643 args_out_of_range_3 (to
, make_number (BEGV
), make_number (ZV
));
1645 pos
= compute_motion (XINT (from
), XINT (XCDR (frompos
)),
1646 XINT (XCAR (frompos
)), 0,
1647 XINT (to
), XINT (XCDR (topos
)),
1648 XINT (XCAR (topos
)),
1649 XINT (width
), hscroll
, tab_offset
,
1652 XSETFASTINT (bufpos
, pos
->bufpos
);
1653 XSETINT (hpos
, pos
->hpos
);
1654 XSETINT (vpos
, pos
->vpos
);
1655 XSETINT (prevhpos
, pos
->prevhpos
);
1657 return Fcons (bufpos
,
1661 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
1665 /* Fvertical_motion and vmotion */
1666 struct position val_vmotion
;
1669 vmotion (from
, vtarget
, w
)
1670 register int from
, vtarget
;
1673 int width
= window_internal_width (w
) - 1;
1674 int hscroll
= XINT (w
->hscroll
);
1675 struct position pos
;
1676 /* vpos is cumulative vertical position, changed as from is changed */
1677 register int vpos
= 0;
1678 Lisp_Object prevline
;
1681 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1683 = (INTEGERP (current_buffer
->selective_display
)
1684 ? XINT (current_buffer
->selective_display
)
1685 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1689 /* This is the object we use for fetching character properties. */
1690 Lisp_Object text_prop_object
;
1692 XSETWINDOW (window
, w
);
1694 /* If the window contains this buffer, use it for getting text properties.
1695 Otherwise use the current buffer as arg for doing that. */
1696 if (EQ (w
->buffer
, Fcurrent_buffer ()))
1697 text_prop_object
= window
;
1699 text_prop_object
= Fcurrent_buffer ();
1701 if (vpos
>= vtarget
)
1703 /* To move upward, go a line at a time until
1704 we have gone at least far enough. */
1708 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1710 Lisp_Object propval
;
1712 XSETFASTINT (prevline
, find_next_newline_no_quit (from
- 1, -1));
1713 while (XFASTINT (prevline
) > BEGV
1715 && indented_beyond_p (XFASTINT (prevline
),
1716 CHAR_TO_BYTE (XFASTINT (prevline
)),
1718 /* watch out for newlines with `invisible' property */
1719 || (propval
= Fget_char_property (prevline
,
1722 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1723 XSETFASTINT (prevline
,
1724 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1726 pos
= *compute_motion (XFASTINT (prevline
), 0,
1727 lmargin
+ (XFASTINT (prevline
) == BEG
1731 /* Don't care for VPOS... */
1732 1 << (BITS_PER_SHORT
- 1),
1734 1 << (BITS_PER_SHORT
- 1),
1736 /* This compensates for start_hpos
1737 so that a tab as first character
1738 still occupies 8 columns. */
1739 (XFASTINT (prevline
) == BEG
1744 from
= XFASTINT (prevline
);
1747 /* If we made exactly the desired vertical distance,
1748 or if we hit beginning of buffer,
1749 return point found */
1750 if (vpos
>= vtarget
)
1752 val_vmotion
.bufpos
= from
;
1753 val_vmotion
.bytepos
= CHAR_TO_BYTE (from
);
1754 val_vmotion
.vpos
= vpos
;
1755 val_vmotion
.hpos
= lmargin
;
1756 val_vmotion
.contin
= 0;
1757 val_vmotion
.prevhpos
= 0;
1758 val_vmotion
.ovstring_chars_done
= 0;
1759 val_vmotion
.tab_offset
= 0; /* For accumulating tab offset. */
1760 return &val_vmotion
;
1763 /* Otherwise find the correct spot by moving down */
1765 /* Moving downward is simple, but must calculate from beg of line
1766 to determine hpos of starting point */
1767 from_byte
= CHAR_TO_BYTE (from
);
1768 if (from
> BEGV
&& FETCH_BYTE (from_byte
- 1) != '\n')
1770 Lisp_Object propval
;
1772 XSETFASTINT (prevline
, find_next_newline_no_quit (from
, -1));
1773 while (XFASTINT (prevline
) > BEGV
1775 && indented_beyond_p (XFASTINT (prevline
),
1776 CHAR_TO_BYTE (XFASTINT (prevline
)),
1778 /* watch out for newlines with `invisible' property */
1779 || (propval
= Fget_char_property (prevline
, Qinvisible
,
1781 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1782 XSETFASTINT (prevline
,
1783 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1785 pos
= *compute_motion (XFASTINT (prevline
), 0,
1786 lmargin
+ (XFASTINT (prevline
) == BEG
1790 /* Don't care for VPOS... */
1791 1 << (BITS_PER_SHORT
- 1),
1793 1 << (BITS_PER_SHORT
- 1),
1795 (XFASTINT (prevline
) == BEG
? -start_hpos
: 0),
1801 pos
.hpos
= lmargin
+ (from
== BEG
? start_hpos
: 0);
1806 return compute_motion (from
, vpos
, pos
.hpos
, did_motion
,
1807 ZV
, vtarget
, - (1 << (BITS_PER_SHORT
- 1)),
1809 pos
.tab_offset
- (from
== BEG
? start_hpos
: 0),
1813 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
1814 "Move point to start of the screen line LINES lines down.\n\
1815 If LINES is negative, this means moving up.\n\
1817 This function is an ordinary cursor motion function\n\
1818 which calculates the new position based on how text would be displayed.\n\
1819 The new position may be the start of a line,\n\
1820 or just the start of a continuation line.\n\
1821 The function returns number of screen lines moved over;\n\
1822 that usually equals LINES, but may be closer to zero\n\
1823 if beginning or end of buffer was reached.\n\
1825 The optional second argument WINDOW specifies the window to use for\n\
1826 parameters such as width, horizontal scrolling, and so on.\n\
1827 The default is to use the selected window's parameters.\n\
1829 `vertical-motion' always uses the current buffer,\n\
1830 regardless of which buffer is displayed in WINDOW.\n\
1831 This is consistent with other cursor motion functions\n\
1832 and makes it possible to use `vertical-motion' in any buffer,\n\
1833 whether or not it is currently displayed in some window.")
1835 Lisp_Object lines
, window
;
1840 Lisp_Object old_buffer
;
1841 struct gcpro gcpro1
;
1843 CHECK_NUMBER (lines
, 0);
1844 if (! NILP (window
))
1845 CHECK_WINDOW (window
, 0);
1847 window
= selected_window
;
1848 w
= XWINDOW (window
);
1851 GCPRO1 (old_buffer
);
1852 if (XBUFFER (w
->buffer
) != current_buffer
)
1854 /* Set the window's buffer temporarily to the current buffer. */
1855 old_buffer
= w
->buffer
;
1856 XSETBUFFER (w
->buffer
, current_buffer
);
1859 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
1860 start_display (&it
, w
, pt
);
1861 move_it_by_lines (&it
, XINT (lines
), 0);
1862 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
1864 if (BUFFERP (old_buffer
))
1865 w
->buffer
= old_buffer
;
1867 RETURN_UNGCPRO (make_number (it
.vpos
));
1872 /* file's initialization. */
1877 DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode
,
1878 "*Indentation can insert tabs if this is non-nil.\n\
1879 Setting this variable automatically makes it local to the current buffer.");
1880 indent_tabs_mode
= 1;
1882 defsubr (&Scurrent_indentation
);
1883 defsubr (&Sindent_to
);
1884 defsubr (&Scurrent_column
);
1885 defsubr (&Smove_to_column
);
1886 defsubr (&Svertical_motion
);
1887 defsubr (&Scompute_motion
);