1 /* Indentation functions.
2 Copyright (C) 1985,86,87,88,93,94,95,98,2000,01,02,03,2004
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
34 #include "intervals.h"
35 #include "region-cache.h"
37 /* Indentation can insert tabs if this is non-zero;
38 otherwise always uses spaces. */
44 /* These three values memorize the current column to avoid recalculation. */
46 /* Last value returned by current_column.
47 Some things in set last_known_column_point to -1
48 to mark the memorized value as invalid. */
50 double last_known_column
;
52 /* Value of point when current_column was called. */
54 int last_known_column_point
;
56 /* Value of MODIFF when current_column was called. */
58 int last_known_column_modified
;
60 static double current_column_1
P_ ((void));
61 static double position_indentation
P_ ((int));
63 /* Cache of beginning of line found by the last call of
66 int current_column_bol_cache
;
68 /* Get the display table to use for the current buffer. */
70 struct Lisp_Char_Table
*
71 buffer_display_table ()
75 thisbuf
= current_buffer
->display_table
;
76 if (DISP_TABLE_P (thisbuf
))
77 return XCHAR_TABLE (thisbuf
);
78 if (DISP_TABLE_P (Vstandard_display_table
))
79 return XCHAR_TABLE (Vstandard_display_table
);
83 /* Width run cache considerations. */
85 /* Return the width of character C under display table DP. */
88 character_width (c
, dp
)
90 struct Lisp_Char_Table
*dp
;
94 /* These width computations were determined by examining the cases
95 in display_text_line. */
97 /* Everything can be handled by the display table, if it's
98 present and the element is right. */
99 if (dp
&& (elt
= DISP_CHAR_VECTOR (dp
, c
), VECTORP (elt
)))
100 return XVECTOR (elt
)->size
;
102 /* Some characters are special. */
103 if (c
== '\n' || c
== '\t' || c
== '\015')
106 /* Printing characters have width 1. */
107 else if (c
>= 040 && c
< 0177)
110 /* Everybody else (control characters, metacharacters) has other
111 widths. We could return their actual widths here, but they
112 depend on things like ctl_arrow and crud like that, and they're
113 not very common at all. So we'll just claim we don't know their
119 /* Return true iff the display table DISPTAB specifies the same widths
120 for characters as WIDTHTAB. We use this to decide when to
121 invalidate the buffer's width_run_cache. */
124 disptab_matches_widthtab (disptab
, widthtab
)
125 struct Lisp_Char_Table
*disptab
;
126 struct Lisp_Vector
*widthtab
;
130 if (widthtab
->size
!= 256)
133 for (i
= 0; i
< 256; i
++)
134 if (character_width (i
, disptab
)
135 != XFASTINT (widthtab
->contents
[i
]))
141 /* Recompute BUF's width table, using the display table DISPTAB. */
144 recompute_width_table (buf
, disptab
)
146 struct Lisp_Char_Table
*disptab
;
149 struct Lisp_Vector
*widthtab
;
151 if (!VECTORP (buf
->width_table
))
152 buf
->width_table
= Fmake_vector (make_number (256), make_number (0));
153 widthtab
= XVECTOR (buf
->width_table
);
154 if (widthtab
->size
!= 256)
157 for (i
= 0; i
< 256; i
++)
158 XSETFASTINT (widthtab
->contents
[i
], character_width (i
, disptab
));
161 /* Allocate or free the width run cache, as requested by the current
162 state of current_buffer's cache_long_line_scans variable. */
165 width_run_cache_on_off ()
167 if (NILP (current_buffer
->cache_long_line_scans
)
168 /* And, for the moment, this feature doesn't work on multibyte
170 || !NILP (current_buffer
->enable_multibyte_characters
))
172 /* It should be off. */
173 if (current_buffer
->width_run_cache
)
175 free_region_cache (current_buffer
->width_run_cache
);
176 current_buffer
->width_run_cache
= 0;
177 current_buffer
->width_table
= Qnil
;
182 /* It should be on. */
183 if (current_buffer
->width_run_cache
== 0)
185 current_buffer
->width_run_cache
= new_region_cache ();
186 recompute_width_table (current_buffer
, buffer_display_table ());
192 /* Skip some invisible characters starting from POS.
193 This includes characters invisible because of text properties
194 and characters invisible because of overlays.
196 If position POS is followed by invisible characters,
197 skip some of them and return the position after them.
198 Otherwise return POS itself.
200 Set *NEXT_BOUNDARY_P to the next position at which
201 it will be necessary to call this function again.
203 Don't scan past TO, and don't set *NEXT_BOUNDARY_P
204 to a value greater than TO.
206 If WINDOW is non-nil, and this buffer is displayed in WINDOW,
207 take account of overlays that apply only in WINDOW.
209 We don't necessarily skip all the invisible characters after POS
210 because that could take a long time. We skip a reasonable number
211 which can be skipped quickly. If there might be more invisible
212 characters immediately following, then *NEXT_BOUNDARY_P
213 will equal the return value. */
216 skip_invisible (pos
, next_boundary_p
, to
, window
)
218 int *next_boundary_p
;
222 Lisp_Object prop
, position
, overlay_limit
, proplimit
;
226 XSETFASTINT (position
, pos
);
227 XSETBUFFER (buffer
, current_buffer
);
229 /* Give faster response for overlay lookup near POS. */
230 recenter_overlay_lists (current_buffer
, pos
);
232 /* We must not advance farther than the next overlay change.
233 The overlay change might change the invisible property;
234 or there might be overlay strings to be displayed there. */
235 overlay_limit
= Fnext_overlay_change (position
);
236 /* As for text properties, this gives a lower bound
237 for where the invisible text property could change. */
238 proplimit
= Fnext_property_change (position
, buffer
, Qt
);
239 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
240 proplimit
= overlay_limit
;
241 /* PROPLIMIT is now a lower bound for the next change
242 in invisible status. If that is plenty far away,
243 use that lower bound. */
244 if (XFASTINT (proplimit
) > pos
+ 100 || XFASTINT (proplimit
) >= to
)
245 *next_boundary_p
= XFASTINT (proplimit
);
246 /* Otherwise, scan for the next `invisible' property change. */
249 /* Don't scan terribly far. */
250 XSETFASTINT (proplimit
, min (pos
+ 100, to
));
251 /* No matter what. don't go past next overlay change. */
252 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
253 proplimit
= overlay_limit
;
254 end
= XFASTINT (Fnext_single_property_change (position
, Qinvisible
,
257 /* Don't put the boundary in the middle of multibyte form if
258 there is no actual property change. */
260 && !NILP (current_buffer
->enable_multibyte_characters
)
262 while (pos
< end
&& !CHAR_HEAD_P (POS_ADDR (end
)))
265 *next_boundary_p
= end
;
267 /* if the `invisible' property is set, we can skip to
268 the next property change */
269 prop
= Fget_char_property (position
, Qinvisible
,
271 && EQ (XWINDOW (window
)->buffer
, buffer
))
273 inv_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
274 /* When counting columns (window == nil), don't skip over ellipsis text. */
275 if (NILP (window
) ? inv_p
== 1 : inv_p
)
276 return *next_boundary_p
;
280 /* If a composition starts at POS/POS_BYTE and it doesn't stride over
281 POINT, set *LEN / *LEN_BYTE to the character and byte lengths, *WIDTH
282 to the width, and return 1. Otherwise, return 0. */
285 check_composition (pos
, pos_byte
, point
, len
, len_byte
, width
)
286 int pos
, pos_byte
, point
;
287 int *len
, *len_byte
, *width
;
293 if (! find_composition (pos
, -1, &start
, &end
, &prop
, Qnil
)
294 || pos
!= start
|| point
< end
295 || !COMPOSITION_VALID_P (start
, end
, prop
))
297 if ((id
= get_composition_id (pos
, pos_byte
, end
- pos
, prop
, Qnil
)) < 0)
300 *len
= COMPOSITION_LENGTH (prop
);
301 *len_byte
= CHAR_TO_BYTE (end
) - pos_byte
;
302 *width
= composition_table
[id
]->width
;
306 /* Set variables WIDTH and BYTES for a multibyte sequence starting at P.
308 DP is a display table or NULL.
310 This macro is used in current_column_1, Fmove_to_column, and
313 #define MULTIBYTE_BYTES_WIDTH(p, dp) \
318 c = STRING_CHAR_AND_LENGTH (p, MAX_MULTIBYTE_LENGTH, bytes); \
319 if (BYTES_BY_CHAR_HEAD (*p) != bytes) \
323 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c))) \
324 width = XVECTOR (DISP_CHAR_VECTOR (dp, c))->size; \
326 width = WIDTH_BY_CHAR_HEAD (*p); \
328 wide_column = width; \
333 DEFUN ("current-column", Fcurrent_column
, Scurrent_column
, 0, 0, 0,
334 doc
: /* Return the horizontal position of point. Beginning of line is column 0.
335 This is calculated by adding together the widths of all the displayed
336 representations of the character between the start of the previous line
337 and point. (eg control characters will have a width of 2 or 4, tabs
338 will have a variable width)
339 Ignores finite width of frame, which means that this function may return
340 values greater than (frame-width).
341 Whether the line is visible (if `selective-display' is t) has no effect;
342 however, ^M is treated as end of line when `selective-display' is t. */)
346 XSETFASTINT (temp
, (int) current_column ()); /* iftc */
350 /* Cancel any recorded value of the horizontal position. */
353 invalidate_current_column ()
355 last_known_column_point
= 0;
362 register unsigned char *ptr
, *stop
;
363 register int tab_seen
;
366 register int tab_width
= XINT (current_buffer
->tab_width
);
367 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
368 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
370 if (PT
== last_known_column_point
371 && MODIFF
== last_known_column_modified
)
372 return last_known_column
;
374 /* If the buffer has overlays, text properties,
375 or multibyte characters, use a more general algorithm. */
376 if (BUF_INTERVALS (current_buffer
)
377 || current_buffer
->overlays_before
378 || current_buffer
->overlays_after
380 return current_column_1 ();
382 /* Scan backwards from point to the previous newline,
383 counting width. Tab characters are the only complicated case. */
385 /* Make a pointer for decrementing through the chars before point. */
386 ptr
= BYTE_POS_ADDR (PT_BYTE
- 1) + 1;
387 /* Make a pointer to where consecutive chars leave off,
388 going backwards from point. */
391 else if (PT
<= GPT
|| BEGV
> GPT
)
396 if (tab_width
<= 0 || tab_width
> 1000)
399 col
= 0, tab_seen
= 0, post_tab
= 0;
408 /* We stopped either for the beginning of the buffer
410 if (ptr
== BEGV_ADDR
)
413 /* It was the gap. Jump back over it. */
417 /* Check whether that brings us to beginning of buffer. */
424 if (dp
&& VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
426 charvec
= DISP_CHAR_VECTOR (dp
, c
);
435 for (i
= n
- 1; i
>= 0; --i
)
437 if (VECTORP (charvec
))
439 /* This should be handled the same as
440 next_element_from_display_vector does it. */
441 Lisp_Object entry
= AREF (charvec
, i
);
444 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
445 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
450 if (c
>= 040 && c
< 0177)
454 && EQ (current_buffer
->selective_display
, Qt
)))
457 goto start_of_line_found
;
462 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
468 else if (VECTORP (charvec
))
469 /* With a display table entry, C is displayed as is, and
470 not displayed as \NNN or as ^N. If C is a single-byte
471 character, it takes one column. If C is multi-byte in
472 an unibyte buffer, it's translated to unibyte, so it
473 also takes one column. */
476 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
484 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
488 if (ptr
== BEGV_ADDR
)
489 current_column_bol_cache
= BEGV
;
491 current_column_bol_cache
= BYTE_TO_CHAR (PTR_BYTE_POS (ptr
));
493 last_known_column
= col
;
494 last_known_column_point
= PT
;
495 last_known_column_modified
= MODIFF
;
500 /* Return the column number of position POS
501 by scanning forward from the beginning of the line.
502 This function handles characters that are invisible
503 due to text properties or overlays. */
508 register int tab_width
= XINT (current_buffer
->tab_width
);
509 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
510 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
511 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
513 /* Start the scan at the beginning of this line with column number 0. */
514 register int col
= 0;
517 int opoint
= PT
, opoint_byte
= PT_BYTE
;
519 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
520 current_column_bol_cache
= PT
;
521 scan
= PT
, scan_byte
= PT_BYTE
;
522 SET_PT_BOTH (opoint
, opoint_byte
);
523 next_boundary
= scan
;
525 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
527 /* Scan forward to the target position. */
528 while (scan
< opoint
)
532 /* Occasionally we may need to skip invisible text. */
533 while (scan
== next_boundary
)
536 /* This updates NEXT_BOUNDARY to the next place
537 where we might need to skip more invisible text. */
538 scan
= skip_invisible (scan
, &next_boundary
, opoint
, Qnil
);
541 if (scan
!= old_scan
)
542 scan_byte
= CHAR_TO_BYTE (scan
);
545 /* Check composition sequence. */
547 int len
, len_byte
, width
;
549 if (check_composition (scan
, scan_byte
, opoint
,
550 &len
, &len_byte
, &width
))
553 scan_byte
+= len_byte
;
560 c
= FETCH_BYTE (scan_byte
);
563 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
564 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
569 /* This character is displayed using a vector of glyphs.
570 Update the column based on those glyphs. */
572 charvec
= DISP_CHAR_VECTOR (dp
, c
);
575 for (i
= 0; i
< n
; i
++)
577 /* This should be handled the same as
578 next_element_from_display_vector does it. */
580 entry
= AREF (charvec
, i
);
583 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
584 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
590 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
595 col
= col
/ tab_width
* tab_width
;
603 /* The display table says nothing for this character.
604 Display it as itself. */
608 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
613 col
= col
/ tab_width
* tab_width
;
615 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
618 int bytes
, width
, wide_column
;
620 ptr
= BYTE_POS_ADDR (scan_byte
);
621 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
623 /* Subtract one to compensate for the increment
624 that is going to happen below. */
628 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
630 else if (c
< 040 || c
>= 0177)
641 last_known_column
= col
;
642 last_known_column_point
= PT
;
643 last_known_column_modified
= MODIFF
;
649 #if 0 /* Not used. */
651 /* Return the width in columns of the part of STRING from BEG to END.
652 If BEG is nil, that stands for the beginning of STRING.
653 If END is nil, that stands for the end of STRING. */
656 string_display_width (string
, beg
, end
)
657 Lisp_Object string
, beg
, end
;
660 register unsigned char *ptr
, *stop
;
661 register int tab_seen
;
664 register int tab_width
= XINT (current_buffer
->tab_width
);
665 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
666 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
685 /* Make a pointer for decrementing through the chars before point. */
686 ptr
= SDATA (string
) + e
;
687 /* Make a pointer to where consecutive chars leave off,
688 going backwards from point. */
689 stop
= SDATA (string
) + b
;
691 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
693 col
= 0, tab_seen
= 0, post_tab
= 0;
701 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
702 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
703 else if (c
>= 040 && c
< 0177)
710 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
717 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
722 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
732 DEFUN ("indent-to", Findent_to
, Sindent_to
, 1, 2, "NIndent to column: ",
733 doc
: /* Indent from point with tabs and spaces until COLUMN is reached.
734 Optional second argument MININUM says always do at least MININUM spaces
735 even if that goes past COLUMN; by default, MININUM is zero. */)
737 Lisp_Object column
, minimum
;
740 register int fromcol
;
741 register int tab_width
= XINT (current_buffer
->tab_width
);
743 CHECK_NUMBER (column
);
745 XSETFASTINT (minimum
, 0);
746 CHECK_NUMBER (minimum
);
748 fromcol
= current_column ();
749 mincol
= fromcol
+ XINT (minimum
);
750 if (mincol
< XINT (column
)) mincol
= XINT (column
);
752 if (fromcol
== mincol
)
753 return make_number (mincol
);
755 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
757 if (indent_tabs_mode
)
760 XSETFASTINT (n
, mincol
/ tab_width
- fromcol
/ tab_width
);
761 if (XFASTINT (n
) != 0)
763 Finsert_char (make_number ('\t'), n
, Qt
);
765 fromcol
= (mincol
/ tab_width
) * tab_width
;
769 XSETFASTINT (column
, mincol
- fromcol
);
770 Finsert_char (make_number (' '), column
, Qt
);
772 last_known_column
= mincol
;
773 last_known_column_point
= PT
;
774 last_known_column_modified
= MODIFF
;
776 XSETINT (column
, mincol
);
781 static double position_indentation
P_ ((int));
783 DEFUN ("current-indentation", Fcurrent_indentation
, Scurrent_indentation
,
785 doc
: /* Return the indentation of the current line.
786 This is the horizontal position of the character
787 following any initial whitespace. */)
791 int opoint
= PT
, opoint_byte
= PT_BYTE
;
793 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
795 XSETFASTINT (val
, (int) position_indentation (PT_BYTE
)); /* iftc */
796 SET_PT_BOTH (opoint
, opoint_byte
);
801 position_indentation (pos_byte
)
802 register int pos_byte
;
804 register int column
= 0;
805 register int tab_width
= XINT (current_buffer
->tab_width
);
806 register unsigned char *p
;
807 register unsigned char *stop
;
808 unsigned char *start
;
809 int next_boundary_byte
= pos_byte
;
810 int ceiling
= next_boundary_byte
;
812 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
814 p
= BYTE_POS_ADDR (pos_byte
);
815 /* STOP records the value of P at which we will need
816 to think about the gap, or about invisible text,
817 or about the end of the buffer. */
819 /* START records the starting value of P. */
827 /* If we have updated P, set POS_BYTE to match.
828 The first time we enter the loop, POS_BYTE is already right. */
830 pos_byte
= PTR_BYTE_POS (p
);
831 /* Consider the various reasons STOP might have been set here. */
832 if (pos_byte
== ZV_BYTE
)
834 if (pos_byte
== next_boundary_byte
)
837 int pos
= BYTE_TO_CHAR (pos_byte
);
838 pos
= skip_invisible (pos
, &next_boundary
, ZV
, Qnil
);
839 pos_byte
= CHAR_TO_BYTE (pos
);
840 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
842 if (pos_byte
>= ceiling
)
843 ceiling
= BUFFER_CEILING_OF (pos_byte
) + 1;
844 /* Compute the next place we need to stop and think,
845 and set STOP accordingly. */
846 stop_pos_byte
= min (ceiling
, next_boundary_byte
);
847 /* The -1 and +1 arrange to point at the first byte of gap
848 (if STOP_POS_BYTE is the position of the gap)
849 rather than at the data after the gap. */
851 stop
= BYTE_POS_ADDR (stop_pos_byte
- 1) + 1;
852 p
= BYTE_POS_ADDR (pos_byte
);
857 if (! NILP (current_buffer
->enable_multibyte_characters
))
863 column
+= tab_width
- column
% tab_width
;
866 if (ASCII_BYTE_P (p
[-1])
867 || NILP (current_buffer
->enable_multibyte_characters
))
871 pos_byte
= PTR_BYTE_POS (p
- 1);
872 c
= FETCH_MULTIBYTE_CHAR (pos_byte
);
873 if (CHAR_HAS_CATEGORY (c
, ' '))
877 p
= BYTE_POS_ADDR (pos_byte
);
886 /* Test whether the line beginning at POS is indented beyond COLUMN.
887 Blank lines are treated as if they had the same indentation as the
891 indented_beyond_p (pos
, pos_byte
, column
)
896 int opoint
= PT
, opoint_byte
= PT_BYTE
;
898 SET_PT_BOTH (pos
, pos_byte
);
899 while (PT
> BEGV
&& FETCH_BYTE (PT_BYTE
) == '\n')
900 scan_newline (PT
- 1, PT_BYTE
- 1, BEGV
, BEGV_BYTE
, -1, 0);
902 val
= position_indentation (PT_BYTE
);
903 SET_PT_BOTH (opoint
, opoint_byte
);
904 return val
>= column
; /* hmm, float comparison */
907 DEFUN ("move-to-column", Fmove_to_column
, Smove_to_column
, 1, 2, "p",
908 doc
: /* Move point to column COLUMN in the current line.
909 The column of a character is calculated by adding together the widths
910 as displayed of the previous characters in the line.
911 This function ignores line-continuation;
912 there is no upper limit on the column number a character can have
913 and horizontal scrolling has no effect.
915 If specified column is within a character, point goes after that character.
916 If it's past end of line, point goes to end of line.
918 A non-nil second (optional) argument FORCE means,
919 if COLUMN is in the middle of a tab character, change it to spaces.
920 In addition, if FORCE is t, and the line is too short
921 to reach column COLUMN, add spaces/tabs to get there.
923 The return value is the current column. */)
925 Lisp_Object column
, force
;
928 register int col
= current_column ();
931 register int tab_width
= XINT (current_buffer
->tab_width
);
932 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
933 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
934 register int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
939 int next_boundary
, pos_byte
;
941 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
942 CHECK_NATNUM (column
);
943 goal
= XINT (column
);
950 /* If we're starting past the desired column,
951 back up to beginning of line and scan from there. */
955 pos
= current_column_bol_cache
;
956 pos_byte
= CHAR_TO_BYTE (pos
);
962 while (pos
== next_boundary
)
965 pos
= skip_invisible (pos
, &next_boundary
, end
, Qnil
);
967 pos_byte
= CHAR_TO_BYTE (pos
);
972 /* Test reaching the goal column. We do this after skipping
973 invisible characters, so that we put point before the
974 character on which the cursor will appear. */
978 /* Check composition sequence. */
980 int len
, len_byte
, width
;
982 if (check_composition (pos
, pos_byte
, Z
, &len
, &len_byte
, &width
))
985 pos_byte
+= len_byte
;
991 c
= FETCH_BYTE (pos_byte
);
993 /* See if there is a display table and it relates
994 to this character. */
997 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
998 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1000 Lisp_Object charvec
;
1003 /* This character is displayed using a vector of glyphs.
1004 Update the position based on those glyphs. */
1006 charvec
= DISP_CHAR_VECTOR (dp
, c
);
1007 n
= ASIZE (charvec
);
1009 for (i
= 0; i
< n
; i
++)
1011 /* This should be handled the same as
1012 next_element_from_display_vector does it. */
1015 entry
= AREF (charvec
, i
);
1017 if (INTEGERP (entry
)
1018 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
1019 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
1025 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
1031 col
= col
/ tab_width
* tab_width
;
1039 /* The display table doesn't affect this character;
1040 it displays as itself. */
1044 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
1050 col
= col
/ tab_width
* tab_width
;
1052 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
1054 else if (c
< 040 || c
== 0177)
1058 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
1060 /* Start of multi-byte form. */
1062 int bytes
, width
, wide_column
;
1064 ptr
= BYTE_POS_ADDR (pos_byte
);
1065 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
1066 pos_byte
+= bytes
- 1;
1078 SET_PT_BOTH (pos
, pos_byte
);
1080 /* If a tab char made us overshoot, change it to spaces
1081 and scan through it again. */
1082 if (!NILP (force
) && col
> goal
&& c
== '\t' && prev_col
< goal
)
1084 int goal_pt
, goal_pt_byte
;
1086 /* Insert spaces in front of the tab to reach GOAL. Do this
1087 first so that a marker at the end of the tab gets
1089 SET_PT_BOTH (PT
- 1, PT_BYTE
- 1);
1090 Finsert_char (make_number (' '), make_number (goal
- prev_col
), Qt
);
1092 /* Now delete the tab, and indent to COL. */
1093 del_range (PT
, PT
+ 1);
1095 goal_pt_byte
= PT_BYTE
;
1096 Findent_to (make_number (col
), Qnil
);
1097 SET_PT_BOTH (goal_pt
, goal_pt_byte
);
1099 /* Set the last_known... vars consistently. */
1103 /* If line ends prematurely, add space to the end. */
1104 if (col
< goal
&& EQ (force
, Qt
))
1105 Findent_to (make_number (col
= goal
), Qnil
);
1107 last_known_column
= col
;
1108 last_known_column_point
= PT
;
1109 last_known_column_modified
= MODIFF
;
1111 XSETFASTINT (val
, col
);
1115 /* compute_motion: compute buffer posn given screen posn and vice versa */
1117 struct position val_compute_motion
;
1119 /* Scan the current buffer forward from offset FROM, pretending that
1120 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
1121 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
1122 and return the ending buffer position and screen location. If we
1123 can't hit the requested column exactly (because of a tab or other
1124 multi-column character), overshoot.
1126 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
1127 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
1128 earlier call to compute_motion. The other common case is that FROMHPOS
1129 is zero and FROM is a position that "belongs" at column zero, but might
1130 be shifted by overlay strings; in this case DID_MOTION should be 0.
1132 WIDTH is the number of columns available to display text;
1133 compute_motion uses this to handle continuation lines and such.
1134 If WIDTH is -1, use width of window's text area adjusted for
1135 continuation glyph when needed.
1137 HSCROLL is the number of columns not being displayed at the left
1138 margin; this is usually taken from a window's hscroll member.
1139 TAB_OFFSET is the number of columns of the first tab that aren't
1140 being displayed, perhaps because of a continuation line or
1143 compute_motion returns a pointer to a struct position. The bufpos
1144 member gives the buffer position at the end of the scan, and hpos
1145 and vpos give its cartesian location. prevhpos is the column at
1146 which the character before bufpos started, and contin is non-zero
1147 if we reached the current line by continuing the previous.
1149 Note that FROMHPOS and TOHPOS should be expressed in real screen
1150 columns, taking HSCROLL and the truncation glyph at the left margin
1151 into account. That is, beginning-of-line moves you to the hpos
1152 -HSCROLL + (HSCROLL > 0).
1154 For example, to find the buffer position of column COL of line LINE
1155 of a certain window, pass the window's starting location as FROM
1156 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
1157 Pass the buffer's ZV as TO, to limit the scan to the end of the
1158 visible section of the buffer, and pass LINE and COL as TOVPOS and
1161 When displaying in window w, a typical formula for WIDTH is:
1164 - (has_vertical_scroll_bars
1165 ? WINDOW_CONFIG_SCROLL_BAR_COLS (window)
1166 : (window_width + window_left != frame_cols))
1169 window_width is XFASTINT (w->total_cols),
1170 window_left is XFASTINT (w->left_col),
1171 has_vertical_scroll_bars is
1172 WINDOW_HAS_VERTICAL_SCROLL_BAR (window)
1173 and frame_cols = FRAME_COLS (XFRAME (window->frame))
1175 Or you can let window_box_text_cols do this all for you, and write:
1176 window_box_text_cols (w) - 1
1178 The `-1' accounts for the continuation-line backslashes; the rest
1179 accounts for window borders if the window is split horizontally, and
1180 the scroll bars if they are turned on. */
1183 compute_motion (from
, fromvpos
, fromhpos
, did_motion
, to
, tovpos
, tohpos
, width
, hscroll
, tab_offset
, win
)
1184 int from
, fromvpos
, fromhpos
, to
, tovpos
, tohpos
;
1187 int hscroll
, tab_offset
;
1190 register int hpos
= fromhpos
;
1191 register int vpos
= fromvpos
;
1196 register int tab_width
= XFASTINT (current_buffer
->tab_width
);
1197 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
1198 register struct Lisp_Char_Table
*dp
= window_display_table (win
);
1200 = (INTEGERP (current_buffer
->selective_display
)
1201 ? XINT (current_buffer
->selective_display
)
1202 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1204 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
1205 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
: 0);
1206 /* The next location where the `invisible' property changes, or an
1207 overlay starts or ends. */
1208 int next_boundary
= from
;
1210 /* For computing runs of characters with similar widths.
1211 Invariant: width_run_width is zero, or all the characters
1212 from width_run_start to width_run_end have a fixed width of
1214 int width_run_start
= from
;
1215 int width_run_end
= from
;
1216 int width_run_width
= 0;
1217 Lisp_Object
*width_table
;
1220 /* The next buffer pos where we should consult the width run cache. */
1221 int next_width_run
= from
;
1224 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
1225 /* If previous char scanned was a wide character,
1226 this is the column where it ended. Otherwise, this is 0. */
1227 int wide_column_end_hpos
= 0;
1228 int prev_pos
; /* Previous buffer position. */
1229 int prev_pos_byte
; /* Previous buffer position. */
1232 int contin_hpos
; /* HPOS of last column of continued line. */
1233 int prev_tab_offset
; /* Previous tab offset. */
1235 XSETBUFFER (buffer
, current_buffer
);
1236 XSETWINDOW (window
, win
);
1238 width_run_cache_on_off ();
1239 if (dp
== buffer_display_table ())
1240 width_table
= (VECTORP (current_buffer
->width_table
)
1241 ? XVECTOR (current_buffer
->width_table
)->contents
1244 /* If the window has its own display table, we can't use the width
1245 run cache, because that's based on the buffer's display table. */
1248 if (tab_width
<= 0 || tab_width
> 1000)
1251 /* Negative width means use all available text columns. */
1254 width
= window_box_text_cols (win
);
1255 /* We must make room for continuation marks if we don't have fringes. */
1256 #ifdef HAVE_WINDOW_SYSTEM
1257 if (!FRAME_WINDOW_P (XFRAME (win
->frame
)))
1265 pos
= prev_pos
= from
;
1266 pos_byte
= prev_pos_byte
= CHAR_TO_BYTE (from
);
1268 prev_tab_offset
= tab_offset
;
1271 while (pos
== next_boundary
)
1276 /* Don't skip invisible if we are already at the margin. */
1277 if (vpos
> tovpos
|| (vpos
== tovpos
&& hpos
>= tohpos
))
1279 if (contin_hpos
&& prev_hpos
== 0
1281 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1282 { /* Line breaks because we can't put the character at the
1283 previous line any more. It is not the multi-column
1284 character continued in middle. Go back to previous
1285 buffer position, screen position, and set tab offset
1286 to previous value. It's the beginning of the
1289 pos_byte
= prev_pos_byte
;
1292 tab_offset
= prev_tab_offset
;
1297 /* If the caller says that the screen position came from an earlier
1298 call to compute_motion, then we've already accounted for the
1299 overlay strings at point. This is only true the first time
1300 through, so clear the flag after testing it. */
1302 /* We need to skip past the overlay strings. Currently those
1303 strings must not contain TAB;
1304 if we want to relax that restriction, something will have
1305 to be changed here. */
1307 unsigned char *ovstr
;
1308 int ovlen
= overlay_strings (pos
, win
, &ovstr
);
1309 hpos
+= ((multibyte
&& ovlen
> 0)
1310 ? strwidth (ovstr
, ovlen
) : ovlen
);
1317 /* Advance POS past invisible characters
1318 (but not necessarily all that there are here),
1319 and store in next_boundary the next position where
1320 we need to call skip_invisible. */
1321 newpos
= skip_invisible (pos
, &next_boundary
, to
, window
);
1325 pos
= min (to
, newpos
);
1326 pos_byte
= CHAR_TO_BYTE (pos
);
1330 if (newpos
!= pos_here
)
1333 pos_byte
= CHAR_TO_BYTE (pos
);
1337 /* Handle right margin. */
1338 /* Note on a wide-column character.
1340 Characters are classified into the following three categories
1341 according to the width (columns occupied on screen).
1343 (1) single-column character: ex. `a'
1344 (2) multi-column character: ex. `^A', TAB, `\033'
1345 (3) wide-column character: ex. Japanese character, Chinese character
1346 (In the following example, `W_' stands for them.)
1348 Multi-column characters can be divided around the right margin,
1349 but wide-column characters cannot.
1353 (*) The cursor is placed on the next character after the point.
1357 j ^---- next after the point
1358 ^--- next char. after the point.
1360 In case of sigle-column character
1364 033 ^---- next after the point, next char. after the point.
1366 In case of multi-column character
1370 W_ ^---- next after the point
1371 ^---- next char. after the point.
1373 In case of wide-column character
1375 The problem here is continuation at a wide-column character.
1376 In this case, the line may shorter less than WIDTH.
1377 And we find the continuation AFTER it occurs.
1384 || (truncate_partial_width_windows
1385 && width
< FRAME_COLS (XFRAME (WINDOW_FRAME (win
))))
1386 || !NILP (current_buffer
->truncate_lines
))
1388 /* Truncating: skip to newline, unless we are already past
1389 TO (we need to go back below). */
1392 pos
= find_before_next_newline (pos
, to
, 1);
1393 pos_byte
= CHAR_TO_BYTE (pos
);
1395 /* If we just skipped next_boundary,
1396 loop around in the main while
1398 if (pos
>= next_boundary
)
1399 next_boundary
= pos
+ 1;
1402 prev_tab_offset
= tab_offset
;
1408 /* Remember the previous value. */
1409 prev_tab_offset
= tab_offset
;
1411 if (wide_column_end_hpos
> width
)
1414 tab_offset
+= prev_hpos
;
1418 tab_offset
+= width
;
1422 contin_hpos
= prev_hpos
;
1428 /* Stop if past the target buffer position or screen position. */
1431 /* Go back to the previous position. */
1433 pos_byte
= prev_pos_byte
;
1436 tab_offset
= prev_tab_offset
;
1438 /* NOTE on contin_hpos, hpos, and prev_hpos.
1442 W_ ^---- contin_hpos
1448 if (contin_hpos
&& prev_hpos
== 0
1449 && contin_hpos
< width
&& !wide_column_end_hpos
)
1451 /* Line breaking occurs in the middle of multi-column
1452 character. Go back to previous line. */
1459 if (vpos
> tovpos
|| (vpos
== tovpos
&& hpos
>= tohpos
))
1461 if (contin_hpos
&& prev_hpos
== 0
1463 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1464 { /* Line breaks because we can't put the character at the
1465 previous line any more. It is not the multi-column
1466 character continued in middle. Go back to previous
1467 buffer position, screen position, and set tab offset
1468 to previous value. It's the beginning of the
1471 pos_byte
= prev_pos_byte
;
1474 tab_offset
= prev_tab_offset
;
1478 if (pos
== ZV
) /* We cannot go beyond ZV. Stop here. */
1484 prev_pos_byte
= pos_byte
;
1485 wide_column_end_hpos
= 0;
1487 /* Consult the width run cache to see if we can avoid inspecting
1488 the text character-by-character. */
1489 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
1493 = region_cache_forward (current_buffer
,
1494 current_buffer
->width_run_cache
,
1497 /* A width of zero means the character's width varies (like
1498 a tab), is meaningless (like a newline), or we just don't
1499 want to skip over it for some other reason. */
1500 if (common_width
!= 0)
1504 /* Don't go past the final buffer posn the user
1509 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1511 /* Don't go past the final horizontal position the user
1513 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
1515 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
1516 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1519 /* Don't go past the margin. */
1520 if (run_end_hpos
>= width
)
1522 run_end
= pos
+ (width
- hpos
) / common_width
;
1523 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1526 hpos
= run_end_hpos
;
1528 prev_hpos
= hpos
- common_width
;
1532 pos_byte
= CHAR_TO_BYTE (pos
);
1536 next_width_run
= run_end
+ 1;
1539 /* We have to scan the text character-by-character. */
1543 Lisp_Object charvec
;
1545 c
= FETCH_BYTE (pos_byte
);
1547 /* Check composition sequence. */
1549 int len
, len_byte
, width
;
1551 if (check_composition (pos
, pos_byte
, to
, &len
, &len_byte
, &width
))
1554 pos_byte
+= len_byte
;
1562 /* Perhaps add some info to the width_run_cache. */
1563 if (current_buffer
->width_run_cache
)
1565 /* Is this character part of the current run? If so, extend
1567 if (pos
- 1 == width_run_end
1568 && XFASTINT (width_table
[c
]) == width_run_width
)
1569 width_run_end
= pos
;
1571 /* The previous run is over, since this is a character at a
1572 different position, or a different width. */
1575 /* Have we accumulated a run to put in the cache?
1576 (Currently, we only cache runs of width == 1). */
1577 if (width_run_start
< width_run_end
1578 && width_run_width
== 1)
1579 know_region_cache (current_buffer
,
1580 current_buffer
->width_run_cache
,
1581 width_run_start
, width_run_end
);
1583 /* Start recording a new width run. */
1584 width_run_width
= XFASTINT (width_table
[c
]);
1585 width_run_start
= pos
- 1;
1586 width_run_end
= pos
;
1591 && ! (multibyte
&& BASE_LEADING_CODE_P (c
))
1592 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1594 charvec
= DISP_CHAR_VECTOR (dp
, c
);
1595 n
= ASIZE (charvec
);
1603 for (i
= n
- 1; i
>= 0; --i
)
1605 if (VECTORP (charvec
))
1607 /* This should be handled the same as
1608 next_element_from_display_vector does it. */
1609 Lisp_Object entry
= AREF (charvec
, i
);
1611 if (INTEGERP (entry
)
1612 && GLYPH_CHAR_VALID_P (XFASTINT (entry
)))
1613 c
= FAST_GLYPH_CHAR (XFASTINT (entry
));
1618 if (c
>= 040 && c
< 0177)
1622 int tem
= ((hpos
+ tab_offset
+ hscroll
- (hscroll
> 0))
1626 hpos
+= tab_width
- tem
;
1631 && indented_beyond_p (pos
, pos_byte
,
1632 (double) selective
)) /* iftc */
1634 /* If (pos == to), we don't have to take care of
1635 selective display. */
1638 /* Skip any number of invisible lines all at once */
1641 pos
= find_before_next_newline (pos
, to
, 1);
1644 pos_byte
= CHAR_TO_BYTE (pos
);
1647 && indented_beyond_p (pos
, pos_byte
,
1648 (double) selective
)); /* iftc */
1649 /* Allow for the " ..." that is displayed for them. */
1652 hpos
+= selective_rlen
;
1656 DEC_BOTH (pos
, pos_byte
);
1657 /* We have skipped the invis text, but not the
1663 /* A visible line. */
1667 /* Count the truncation glyph on column 0 */
1674 else if (c
== CR
&& selective
< 0)
1676 /* In selective display mode,
1677 everything from a ^M to the end of the line is invisible.
1678 Stop *before* the real newline. */
1681 pos
= find_before_next_newline (pos
, to
, 1);
1682 pos_byte
= CHAR_TO_BYTE (pos
);
1684 /* If we just skipped next_boundary,
1685 loop around in the main while
1687 if (pos
> next_boundary
)
1688 next_boundary
= pos
;
1689 /* Allow for the " ..." that is displayed for them. */
1692 hpos
+= selective_rlen
;
1697 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
1699 /* Start of multi-byte form. */
1701 int bytes
, width
, wide_column
;
1703 pos_byte
--; /* rewind POS_BYTE */
1704 ptr
= BYTE_POS_ADDR (pos_byte
);
1705 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
1708 wide_column_end_hpos
= hpos
+ wide_column
;
1711 else if (VECTORP (charvec
))
1714 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
1721 /* Remember any final width run in the cache. */
1722 if (current_buffer
->width_run_cache
1723 && width_run_width
== 1
1724 && width_run_start
< width_run_end
)
1725 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
1726 width_run_start
, width_run_end
);
1728 val_compute_motion
.bufpos
= pos
;
1729 val_compute_motion
.bytepos
= pos_byte
;
1730 val_compute_motion
.hpos
= hpos
;
1731 val_compute_motion
.vpos
= vpos
;
1732 if (contin_hpos
&& prev_hpos
== 0)
1733 val_compute_motion
.prevhpos
= contin_hpos
;
1735 val_compute_motion
.prevhpos
= prev_hpos
;
1736 /* We alalways handle all of them here; none of them remain to do. */
1737 val_compute_motion
.ovstring_chars_done
= 0;
1739 /* Nonzero if have just continued a line */
1740 val_compute_motion
.contin
= (contin_hpos
&& prev_hpos
== 0);
1743 return &val_compute_motion
;
1747 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
1748 doc
: /* Scan through the current buffer, calculating screen position.
1749 Scan the current buffer forward from offset FROM,
1750 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--
1751 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--
1752 and return the ending buffer position and screen location.
1754 If TOPOS is nil, the actual width and height of the window's
1757 There are three additional arguments:
1759 WIDTH is the number of columns available to display text;
1760 this affects handling of continuation lines. A value of nil
1761 corresponds to the actual number of available text columns.
1763 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).
1764 HSCROLL is the number of columns not being displayed at the left
1765 margin; this is usually taken from a window's hscroll member.
1766 TAB-OFFSET is the number of columns of the first tab that aren't
1767 being displayed, perhaps because the line was continued within it.
1768 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.
1770 WINDOW is the window to operate on. It is used to choose the display table;
1771 if it is showing the current buffer, it is used also for
1772 deciding which overlay properties apply.
1773 Note that `compute-motion' always operates on the current buffer.
1775 The value is a list of five elements:
1776 (POS HPOS VPOS PREVHPOS CONTIN)
1777 POS is the buffer position where the scan stopped.
1778 VPOS is the vertical position where the scan stopped.
1779 HPOS is the horizontal position where the scan stopped.
1781 PREVHPOS is the horizontal position one character back from POS.
1782 CONTIN is t if a line was continued after (or within) the previous character.
1784 For example, to find the buffer position of column COL of line LINE
1785 of a certain window, pass the window's starting location as FROM
1786 and the window's upper-left coordinates as FROMPOS.
1787 Pass the buffer's (point-max) as TO, to limit the scan to the end of the
1788 visible section of the buffer, and pass LINE and COL as TOPOS. */)
1789 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1790 Lisp_Object from
, frompos
, to
, topos
;
1791 Lisp_Object width
, offsets
, window
;
1794 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
;
1795 struct position
*pos
;
1796 int hscroll
, tab_offset
;
1798 CHECK_NUMBER_COERCE_MARKER (from
);
1799 CHECK_CONS (frompos
);
1800 CHECK_NUMBER_CAR (frompos
);
1801 CHECK_NUMBER_CDR (frompos
);
1802 CHECK_NUMBER_COERCE_MARKER (to
);
1806 CHECK_NUMBER_CAR (topos
);
1807 CHECK_NUMBER_CDR (topos
);
1810 CHECK_NUMBER (width
);
1812 if (!NILP (offsets
))
1814 CHECK_CONS (offsets
);
1815 CHECK_NUMBER_CAR (offsets
);
1816 CHECK_NUMBER_CDR (offsets
);
1817 hscroll
= XINT (XCAR (offsets
));
1818 tab_offset
= XINT (XCDR (offsets
));
1821 hscroll
= tab_offset
= 0;
1824 window
= Fselected_window ();
1826 CHECK_LIVE_WINDOW (window
);
1827 w
= XWINDOW (window
);
1829 if (XINT (from
) < BEGV
|| XINT (from
) > ZV
)
1830 args_out_of_range_3 (from
, make_number (BEGV
), make_number (ZV
));
1831 if (XINT (to
) < BEGV
|| XINT (to
) > ZV
)
1832 args_out_of_range_3 (to
, make_number (BEGV
), make_number (ZV
));
1834 pos
= compute_motion (XINT (from
), XINT (XCDR (frompos
)),
1835 XINT (XCAR (frompos
)), 0,
1838 ? window_internal_height (w
)
1839 : XINT (XCDR (topos
))),
1841 ? (window_box_text_cols (w
)
1843 #ifdef HAVE_WINDOW_SYSTEM
1844 FRAME_WINDOW_P (XFRAME (w
->frame
)) ? 0 :
1847 : XINT (XCAR (topos
))),
1848 (NILP (width
) ? -1 : XINT (width
)),
1849 hscroll
, tab_offset
,
1852 XSETFASTINT (bufpos
, pos
->bufpos
);
1853 XSETINT (hpos
, pos
->hpos
);
1854 XSETINT (vpos
, pos
->vpos
);
1855 XSETINT (prevhpos
, pos
->prevhpos
);
1857 return Fcons (bufpos
,
1861 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
1865 /* Fvertical_motion and vmotion */
1867 struct position val_vmotion
;
1870 vmotion (from
, vtarget
, w
)
1871 register int from
, vtarget
;
1874 int hscroll
= XINT (w
->hscroll
);
1875 struct position pos
;
1876 /* vpos is cumulative vertical position, changed as from is changed */
1877 register int vpos
= 0;
1878 Lisp_Object prevline
;
1881 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1883 = (INTEGERP (current_buffer
->selective_display
)
1884 ? XINT (current_buffer
->selective_display
)
1885 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1889 /* This is the object we use for fetching character properties. */
1890 Lisp_Object text_prop_object
;
1892 XSETWINDOW (window
, w
);
1894 /* If the window contains this buffer, use it for getting text properties.
1895 Otherwise use the current buffer as arg for doing that. */
1896 if (EQ (w
->buffer
, Fcurrent_buffer ()))
1897 text_prop_object
= window
;
1899 text_prop_object
= Fcurrent_buffer ();
1901 if (vpos
>= vtarget
)
1903 /* To move upward, go a line at a time until
1904 we have gone at least far enough. */
1908 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1910 Lisp_Object propval
;
1912 XSETFASTINT (prevline
, find_next_newline_no_quit (from
- 1, -1));
1913 while (XFASTINT (prevline
) > BEGV
1915 && indented_beyond_p (XFASTINT (prevline
),
1916 CHAR_TO_BYTE (XFASTINT (prevline
)),
1917 (double) selective
)) /* iftc */
1918 /* watch out for newlines with `invisible' property */
1919 || (propval
= Fget_char_property (prevline
,
1922 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1923 XSETFASTINT (prevline
,
1924 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1926 pos
= *compute_motion (XFASTINT (prevline
), 0,
1927 lmargin
+ (XFASTINT (prevline
) == BEG
1931 /* Don't care for VPOS... */
1932 1 << (BITS_PER_SHORT
- 1),
1934 1 << (BITS_PER_SHORT
- 1),
1936 /* This compensates for start_hpos
1937 so that a tab as first character
1938 still occupies 8 columns. */
1939 (XFASTINT (prevline
) == BEG
1944 from
= XFASTINT (prevline
);
1947 /* If we made exactly the desired vertical distance,
1948 or if we hit beginning of buffer,
1949 return point found */
1950 if (vpos
>= vtarget
)
1952 val_vmotion
.bufpos
= from
;
1953 val_vmotion
.bytepos
= CHAR_TO_BYTE (from
);
1954 val_vmotion
.vpos
= vpos
;
1955 val_vmotion
.hpos
= lmargin
;
1956 val_vmotion
.contin
= 0;
1957 val_vmotion
.prevhpos
= 0;
1958 val_vmotion
.ovstring_chars_done
= 0;
1959 val_vmotion
.tab_offset
= 0; /* For accumulating tab offset. */
1960 return &val_vmotion
;
1963 /* Otherwise find the correct spot by moving down */
1965 /* Moving downward is simple, but must calculate from beg of line
1966 to determine hpos of starting point */
1967 from_byte
= CHAR_TO_BYTE (from
);
1968 if (from
> BEGV
&& FETCH_BYTE (from_byte
- 1) != '\n')
1970 Lisp_Object propval
;
1972 XSETFASTINT (prevline
, find_next_newline_no_quit (from
, -1));
1973 while (XFASTINT (prevline
) > BEGV
1975 && indented_beyond_p (XFASTINT (prevline
),
1976 CHAR_TO_BYTE (XFASTINT (prevline
)),
1977 (double) selective
)) /* iftc */
1978 /* watch out for newlines with `invisible' property */
1979 || (propval
= Fget_char_property (prevline
, Qinvisible
,
1981 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1982 XSETFASTINT (prevline
,
1983 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1985 pos
= *compute_motion (XFASTINT (prevline
), 0,
1986 lmargin
+ (XFASTINT (prevline
) == BEG
1990 /* Don't care for VPOS... */
1991 1 << (BITS_PER_SHORT
- 1),
1993 1 << (BITS_PER_SHORT
- 1),
1995 (XFASTINT (prevline
) == BEG
? -start_hpos
: 0),
2001 pos
.hpos
= lmargin
+ (from
== BEG
? start_hpos
: 0);
2006 return compute_motion (from
, vpos
, pos
.hpos
, did_motion
,
2007 ZV
, vtarget
, - (1 << (BITS_PER_SHORT
- 1)),
2009 pos
.tab_offset
- (from
== BEG
? start_hpos
: 0),
2013 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
2014 doc
: /* Move point to start of the screen line LINES lines down.
2015 If LINES is negative, this means moving up.
2017 This function is an ordinary cursor motion function
2018 which calculates the new position based on how text would be displayed.
2019 The new position may be the start of a line,
2020 or just the start of a continuation line.
2021 The function returns number of screen lines moved over;
2022 that usually equals LINES, but may be closer to zero
2023 if beginning or end of buffer was reached.
2025 The optional second argument WINDOW specifies the window to use for
2026 parameters such as width, horizontal scrolling, and so on.
2027 The default is to use the selected window's parameters.
2029 `vertical-motion' always uses the current buffer,
2030 regardless of which buffer is displayed in WINDOW.
2031 This is consistent with other cursor motion functions
2032 and makes it possible to use `vertical-motion' in any buffer,
2033 whether or not it is currently displayed in some window. */)
2035 Lisp_Object lines
, window
;
2040 Lisp_Object old_buffer
;
2041 struct gcpro gcpro1
;
2043 CHECK_NUMBER (lines
);
2044 if (! NILP (window
))
2045 CHECK_WINDOW (window
);
2047 window
= selected_window
;
2048 w
= XWINDOW (window
);
2051 GCPRO1 (old_buffer
);
2052 if (XBUFFER (w
->buffer
) != current_buffer
)
2054 /* Set the window's buffer temporarily to the current buffer. */
2055 old_buffer
= w
->buffer
;
2056 XSETBUFFER (w
->buffer
, current_buffer
);
2059 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
2060 start_display (&it
, w
, pt
);
2062 /* Move to the start of the display line containing PT. If we don't
2063 do this, we start moving with IT->current_x == 0, while PT is
2064 really at some x > 0. The effect is, in continuation lines, that
2065 we end up with the iterator placed at where it thinks X is 0,
2066 while the end position is really at some X > 0, the same X that
2068 move_it_by_lines (&it
, 0, 0);
2070 if (XINT (lines
) != 0)
2071 move_it_by_lines (&it
, XINT (lines
), 0);
2073 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
2075 if (BUFFERP (old_buffer
))
2076 w
->buffer
= old_buffer
;
2078 RETURN_UNGCPRO (make_number (it
.vpos
));
2083 /* File's initialization. */
2088 DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode
,
2089 doc
: /* *Indentation can insert tabs if this is non-nil.
2090 Setting this variable automatically makes it local to the current buffer. */);
2091 indent_tabs_mode
= 1;
2093 defsubr (&Scurrent_indentation
);
2094 defsubr (&Sindent_to
);
2095 defsubr (&Scurrent_column
);
2096 defsubr (&Smove_to_column
);
2097 defsubr (&Svertical_motion
);
2098 defsubr (&Scompute_motion
);
2101 /* arch-tag: 9adfea44-71f7-4988-8ee3-96da15c502cc
2102 (do not change this comment) */