1 /* Indentation functions.
2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995, 1998, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
27 #include "character.h"
29 #include "composite.h"
37 #include "intervals.h"
38 #include "dispextern.h"
39 #include "region-cache.h"
41 /* Indentation can insert tabs if this is non-zero;
42 otherwise always uses spaces. */
44 static int indent_tabs_mode
;
48 /* These three values memorize the current column to avoid recalculation. */
50 /* Last value returned by current_column.
51 Some things in set last_known_column_point to -1
52 to mark the memorized value as invalid. */
54 static double last_known_column
;
56 /* Value of point when current_column was called. */
58 EMACS_INT last_known_column_point
;
60 /* Value of MODIFF when current_column was called. */
62 static int last_known_column_modified
;
64 static double current_column_1 (void);
65 static double position_indentation (int);
67 /* Cache of beginning of line found by the last call of
70 static EMACS_INT current_column_bol_cache
;
72 /* Get the display table to use for the current buffer. */
74 struct Lisp_Char_Table
*
75 buffer_display_table (void)
79 thisbuf
= current_buffer
->display_table
;
80 if (DISP_TABLE_P (thisbuf
))
81 return XCHAR_TABLE (thisbuf
);
82 if (DISP_TABLE_P (Vstandard_display_table
))
83 return XCHAR_TABLE (Vstandard_display_table
);
87 /* Width run cache considerations. */
89 /* Return the width of character C under display table DP. */
92 character_width (int c
, struct Lisp_Char_Table
*dp
)
96 /* These width computations were determined by examining the cases
97 in display_text_line. */
99 /* Everything can be handled by the display table, if it's
100 present and the element is right. */
101 if (dp
&& (elt
= DISP_CHAR_VECTOR (dp
, c
), VECTORP (elt
)))
102 return XVECTOR (elt
)->size
;
104 /* Some characters are special. */
105 if (c
== '\n' || c
== '\t' || c
== '\015')
108 /* Printing characters have width 1. */
109 else if (c
>= 040 && c
< 0177)
112 /* Everybody else (control characters, metacharacters) has other
113 widths. We could return their actual widths here, but they
114 depend on things like ctl_arrow and crud like that, and they're
115 not very common at all. So we'll just claim we don't know their
121 /* Return true if the display table DISPTAB specifies the same widths
122 for characters as WIDTHTAB. We use this to decide when to
123 invalidate the buffer's width_run_cache. */
126 disptab_matches_widthtab (struct Lisp_Char_Table
*disptab
, 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 (struct buffer
*buf
, struct Lisp_Char_Table
*disptab
)
147 struct Lisp_Vector
*widthtab
;
149 if (!VECTORP (buf
->width_table
))
150 buf
->width_table
= Fmake_vector (make_number (256), make_number (0));
151 widthtab
= XVECTOR (buf
->width_table
);
152 if (widthtab
->size
!= 256)
155 for (i
= 0; i
< 256; i
++)
156 XSETFASTINT (widthtab
->contents
[i
], character_width (i
, disptab
));
159 /* Allocate or free the width run cache, as requested by the current
160 state of current_buffer's cache_long_line_scans variable. */
163 width_run_cache_on_off (void)
165 if (NILP (current_buffer
->cache_long_line_scans
)
166 /* And, for the moment, this feature doesn't work on multibyte
168 || !NILP (current_buffer
->enable_multibyte_characters
))
170 /* It should be off. */
171 if (current_buffer
->width_run_cache
)
173 free_region_cache (current_buffer
->width_run_cache
);
174 current_buffer
->width_run_cache
= 0;
175 current_buffer
->width_table
= Qnil
;
180 /* It should be on. */
181 if (current_buffer
->width_run_cache
== 0)
183 current_buffer
->width_run_cache
= new_region_cache ();
184 recompute_width_table (current_buffer
, buffer_display_table ());
190 /* Skip some invisible characters starting from POS.
191 This includes characters invisible because of text properties
192 and characters invisible because of overlays.
194 If position POS is followed by invisible characters,
195 skip some of them and return the position after them.
196 Otherwise return POS itself.
198 Set *NEXT_BOUNDARY_P to the next position at which
199 it will be necessary to call this function again.
201 Don't scan past TO, and don't set *NEXT_BOUNDARY_P
202 to a value greater than TO.
204 If WINDOW is non-nil, and this buffer is displayed in WINDOW,
205 take account of overlays that apply only in WINDOW.
207 We don't necessarily skip all the invisible characters after POS
208 because that could take a long time. We skip a reasonable number
209 which can be skipped quickly. If there might be more invisible
210 characters immediately following, then *NEXT_BOUNDARY_P
211 will equal the return value. */
214 skip_invisible (EMACS_INT pos
, EMACS_INT
*next_boundary_p
, EMACS_INT to
, Lisp_Object window
)
216 Lisp_Object prop
, position
, overlay_limit
, proplimit
;
217 Lisp_Object buffer
, tmp
;
221 XSETFASTINT (position
, pos
);
222 XSETBUFFER (buffer
, current_buffer
);
224 /* Give faster response for overlay lookup near POS. */
225 recenter_overlay_lists (current_buffer
, pos
);
227 /* We must not advance farther than the next overlay change.
228 The overlay change might change the invisible property;
229 or there might be overlay strings to be displayed there. */
230 overlay_limit
= Fnext_overlay_change (position
);
231 /* As for text properties, this gives a lower bound
232 for where the invisible text property could change. */
233 proplimit
= Fnext_property_change (position
, buffer
, Qt
);
234 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
235 proplimit
= overlay_limit
;
236 /* PROPLIMIT is now a lower bound for the next change
237 in invisible status. If that is plenty far away,
238 use that lower bound. */
239 if (XFASTINT (proplimit
) > pos
+ 100 || XFASTINT (proplimit
) >= to
)
240 *next_boundary_p
= XFASTINT (proplimit
);
241 /* Otherwise, scan for the next `invisible' property change. */
244 /* Don't scan terribly far. */
245 XSETFASTINT (proplimit
, min (pos
+ 100, to
));
246 /* No matter what, don't go past next overlay change. */
247 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
248 proplimit
= overlay_limit
;
249 tmp
= Fnext_single_property_change (position
, Qinvisible
,
251 end
= XFASTINT (tmp
);
253 /* Don't put the boundary in the middle of multibyte form if
254 there is no actual property change. */
256 && !NILP (current_buffer
->enable_multibyte_characters
)
258 while (pos
< end
&& !CHAR_HEAD_P (POS_ADDR (end
)))
261 *next_boundary_p
= end
;
263 /* if the `invisible' property is set, we can skip to
264 the next property change */
265 prop
= Fget_char_property (position
, Qinvisible
,
267 && EQ (XWINDOW (window
)->buffer
, buffer
))
269 inv_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
270 /* When counting columns (window == nil), don't skip over ellipsis text. */
271 if (NILP (window
) ? inv_p
== 1 : inv_p
)
272 return *next_boundary_p
;
276 /* Set variables WIDTH and BYTES for a multibyte sequence starting at P.
278 DP is a display table or NULL.
280 This macro is used in current_column_1, Fmove_to_column, and
283 #define MULTIBYTE_BYTES_WIDTH(p, dp) \
288 c = STRING_CHAR_AND_LENGTH (p, bytes); \
289 if (BYTES_BY_CHAR_HEAD (*p) != bytes) \
293 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c))) \
294 width = XVECTOR (DISP_CHAR_VECTOR (dp, c))->size; \
296 width = CHAR_WIDTH (c); \
298 wide_column = width; \
303 DEFUN ("current-column", Fcurrent_column
, Scurrent_column
, 0, 0, 0,
304 doc
: /* Return the horizontal position of point. Beginning of line is column 0.
305 This is calculated by adding together the widths of all the displayed
306 representations of the character between the start of the previous line
307 and point (eg. control characters will have a width of 2 or 4, tabs
308 will have a variable width).
309 Ignores finite width of frame, which means that this function may return
310 values greater than (frame-width).
311 Whether the line is visible (if `selective-display' is t) has no effect;
312 however, ^M is treated as end of line when `selective-display' is t.
313 Text that has an invisible property is considered as having width 0, unless
314 `buffer-invisibility-spec' specifies that it is replaced by an ellipsis. */)
318 XSETFASTINT (temp
, (int) current_column ()); /* iftc */
322 /* Cancel any recorded value of the horizontal position. */
325 invalidate_current_column (void)
327 last_known_column_point
= 0;
331 current_column (void)
334 register unsigned char *ptr
, *stop
;
335 register int tab_seen
;
338 register int tab_width
= XINT (current_buffer
->tab_width
);
339 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
340 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
342 if (PT
== last_known_column_point
343 && MODIFF
== last_known_column_modified
)
344 return last_known_column
;
346 /* If the buffer has overlays, text properties,
347 or multibyte characters, use a more general algorithm. */
348 if (BUF_INTERVALS (current_buffer
)
349 || current_buffer
->overlays_before
350 || current_buffer
->overlays_after
352 return current_column_1 ();
354 /* Scan backwards from point to the previous newline,
355 counting width. Tab characters are the only complicated case. */
357 /* Make a pointer for decrementing through the chars before point. */
358 ptr
= BYTE_POS_ADDR (PT_BYTE
- 1) + 1;
359 /* Make a pointer to where consecutive chars leave off,
360 going backwards from point. */
363 else if (PT
<= GPT
|| BEGV
> GPT
)
368 if (tab_width
<= 0 || tab_width
> 1000)
371 col
= 0, tab_seen
= 0, post_tab
= 0;
380 /* We stopped either for the beginning of the buffer
382 if (ptr
== BEGV_ADDR
)
385 /* It was the gap. Jump back over it. */
389 /* Check whether that brings us to beginning of buffer. */
396 if (dp
&& VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
398 charvec
= DISP_CHAR_VECTOR (dp
, c
);
407 for (i
= n
- 1; i
>= 0; --i
)
409 if (VECTORP (charvec
))
411 /* This should be handled the same as
412 next_element_from_display_vector does it. */
413 Lisp_Object entry
= AREF (charvec
, i
);
415 if (GLYPH_CODE_P (entry
)
416 && GLYPH_CODE_CHAR_VALID_P (entry
))
417 c
= GLYPH_CODE_CHAR (entry
);
422 if (c
>= 040 && c
< 0177)
426 && EQ (current_buffer
->selective_display
, Qt
)))
429 goto start_of_line_found
;
434 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
440 else if (VECTORP (charvec
))
441 /* With a display table entry, C is displayed as is, and
442 not displayed as \NNN or as ^N. If C is a single-byte
443 character, it takes one column. If C is multi-byte in
444 an unibyte buffer, it's translated to unibyte, so it
445 also takes one column. */
448 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
456 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
460 if (ptr
== BEGV_ADDR
)
461 current_column_bol_cache
= BEGV
;
463 current_column_bol_cache
= BYTE_TO_CHAR (PTR_BYTE_POS (ptr
));
465 last_known_column
= col
;
466 last_known_column_point
= PT
;
467 last_known_column_modified
= MODIFF
;
472 extern Lisp_Object Qspace
, QCwidth
, QCalign_to
;
474 /* Check the presence of a display property and compute its width.
475 If a property was found and its width was found as well, return
476 its width (>= 0) and set the position of the end of the property
478 Otherwise just return -1. */
480 check_display_width (EMACS_INT pos
, EMACS_INT col
, EMACS_INT
*endpos
)
482 Lisp_Object val
, overlay
;
484 if (CONSP (val
= get_char_property_and_overlay
485 (make_number (pos
), Qdisplay
, Qnil
, &overlay
))
486 && EQ (Qspace
, XCAR (val
)))
487 { /* FIXME: Use calc_pixel_width_or_height, as in term.c. */
488 Lisp_Object plist
= XCDR (val
), prop
;
491 if ((prop
= Fplist_get (plist
, QCwidth
), NATNUMP (prop
)))
493 else if (FLOATP (prop
))
494 width
= (int)(XFLOAT_DATA (prop
) + 0.5);
495 else if ((prop
= Fplist_get (plist
, QCalign_to
), NATNUMP (prop
)))
496 width
= XINT (prop
) - col
;
497 else if (FLOATP (prop
))
498 width
= (int)(XFLOAT_DATA (prop
) + 0.5) - col
;
503 if (OVERLAYP (overlay
))
504 *endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
506 get_property_and_range (pos
, Qdisplay
, &val
, &start
, endpos
, Qnil
);
513 /* Scanning from the beginning of the current line, stop at the buffer
514 position ENDPOS or at the column GOALCOL or at the end of line, whichever
516 Return the resulting buffer position and column in ENDPOS and GOALCOL.
517 PREVCOL gets set to the column of the previous position (it's always
518 strictly smaller than the goal column). */
520 scan_for_column (EMACS_INT
*endpos
, EMACS_INT
*goalcol
, EMACS_INT
*prevcol
)
522 register EMACS_INT tab_width
= XINT (current_buffer
->tab_width
);
523 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
524 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
525 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
526 struct composition_it cmp_it
;
530 /* Start the scan at the beginning of this line with column number 0. */
531 register EMACS_INT col
= 0, prev_col
= 0;
532 EMACS_INT goal
= goalcol
? *goalcol
: MOST_POSITIVE_FIXNUM
;
533 EMACS_INT end
= endpos
? *endpos
: PT
;
534 EMACS_INT scan
, scan_byte
;
535 EMACS_INT next_boundary
;
537 EMACS_INT opoint
= PT
, opoint_byte
= PT_BYTE
;
538 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
539 current_column_bol_cache
= PT
;
540 scan
= PT
, scan_byte
= PT_BYTE
;
541 SET_PT_BOTH (opoint
, opoint_byte
);
542 next_boundary
= scan
;
545 window
= Fget_buffer_window (Fcurrent_buffer (), Qnil
);
546 w
= ! NILP (window
) ? XWINDOW (window
) : NULL
;
548 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
549 bzero (&cmp_it
, sizeof cmp_it
);
551 composition_compute_stop_pos (&cmp_it
, scan
, scan_byte
, end
, Qnil
);
553 /* Scan forward to the target position. */
558 /* Occasionally we may need to skip invisible text. */
559 while (scan
== next_boundary
)
561 EMACS_INT old_scan
= scan
;
562 /* This updates NEXT_BOUNDARY to the next place
563 where we might need to skip more invisible text. */
564 scan
= skip_invisible (scan
, &next_boundary
, end
, Qnil
);
565 if (scan
!= old_scan
)
566 scan_byte
= CHAR_TO_BYTE (scan
);
571 /* Test reaching the goal column. We do this after skipping
572 invisible characters, so that we put point before the
573 character on which the cursor will appear. */
578 { /* Check display property. */
580 int width
= check_display_width (scan
, col
, &end
);
584 if (end
> scan
) /* Avoid infinite loops with 0-width overlays. */
586 scan
= end
; scan_byte
= charpos_to_bytepos (scan
);
592 /* Check composition sequence. */
594 || (scan
== cmp_it
.stop_pos
595 && composition_reseat_it (&cmp_it
, scan
, scan_byte
, end
,
597 composition_update_it (&cmp_it
, scan
, scan_byte
, Qnil
);
600 scan
+= cmp_it
.nchars
;
601 scan_byte
+= cmp_it
.nbytes
;
604 if (cmp_it
.to
== cmp_it
.nglyphs
)
607 composition_compute_stop_pos (&cmp_it
, scan
, scan_byte
, end
,
611 cmp_it
.from
= cmp_it
.to
;
615 c
= FETCH_BYTE (scan_byte
);
617 /* See if there is a display table and it relates
618 to this character. */
621 && ! (multibyte
&& LEADING_CODE_P (c
))
622 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
627 /* This character is displayed using a vector of glyphs.
628 Update the column/position based on those glyphs. */
630 charvec
= DISP_CHAR_VECTOR (dp
, c
);
633 for (i
= 0; i
< n
; i
++)
635 /* This should be handled the same as
636 next_element_from_display_vector does it. */
637 Lisp_Object entry
= AREF (charvec
, i
);
639 if (GLYPH_CODE_P (entry
)
640 && GLYPH_CODE_CHAR_VALID_P (entry
))
641 c
= GLYPH_CODE_CHAR (entry
);
647 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
652 col
= col
/ tab_width
* tab_width
;
660 /* The display table doesn't affect this character;
661 it displays as itself. */
665 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
670 col
= col
/ tab_width
* tab_width
;
672 else if (multibyte
&& LEADING_CODE_P (c
))
674 /* Start of multi-byte form. */
676 int bytes
, width
, wide_column
;
678 ptr
= BYTE_POS_ADDR (scan_byte
);
679 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
680 /* Subtract one to compensate for the increment
681 that is going to happen below. */
682 scan_byte
+= bytes
- 1;
685 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
687 else if (c
< 040 || c
>= 0177)
698 last_known_column
= col
;
699 last_known_column_point
= PT
;
700 last_known_column_modified
= MODIFF
;
710 /* Return the column number of position POS
711 by scanning forward from the beginning of the line.
712 This function handles characters that are invisible
713 due to text properties or overlays. */
716 current_column_1 (void)
718 EMACS_INT col
= MOST_POSITIVE_FIXNUM
;
719 EMACS_INT opoint
= PT
;
721 scan_for_column (&opoint
, &col
, NULL
);
726 #if 0 /* Not used. */
728 /* Return the width in columns of the part of STRING from BEG to END.
729 If BEG is nil, that stands for the beginning of STRING.
730 If END is nil, that stands for the end of STRING. */
733 string_display_width (string
, beg
, end
)
734 Lisp_Object string
, beg
, end
;
737 register unsigned char *ptr
, *stop
;
738 register int tab_seen
;
741 register int tab_width
= XINT (current_buffer
->tab_width
);
742 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
743 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
762 /* Make a pointer for decrementing through the chars before point. */
763 ptr
= SDATA (string
) + e
;
764 /* Make a pointer to where consecutive chars leave off,
765 going backwards from point. */
766 stop
= SDATA (string
) + b
;
768 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
770 col
= 0, tab_seen
= 0, post_tab
= 0;
778 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
779 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
780 else if (c
>= 040 && c
< 0177)
787 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
794 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
799 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
809 DEFUN ("indent-to", Findent_to
, Sindent_to
, 1, 2, "NIndent to column: ",
810 doc
: /* Indent from point with tabs and spaces until COLUMN is reached.
811 Optional second argument MINIMUM says always do at least MINIMUM spaces
812 even if that goes past COLUMN; by default, MINIMUM is zero.
814 The return value is COLUMN. */)
816 Lisp_Object column
, minimum
;
819 register int fromcol
;
820 register int tab_width
= XINT (current_buffer
->tab_width
);
822 CHECK_NUMBER (column
);
824 XSETFASTINT (minimum
, 0);
825 CHECK_NUMBER (minimum
);
827 fromcol
= current_column ();
828 mincol
= fromcol
+ XINT (minimum
);
829 if (mincol
< XINT (column
)) mincol
= XINT (column
);
831 if (fromcol
== mincol
)
832 return make_number (mincol
);
834 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
836 if (indent_tabs_mode
)
839 XSETFASTINT (n
, mincol
/ tab_width
- fromcol
/ tab_width
);
840 if (XFASTINT (n
) != 0)
842 Finsert_char (make_number ('\t'), n
, Qt
);
844 fromcol
= (mincol
/ tab_width
) * tab_width
;
848 XSETFASTINT (column
, mincol
- fromcol
);
849 Finsert_char (make_number (' '), column
, Qt
);
851 last_known_column
= mincol
;
852 last_known_column_point
= PT
;
853 last_known_column_modified
= MODIFF
;
855 XSETINT (column
, mincol
);
860 static double position_indentation (int);
862 DEFUN ("current-indentation", Fcurrent_indentation
, Scurrent_indentation
,
864 doc
: /* Return the indentation of the current line.
865 This is the horizontal position of the character
866 following any initial whitespace. */)
870 int opoint
= PT
, opoint_byte
= PT_BYTE
;
872 scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, -1, 1);
874 XSETFASTINT (val
, (int) position_indentation (PT_BYTE
)); /* iftc */
875 SET_PT_BOTH (opoint
, opoint_byte
);
880 position_indentation (register int pos_byte
)
882 register EMACS_INT column
= 0;
883 register EMACS_INT tab_width
= XINT (current_buffer
->tab_width
);
884 register unsigned char *p
;
885 register unsigned char *stop
;
886 unsigned char *start
;
887 EMACS_INT next_boundary_byte
= pos_byte
;
888 EMACS_INT ceiling
= next_boundary_byte
;
890 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
892 p
= BYTE_POS_ADDR (pos_byte
);
893 /* STOP records the value of P at which we will need
894 to think about the gap, or about invisible text,
895 or about the end of the buffer. */
897 /* START records the starting value of P. */
903 EMACS_INT stop_pos_byte
;
905 /* If we have updated P, set POS_BYTE to match.
906 The first time we enter the loop, POS_BYTE is already right. */
908 pos_byte
= PTR_BYTE_POS (p
);
909 /* Consider the various reasons STOP might have been set here. */
910 if (pos_byte
== ZV_BYTE
)
912 if (pos_byte
== next_boundary_byte
)
914 EMACS_INT next_boundary
;
915 EMACS_INT pos
= BYTE_TO_CHAR (pos_byte
);
916 pos
= skip_invisible (pos
, &next_boundary
, ZV
, Qnil
);
917 pos_byte
= CHAR_TO_BYTE (pos
);
918 next_boundary_byte
= CHAR_TO_BYTE (next_boundary
);
920 if (pos_byte
>= ceiling
)
921 ceiling
= BUFFER_CEILING_OF (pos_byte
) + 1;
922 /* Compute the next place we need to stop and think,
923 and set STOP accordingly. */
924 stop_pos_byte
= min (ceiling
, next_boundary_byte
);
925 /* The -1 and +1 arrange to point at the first byte of gap
926 (if STOP_POS_BYTE is the position of the gap)
927 rather than at the data after the gap. */
929 stop
= BYTE_POS_ADDR (stop_pos_byte
- 1) + 1;
930 p
= BYTE_POS_ADDR (pos_byte
);
935 if (! NILP (current_buffer
->enable_multibyte_characters
))
941 column
+= tab_width
- column
% tab_width
;
944 if (ASCII_BYTE_P (p
[-1])
945 || NILP (current_buffer
->enable_multibyte_characters
))
949 pos_byte
= PTR_BYTE_POS (p
- 1);
950 c
= FETCH_MULTIBYTE_CHAR (pos_byte
);
951 if (CHAR_HAS_CATEGORY (c
, ' '))
955 p
= BYTE_POS_ADDR (pos_byte
);
964 /* Test whether the line beginning at POS is indented beyond COLUMN.
965 Blank lines are treated as if they had the same indentation as the
969 indented_beyond_p (int pos
, int pos_byte
, double column
)
972 int opoint
= PT
, opoint_byte
= PT_BYTE
;
974 SET_PT_BOTH (pos
, pos_byte
);
975 while (PT
> BEGV
&& FETCH_BYTE (PT_BYTE
) == '\n')
976 scan_newline (PT
- 1, PT_BYTE
- 1, BEGV
, BEGV_BYTE
, -1, 0);
978 val
= position_indentation (PT_BYTE
);
979 SET_PT_BOTH (opoint
, opoint_byte
);
980 return val
>= column
; /* hmm, float comparison */
983 DEFUN ("move-to-column", Fmove_to_column
, Smove_to_column
, 1, 2, "p",
984 doc
: /* Move point to column COLUMN in the current line.
985 Interactively, COLUMN is the value of prefix numeric argument.
986 The column of a character is calculated by adding together the widths
987 as displayed of the previous characters in the line.
988 This function ignores line-continuation;
989 there is no upper limit on the column number a character can have
990 and horizontal scrolling has no effect.
992 If specified column is within a character, point goes after that character.
993 If it's past end of line, point goes to end of line.
995 Optional second argument FORCE non-nil means if COLUMN is in the
996 middle of a tab character, change it to spaces.
997 In addition, if FORCE is t, and the line is too short to reach
998 COLUMN, add spaces/tabs to get there.
1000 The return value is the current column. */)
1002 Lisp_Object column
, force
;
1005 EMACS_INT col
, prev_col
;
1008 CHECK_NATNUM (column
);
1009 goal
= XINT (column
);
1013 scan_for_column (&pos
, &col
, &prev_col
);
1017 /* If a tab char made us overshoot, change it to spaces
1018 and scan through it again. */
1019 if (!NILP (force
) && col
> goal
)
1022 EMACS_INT pos_byte
= PT_BYTE
;
1025 c
= FETCH_CHAR (pos_byte
);
1026 if (c
== '\t' && prev_col
< goal
)
1028 EMACS_INT goal_pt
, goal_pt_byte
;
1030 /* Insert spaces in front of the tab to reach GOAL. Do this
1031 first so that a marker at the end of the tab gets
1033 SET_PT_BOTH (PT
- 1, PT_BYTE
- 1);
1034 Finsert_char (make_number (' '), make_number (goal
- prev_col
), Qt
);
1036 /* Now delete the tab, and indent to COL. */
1037 del_range (PT
, PT
+ 1);
1039 goal_pt_byte
= PT_BYTE
;
1040 Findent_to (make_number (col
), Qnil
);
1041 SET_PT_BOTH (goal_pt
, goal_pt_byte
);
1043 /* Set the last_known... vars consistently. */
1048 /* If line ends prematurely, add space to the end. */
1049 if (col
< goal
&& EQ (force
, Qt
))
1050 Findent_to (make_number (col
= goal
), Qnil
);
1052 last_known_column
= col
;
1053 last_known_column_point
= PT
;
1054 last_known_column_modified
= MODIFF
;
1056 return make_number (col
);
1059 /* compute_motion: compute buffer posn given screen posn and vice versa */
1061 struct position val_compute_motion
;
1063 /* Scan the current buffer forward from offset FROM, pretending that
1064 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
1065 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
1066 and return the ending buffer position and screen location. If we
1067 can't hit the requested column exactly (because of a tab or other
1068 multi-column character), overshoot.
1070 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
1071 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
1072 earlier call to compute_motion. The other common case is that FROMHPOS
1073 is zero and FROM is a position that "belongs" at column zero, but might
1074 be shifted by overlay strings; in this case DID_MOTION should be 0.
1076 WIDTH is the number of columns available to display text;
1077 compute_motion uses this to handle continuation lines and such.
1078 If WIDTH is -1, use width of window's text area adjusted for
1079 continuation glyph when needed.
1081 HSCROLL is the number of columns not being displayed at the left
1082 margin; this is usually taken from a window's hscroll member.
1083 TAB_OFFSET is the number of columns of the first tab that aren't
1084 being displayed, perhaps because of a continuation line or
1087 compute_motion returns a pointer to a struct position. The bufpos
1088 member gives the buffer position at the end of the scan, and hpos
1089 and vpos give its cartesian location. prevhpos is the column at
1090 which the character before bufpos started, and contin is non-zero
1091 if we reached the current line by continuing the previous.
1093 Note that FROMHPOS and TOHPOS should be expressed in real screen
1094 columns, taking HSCROLL and the truncation glyph at the left margin
1095 into account. That is, beginning-of-line moves you to the hpos
1096 -HSCROLL + (HSCROLL > 0).
1098 For example, to find the buffer position of column COL of line LINE
1099 of a certain window, pass the window's starting location as FROM
1100 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
1101 Pass the buffer's ZV as TO, to limit the scan to the end of the
1102 visible section of the buffer, and pass LINE and COL as TOVPOS and
1105 When displaying in window w, a typical formula for WIDTH is:
1108 - (has_vertical_scroll_bars
1109 ? WINDOW_CONFIG_SCROLL_BAR_COLS (window)
1110 : (window_width + window_left != frame_cols))
1113 window_width is XFASTINT (w->total_cols),
1114 window_left is XFASTINT (w->left_col),
1115 has_vertical_scroll_bars is
1116 WINDOW_HAS_VERTICAL_SCROLL_BAR (window)
1117 and frame_cols = FRAME_COLS (XFRAME (window->frame))
1119 Or you can let window_box_text_cols do this all for you, and write:
1120 window_box_text_cols (w) - 1
1122 The `-1' accounts for the continuation-line backslashes; the rest
1123 accounts for window borders if the window is split horizontally, and
1124 the scroll bars if they are turned on. */
1127 compute_motion (EMACS_INT from
, EMACS_INT fromvpos
, EMACS_INT fromhpos
, int did_motion
, EMACS_INT to
, EMACS_INT tovpos
, EMACS_INT tohpos
, EMACS_INT width
, EMACS_INT hscroll
, EMACS_INT tab_offset
, struct window
*win
)
1129 register EMACS_INT hpos
= fromhpos
;
1130 register EMACS_INT vpos
= fromvpos
;
1132 register EMACS_INT pos
;
1135 register EMACS_INT tab_width
= XFASTINT (current_buffer
->tab_width
);
1136 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
1137 register struct Lisp_Char_Table
*dp
= window_display_table (win
);
1139 = (INTEGERP (current_buffer
->selective_display
)
1140 ? XINT (current_buffer
->selective_display
)
1141 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1143 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
1144 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
: 0);
1145 /* The next location where the `invisible' property changes, or an
1146 overlay starts or ends. */
1147 EMACS_INT next_boundary
= from
;
1149 /* For computing runs of characters with similar widths.
1150 Invariant: width_run_width is zero, or all the characters
1151 from width_run_start to width_run_end have a fixed width of
1153 EMACS_INT width_run_start
= from
;
1154 EMACS_INT width_run_end
= from
;
1155 EMACS_INT width_run_width
= 0;
1156 Lisp_Object
*width_table
;
1159 /* The next buffer pos where we should consult the width run cache. */
1160 EMACS_INT next_width_run
= from
;
1163 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
1164 /* If previous char scanned was a wide character,
1165 this is the column where it ended. Otherwise, this is 0. */
1166 EMACS_INT wide_column_end_hpos
= 0;
1167 EMACS_INT prev_pos
; /* Previous buffer position. */
1168 EMACS_INT prev_pos_byte
; /* Previous buffer position. */
1169 EMACS_INT prev_hpos
= 0;
1170 EMACS_INT prev_vpos
= 0;
1171 EMACS_INT contin_hpos
; /* HPOS of last column of continued line. */
1172 EMACS_INT prev_tab_offset
; /* Previous tab offset. */
1173 EMACS_INT continuation_glyph_width
;
1175 struct composition_it cmp_it
;
1177 XSETBUFFER (buffer
, current_buffer
);
1178 XSETWINDOW (window
, win
);
1180 width_run_cache_on_off ();
1181 if (dp
== buffer_display_table ())
1182 width_table
= (VECTORP (current_buffer
->width_table
)
1183 ? XVECTOR (current_buffer
->width_table
)->contents
1186 /* If the window has its own display table, we can't use the width
1187 run cache, because that's based on the buffer's display table. */
1190 if (tab_width
<= 0 || tab_width
> 1000)
1193 /* Negative width means use all available text columns. */
1196 width
= window_box_text_cols (win
);
1197 /* We must make room for continuation marks if we don't have fringes. */
1198 #ifdef HAVE_WINDOW_SYSTEM
1199 if (!FRAME_WINDOW_P (XFRAME (win
->frame
)))
1204 continuation_glyph_width
= 1;
1205 #ifdef HAVE_WINDOW_SYSTEM
1206 if (FRAME_WINDOW_P (XFRAME (win
->frame
)))
1207 continuation_glyph_width
= 0; /* In the fringe. */
1213 pos
= prev_pos
= from
;
1214 pos_byte
= prev_pos_byte
= CHAR_TO_BYTE (from
);
1216 prev_tab_offset
= tab_offset
;
1217 bzero (&cmp_it
, sizeof cmp_it
);
1219 composition_compute_stop_pos (&cmp_it
, pos
, pos_byte
, to
, Qnil
);
1223 while (pos
== next_boundary
)
1225 EMACS_INT pos_here
= pos
;
1228 /* Don't skip invisible if we are already at the margin. */
1229 if (vpos
> tovpos
|| (vpos
== tovpos
&& hpos
>= tohpos
))
1231 if (contin_hpos
&& prev_hpos
== 0
1233 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1234 { /* Line breaks because we can't put the character at the
1235 previous line any more. It is not the multi-column
1236 character continued in middle. Go back to previous
1237 buffer position, screen position, and set tab offset
1238 to previous value. It's the beginning of the
1241 pos_byte
= prev_pos_byte
;
1244 tab_offset
= prev_tab_offset
;
1249 /* If the caller says that the screen position came from an earlier
1250 call to compute_motion, then we've already accounted for the
1251 overlay strings at point. This is only true the first time
1252 through, so clear the flag after testing it. */
1254 /* We need to skip past the overlay strings. Currently those
1255 strings must not contain TAB;
1256 if we want to relax that restriction, something will have
1257 to be changed here. */
1259 unsigned char *ovstr
;
1260 int ovlen
= overlay_strings (pos
, win
, &ovstr
);
1261 hpos
+= ((multibyte
&& ovlen
> 0)
1262 ? strwidth (ovstr
, ovlen
) : ovlen
);
1269 /* Advance POS past invisible characters
1270 (but not necessarily all that there are here),
1271 and store in next_boundary the next position where
1272 we need to call skip_invisible. */
1273 newpos
= skip_invisible (pos
, &next_boundary
, to
, window
);
1277 pos
= min (to
, newpos
);
1278 pos_byte
= CHAR_TO_BYTE (pos
);
1282 if (newpos
!= pos_here
)
1285 pos_byte
= CHAR_TO_BYTE (pos
);
1289 /* Handle right margin. */
1290 /* Note on a wide-column character.
1292 Characters are classified into the following three categories
1293 according to the width (columns occupied on screen).
1295 (1) single-column character: ex. `a'
1296 (2) multi-column character: ex. `^A', TAB, `\033'
1297 (3) wide-column character: ex. Japanese character, Chinese character
1298 (In the following example, `W_' stands for them.)
1300 Multi-column characters can be divided around the right margin,
1301 but wide-column characters cannot.
1305 (*) The cursor is placed on the next character after the point.
1309 j ^---- next after the point
1310 ^--- next char. after the point.
1312 In case of sigle-column character
1316 033 ^---- next after the point, next char. after the point.
1318 In case of multi-column character
1322 W_ ^---- next after the point
1323 ^---- next char. after the point.
1325 In case of wide-column character
1327 The problem here is continuation at a wide-column character.
1328 In this case, the line may shorter less than WIDTH.
1329 And we find the continuation AFTER it occurs.
1335 int total_width
= width
+ continuation_glyph_width
;
1338 if (!NILP (Vtruncate_partial_width_windows
)
1339 && (total_width
< FRAME_COLS (XFRAME (WINDOW_FRAME (win
)))))
1341 if (INTEGERP (Vtruncate_partial_width_windows
))
1343 = total_width
< XFASTINT (Vtruncate_partial_width_windows
);
1348 if (hscroll
|| truncate
1349 || !NILP (current_buffer
->truncate_lines
))
1351 /* Truncating: skip to newline, unless we are already past
1352 TO (we need to go back below). */
1355 pos
= find_before_next_newline (pos
, to
, 1);
1356 pos_byte
= CHAR_TO_BYTE (pos
);
1358 /* If we just skipped next_boundary,
1359 loop around in the main while
1361 if (pos
>= next_boundary
)
1362 next_boundary
= pos
+ 1;
1365 prev_tab_offset
= tab_offset
;
1371 /* Remember the previous value. */
1372 prev_tab_offset
= tab_offset
;
1374 if (wide_column_end_hpos
> width
)
1377 tab_offset
+= prev_hpos
;
1381 tab_offset
+= width
;
1385 contin_hpos
= prev_hpos
;
1391 /* Stop if past the target buffer position or screen position. */
1394 /* Go back to the previous position. */
1396 pos_byte
= prev_pos_byte
;
1399 tab_offset
= prev_tab_offset
;
1401 /* NOTE on contin_hpos, hpos, and prev_hpos.
1405 W_ ^---- contin_hpos
1411 if (contin_hpos
&& prev_hpos
== 0
1412 && contin_hpos
< width
&& !wide_column_end_hpos
)
1414 /* Line breaking occurs in the middle of multi-column
1415 character. Go back to previous line. */
1422 if (vpos
> tovpos
|| (vpos
== tovpos
&& hpos
>= tohpos
))
1424 if (contin_hpos
&& prev_hpos
== 0
1426 && (contin_hpos
== width
|| wide_column_end_hpos
> width
))
1427 { /* Line breaks because we can't put the character at the
1428 previous line any more. It is not the multi-column
1429 character continued in middle. Go back to previous
1430 buffer position, screen position, and set tab offset
1431 to previous value. It's the beginning of the
1434 pos_byte
= prev_pos_byte
;
1437 tab_offset
= prev_tab_offset
;
1441 if (pos
== ZV
) /* We cannot go beyond ZV. Stop here. */
1447 prev_pos_byte
= pos_byte
;
1448 wide_column_end_hpos
= 0;
1450 /* Consult the width run cache to see if we can avoid inspecting
1451 the text character-by-character. */
1452 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
1456 = region_cache_forward (current_buffer
,
1457 current_buffer
->width_run_cache
,
1460 /* A width of zero means the character's width varies (like
1461 a tab), is meaningless (like a newline), or we just don't
1462 want to skip over it for some other reason. */
1463 if (common_width
!= 0)
1467 /* Don't go past the final buffer posn the user
1472 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1474 /* Don't go past the final horizontal position the user
1476 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
1478 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
1479 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1482 /* Don't go past the margin. */
1483 if (run_end_hpos
>= width
)
1485 run_end
= pos
+ (width
- hpos
) / common_width
;
1486 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1489 hpos
= run_end_hpos
;
1491 prev_hpos
= hpos
- common_width
;
1495 pos_byte
= CHAR_TO_BYTE (pos
);
1499 next_width_run
= run_end
+ 1;
1502 /* We have to scan the text character-by-character. */
1506 Lisp_Object charvec
;
1508 /* Check composition sequence. */
1510 || (pos
== cmp_it
.stop_pos
1511 && composition_reseat_it (&cmp_it
, pos
, pos_byte
, to
, win
,
1513 composition_update_it (&cmp_it
, pos
, pos_byte
, Qnil
);
1516 pos
+= cmp_it
.nchars
;
1517 pos_byte
+= cmp_it
.nbytes
;
1518 hpos
+= cmp_it
.width
;
1519 if (cmp_it
.to
== cmp_it
.nglyphs
)
1522 composition_compute_stop_pos (&cmp_it
, pos
, pos_byte
, to
,
1526 cmp_it
.from
= cmp_it
.to
;
1530 c
= FETCH_BYTE (pos_byte
);
1533 /* Perhaps add some info to the width_run_cache. */
1534 if (current_buffer
->width_run_cache
)
1536 /* Is this character part of the current run? If so, extend
1538 if (pos
- 1 == width_run_end
1539 && XFASTINT (width_table
[c
]) == width_run_width
)
1540 width_run_end
= pos
;
1542 /* The previous run is over, since this is a character at a
1543 different position, or a different width. */
1546 /* Have we accumulated a run to put in the cache?
1547 (Currently, we only cache runs of width == 1). */
1548 if (width_run_start
< width_run_end
1549 && width_run_width
== 1)
1550 know_region_cache (current_buffer
,
1551 current_buffer
->width_run_cache
,
1552 width_run_start
, width_run_end
);
1554 /* Start recording a new width run. */
1555 width_run_width
= XFASTINT (width_table
[c
]);
1556 width_run_start
= pos
- 1;
1557 width_run_end
= pos
;
1562 && ! (multibyte
&& LEADING_CODE_P (c
))
1563 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1565 charvec
= DISP_CHAR_VECTOR (dp
, c
);
1566 n
= ASIZE (charvec
);
1574 for (i
= n
- 1; i
>= 0; --i
)
1576 if (VECTORP (charvec
))
1578 /* This should be handled the same as
1579 next_element_from_display_vector does it. */
1580 Lisp_Object entry
= AREF (charvec
, i
);
1582 if (GLYPH_CODE_P (entry
)
1583 && GLYPH_CODE_CHAR_VALID_P (entry
))
1584 c
= GLYPH_CODE_CHAR (entry
);
1589 if (c
>= 040 && c
< 0177)
1593 int tem
= ((hpos
+ tab_offset
+ hscroll
- (hscroll
> 0))
1597 hpos
+= tab_width
- tem
;
1602 && indented_beyond_p (pos
, pos_byte
,
1603 (double) selective
)) /* iftc */
1605 /* If (pos == to), we don't have to take care of
1606 selective display. */
1609 /* Skip any number of invisible lines all at once */
1612 pos
= find_before_next_newline (pos
, to
, 1);
1615 pos_byte
= CHAR_TO_BYTE (pos
);
1618 && indented_beyond_p (pos
, pos_byte
,
1619 (double) selective
)); /* iftc */
1620 /* Allow for the " ..." that is displayed for them. */
1623 hpos
+= selective_rlen
;
1627 DEC_BOTH (pos
, pos_byte
);
1628 /* We have skipped the invis text, but not the
1634 /* A visible line. */
1638 /* Count the truncation glyph on column 0 */
1640 hpos
+= continuation_glyph_width
;
1645 else if (c
== CR
&& selective
< 0)
1647 /* In selective display mode,
1648 everything from a ^M to the end of the line is invisible.
1649 Stop *before* the real newline. */
1652 pos
= find_before_next_newline (pos
, to
, 1);
1653 pos_byte
= CHAR_TO_BYTE (pos
);
1655 /* If we just skipped next_boundary,
1656 loop around in the main while
1658 if (pos
> next_boundary
)
1659 next_boundary
= pos
;
1660 /* Allow for the " ..." that is displayed for them. */
1663 hpos
+= selective_rlen
;
1668 else if (multibyte
&& LEADING_CODE_P (c
))
1670 /* Start of multi-byte form. */
1672 int bytes
, width
, wide_column
;
1674 pos_byte
--; /* rewind POS_BYTE */
1675 ptr
= BYTE_POS_ADDR (pos_byte
);
1676 MULTIBYTE_BYTES_WIDTH (ptr
, dp
);
1679 wide_column_end_hpos
= hpos
+ wide_column
;
1682 else if (VECTORP (charvec
))
1685 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
1692 /* Remember any final width run in the cache. */
1693 if (current_buffer
->width_run_cache
1694 && width_run_width
== 1
1695 && width_run_start
< width_run_end
)
1696 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
1697 width_run_start
, width_run_end
);
1699 val_compute_motion
.bufpos
= pos
;
1700 val_compute_motion
.bytepos
= pos_byte
;
1701 val_compute_motion
.hpos
= hpos
;
1702 val_compute_motion
.vpos
= vpos
;
1703 if (contin_hpos
&& prev_hpos
== 0)
1704 val_compute_motion
.prevhpos
= contin_hpos
;
1706 val_compute_motion
.prevhpos
= prev_hpos
;
1707 /* We alalways handle all of them here; none of them remain to do. */
1708 val_compute_motion
.ovstring_chars_done
= 0;
1710 /* Nonzero if have just continued a line */
1711 val_compute_motion
.contin
= (contin_hpos
&& prev_hpos
== 0);
1714 return &val_compute_motion
;
1718 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
1719 doc
: /* Scan through the current buffer, calculating screen position.
1720 Scan the current buffer forward from offset FROM,
1721 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--
1722 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--
1723 and return the ending buffer position and screen location.
1725 If TOPOS is nil, the actual width and height of the window's
1728 There are three additional arguments:
1730 WIDTH is the number of columns available to display text;
1731 this affects handling of continuation lines. A value of nil
1732 corresponds to the actual number of available text columns.
1734 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).
1735 HSCROLL is the number of columns not being displayed at the left
1736 margin; this is usually taken from a window's hscroll member.
1737 TAB-OFFSET is the number of columns of the first tab that aren't
1738 being displayed, perhaps because the line was continued within it.
1739 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.
1741 WINDOW is the window to operate on. It is used to choose the display table;
1742 if it is showing the current buffer, it is used also for
1743 deciding which overlay properties apply.
1744 Note that `compute-motion' always operates on the current buffer.
1746 The value is a list of five elements:
1747 (POS HPOS VPOS PREVHPOS CONTIN)
1748 POS is the buffer position where the scan stopped.
1749 VPOS is the vertical position where the scan stopped.
1750 HPOS is the horizontal position where the scan stopped.
1752 PREVHPOS is the horizontal position one character back from POS.
1753 CONTIN is t if a line was continued after (or within) the previous character.
1755 For example, to find the buffer position of column COL of line LINE
1756 of a certain window, pass the window's starting location as FROM
1757 and the window's upper-left coordinates as FROMPOS.
1758 Pass the buffer's (point-max) as TO, to limit the scan to the end of the
1759 visible section of the buffer, and pass LINE and COL as TOPOS. */)
1760 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1761 Lisp_Object from
, frompos
, to
, topos
;
1762 Lisp_Object width
, offsets
, window
;
1765 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
;
1766 struct position
*pos
;
1767 int hscroll
, tab_offset
;
1769 CHECK_NUMBER_COERCE_MARKER (from
);
1770 CHECK_CONS (frompos
);
1771 CHECK_NUMBER_CAR (frompos
);
1772 CHECK_NUMBER_CDR (frompos
);
1773 CHECK_NUMBER_COERCE_MARKER (to
);
1777 CHECK_NUMBER_CAR (topos
);
1778 CHECK_NUMBER_CDR (topos
);
1781 CHECK_NUMBER (width
);
1783 if (!NILP (offsets
))
1785 CHECK_CONS (offsets
);
1786 CHECK_NUMBER_CAR (offsets
);
1787 CHECK_NUMBER_CDR (offsets
);
1788 hscroll
= XINT (XCAR (offsets
));
1789 tab_offset
= XINT (XCDR (offsets
));
1792 hscroll
= tab_offset
= 0;
1795 window
= Fselected_window ();
1797 CHECK_LIVE_WINDOW (window
);
1798 w
= XWINDOW (window
);
1800 if (XINT (from
) < BEGV
|| XINT (from
) > ZV
)
1801 args_out_of_range_3 (from
, make_number (BEGV
), make_number (ZV
));
1802 if (XINT (to
) < BEGV
|| XINT (to
) > ZV
)
1803 args_out_of_range_3 (to
, make_number (BEGV
), make_number (ZV
));
1805 pos
= compute_motion (XINT (from
), XINT (XCDR (frompos
)),
1806 XINT (XCAR (frompos
)), 0,
1809 ? window_internal_height (w
)
1810 : XINT (XCDR (topos
))),
1812 ? (window_box_text_cols (w
)
1814 #ifdef HAVE_WINDOW_SYSTEM
1815 FRAME_WINDOW_P (XFRAME (w
->frame
)) ? 0 :
1818 : XINT (XCAR (topos
))),
1819 (NILP (width
) ? -1 : XINT (width
)),
1820 hscroll
, tab_offset
,
1823 XSETFASTINT (bufpos
, pos
->bufpos
);
1824 XSETINT (hpos
, pos
->hpos
);
1825 XSETINT (vpos
, pos
->vpos
);
1826 XSETINT (prevhpos
, pos
->prevhpos
);
1828 return Fcons (bufpos
,
1832 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
1836 /* Fvertical_motion and vmotion */
1838 struct position val_vmotion
;
1841 vmotion (register EMACS_INT from
, register EMACS_INT vtarget
, struct window
*w
)
1843 EMACS_INT hscroll
= XINT (w
->hscroll
);
1844 struct position pos
;
1845 /* vpos is cumulative vertical position, changed as from is changed */
1846 register int vpos
= 0;
1848 register EMACS_INT first
;
1849 EMACS_INT from_byte
;
1850 EMACS_INT lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1852 = (INTEGERP (current_buffer
->selective_display
)
1853 ? XINT (current_buffer
->selective_display
)
1854 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1856 EMACS_INT start_hpos
= 0;
1858 /* This is the object we use for fetching character properties. */
1859 Lisp_Object text_prop_object
;
1861 XSETWINDOW (window
, w
);
1863 /* If the window contains this buffer, use it for getting text properties.
1864 Otherwise use the current buffer as arg for doing that. */
1865 if (EQ (w
->buffer
, Fcurrent_buffer ()))
1866 text_prop_object
= window
;
1868 text_prop_object
= Fcurrent_buffer ();
1870 if (vpos
>= vtarget
)
1872 /* To move upward, go a line at a time until
1873 we have gone at least far enough. */
1877 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1879 Lisp_Object propval
;
1881 prevline
= find_next_newline_no_quit (from
- 1, -1);
1882 while (prevline
> BEGV
1884 && indented_beyond_p (prevline
,
1885 CHAR_TO_BYTE (prevline
),
1886 (double) selective
)) /* iftc */
1887 /* Watch out for newlines with `invisible' property.
1888 When moving upward, check the newline before. */
1889 || (propval
= Fget_char_property (make_number (prevline
- 1),
1892 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1893 prevline
= find_next_newline_no_quit (prevline
- 1, -1);
1894 pos
= *compute_motion (prevline
, 0,
1895 lmargin
+ (prevline
== BEG
? start_hpos
: 0),
1898 /* Don't care for VPOS... */
1899 1 << (BITS_PER_SHORT
- 1),
1901 1 << (BITS_PER_SHORT
- 1),
1903 /* This compensates for start_hpos
1904 so that a tab as first character
1905 still occupies 8 columns. */
1906 (prevline
== BEG
? -start_hpos
: 0),
1913 /* If we made exactly the desired vertical distance,
1914 or if we hit beginning of buffer,
1915 return point found */
1916 if (vpos
>= vtarget
)
1918 val_vmotion
.bufpos
= from
;
1919 val_vmotion
.bytepos
= CHAR_TO_BYTE (from
);
1920 val_vmotion
.vpos
= vpos
;
1921 val_vmotion
.hpos
= lmargin
;
1922 val_vmotion
.contin
= 0;
1923 val_vmotion
.prevhpos
= 0;
1924 val_vmotion
.ovstring_chars_done
= 0;
1925 val_vmotion
.tab_offset
= 0; /* For accumulating tab offset. */
1926 return &val_vmotion
;
1929 /* Otherwise find the correct spot by moving down */
1931 /* Moving downward is simple, but must calculate from beg of line
1932 to determine hpos of starting point */
1933 from_byte
= CHAR_TO_BYTE (from
);
1934 if (from
> BEGV
&& FETCH_BYTE (from_byte
- 1) != '\n')
1936 Lisp_Object propval
;
1938 prevline
= find_next_newline_no_quit (from
, -1);
1939 while (prevline
> BEGV
1941 && indented_beyond_p (prevline
,
1942 CHAR_TO_BYTE (prevline
),
1943 (double) selective
)) /* iftc */
1944 /* Watch out for newlines with `invisible' property.
1945 When moving downward, check the newline after. */
1946 || (propval
= Fget_char_property (make_number (prevline
),
1949 TEXT_PROP_MEANS_INVISIBLE (propval
))))
1950 prevline
= find_next_newline_no_quit (prevline
- 1, -1);
1951 pos
= *compute_motion (prevline
, 0,
1952 lmargin
+ (prevline
== BEG
1956 /* Don't care for VPOS... */
1957 1 << (BITS_PER_SHORT
- 1),
1959 1 << (BITS_PER_SHORT
- 1),
1961 (prevline
== BEG
? -start_hpos
: 0),
1967 pos
.hpos
= lmargin
+ (from
== BEG
? start_hpos
: 0);
1972 return compute_motion (from
, vpos
, pos
.hpos
, did_motion
,
1973 ZV
, vtarget
, - (1 << (BITS_PER_SHORT
- 1)),
1975 pos
.tab_offset
- (from
== BEG
? start_hpos
: 0),
1979 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
1980 doc
: /* Move point to start of the screen line LINES lines down.
1981 If LINES is negative, this means moving up.
1983 This function is an ordinary cursor motion function
1984 which calculates the new position based on how text would be displayed.
1985 The new position may be the start of a line,
1986 or just the start of a continuation line.
1987 The function returns number of screen lines moved over;
1988 that usually equals LINES, but may be closer to zero
1989 if beginning or end of buffer was reached.
1991 The optional second argument WINDOW specifies the window to use for
1992 parameters such as width, horizontal scrolling, and so on.
1993 The default is to use the selected window's parameters.
1995 LINES can optionally take the form (COLS . LINES), in which case
1996 the motion will not stop at the start of a screen line but on
1997 its column COLS (if such exists on that line, that is).
1999 `vertical-motion' always uses the current buffer,
2000 regardless of which buffer is displayed in WINDOW.
2001 This is consistent with other cursor motion functions
2002 and makes it possible to use `vertical-motion' in any buffer,
2003 whether or not it is currently displayed in some window. */)
2005 Lisp_Object lines
, window
;
2010 Lisp_Object old_buffer
;
2011 struct gcpro gcpro1
;
2012 Lisp_Object lcols
= Qnil
;
2015 /* Allow LINES to be of the form (HPOS . VPOS) aka (COLUMNS . LINES). */
2016 if (CONSP (lines
) && (NUMBERP (XCAR (lines
))))
2018 lcols
= XCAR (lines
);
2019 cols
= INTEGERP (lcols
) ? (double) XINT (lcols
) : XFLOAT_DATA (lcols
);
2020 lines
= XCDR (lines
);
2023 CHECK_NUMBER (lines
);
2024 if (! NILP (window
))
2025 CHECK_WINDOW (window
);
2027 window
= selected_window
;
2028 w
= XWINDOW (window
);
2031 GCPRO1 (old_buffer
);
2032 if (XBUFFER (w
->buffer
) != current_buffer
)
2034 /* Set the window's buffer temporarily to the current buffer. */
2035 old_buffer
= w
->buffer
;
2036 XSETBUFFER (w
->buffer
, current_buffer
);
2041 struct position pos
;
2042 pos
= *vmotion (PT
, XINT (lines
), w
);
2043 SET_PT_BOTH (pos
.bufpos
, pos
.bytepos
);
2047 int it_start
, first_x
, it_overshoot_expected
;
2049 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
2050 start_display (&it
, w
, pt
);
2051 first_x
= it
.first_visible_x
;
2052 it_start
= IT_CHARPOS (it
);
2054 /* See comments below for why we calculate this. */
2055 if (XINT (lines
) > 0)
2057 if (it
.cmp_it
.id
>= 0)
2058 it_overshoot_expected
= 1;
2059 else if (it
.method
== GET_FROM_STRING
)
2061 const char *s
= SDATA (it
.string
);
2062 const char *e
= s
+ SBYTES (it
.string
);
2063 while (s
< e
&& *s
!= '\n')
2065 it_overshoot_expected
= (s
== e
) ? -1 : 0;
2068 it_overshoot_expected
= (it
.method
== GET_FROM_IMAGE
2069 || it
.method
== GET_FROM_STRETCH
);
2072 /* Scan from the start of the line containing PT. If we don't
2073 do this, we start moving with IT->current_x == 0, while PT is
2074 really at some x > 0. */
2075 reseat_at_previous_visible_line_start (&it
);
2076 it
.current_x
= it
.hpos
= 0;
2077 if (IT_CHARPOS (it
) != PT
)
2078 /* We used to temporarily disable selective display here; the
2079 comment said this is "so we don't move too far" (2005-01-19
2080 checkin by kfs). But this does nothing useful that I can
2081 tell, and it causes Bug#2694 . -- cyd */
2082 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
2084 if (XINT (lines
) <= 0)
2087 /* Do this even if LINES is 0, so that we move back to the
2088 beginning of the current line as we ought. */
2089 if (XINT (lines
) == 0 || IT_CHARPOS (it
) > 0)
2090 move_it_by_lines (&it
, XINT (lines
), 0);
2094 if (IT_CHARPOS (it
) > it_start
)
2096 /* IT may move too far if truncate-lines is on and PT
2097 lies beyond the right margin. In that case,
2098 backtrack unless the starting point is on an image,
2099 stretch glyph, composition, or Lisp string. */
2100 if (!it_overshoot_expected
2101 /* Also, backtrack if the Lisp string contains no
2102 newline, but there is a newline right after it.
2103 In this case, IT overshoots if there is an
2104 after-string just before the newline. */
2105 || (it_overshoot_expected
< 0
2106 && it
.method
== GET_FROM_BUFFER
2108 move_it_by_lines (&it
, -1, 0);
2110 move_it_by_lines (&it
, XINT (lines
), 0);
2114 /* Otherwise, we are at the first row occupied by PT,
2115 which might span multiple screen lines (e.g., if it's
2116 on a multi-line display string). We want to start
2117 from the last line that it occupies. */
2120 while (IT_CHARPOS (it
) <= it_start
)
2123 move_it_by_lines (&it
, 1, 0);
2125 if (XINT (lines
) > 1)
2126 move_it_by_lines (&it
, XINT (lines
) - 1, 0);
2131 move_it_by_lines (&it
, XINT (lines
), 0);
2136 /* Move to the goal column, if one was specified. */
2139 /* If the window was originally hscrolled, move forward by
2140 the hscrolled amount first. */
2143 move_it_in_display_line (&it
, ZV
, first_x
, MOVE_TO_X
);
2146 move_it_in_display_line
2148 (int)(cols
* FRAME_COLUMN_WIDTH (XFRAME (w
->frame
)) + 0.5),
2152 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
2155 if (BUFFERP (old_buffer
))
2156 w
->buffer
= old_buffer
;
2158 RETURN_UNGCPRO (make_number (it
.vpos
));
2163 /* File's initialization. */
2166 syms_of_indent (void)
2168 DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode
,
2169 doc
: /* *Indentation can insert tabs if this is non-nil. */);
2170 indent_tabs_mode
= 1;
2172 defsubr (&Scurrent_indentation
);
2173 defsubr (&Sindent_to
);
2174 defsubr (&Scurrent_column
);
2175 defsubr (&Smove_to_column
);
2176 defsubr (&Svertical_motion
);
2177 defsubr (&Scompute_motion
);
2180 /* arch-tag: 9adfea44-71f7-4988-8ee3-96da15c502cc
2181 (do not change this comment) */