1 /* Indentation functions.
2 Copyright (C) 1985,86,87,88,93,94 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 1, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
30 #include "intervals.h"
31 #include "region-cache.h"
33 /* Indentation can insert tabs if this is non-zero;
34 otherwise always uses spaces */
37 #define min(a, b) ((a) < (b) ? (a) : (b))
38 #define max(a, b) ((a) > (b) ? (a) : (b))
42 /* These three values memoize the current column to avoid recalculation */
43 /* Some things in set last_known_column_point to -1
44 to mark the memoized value as invalid */
45 /* Last value returned by current_column */
46 int last_known_column
;
47 /* Value of point when current_column was called */
48 int last_known_column_point
;
49 /* Value of MODIFF when current_column was called */
50 int last_known_column_modified
;
52 /* Get the display table to use for the current buffer. */
55 buffer_display_table ()
59 thisbuf
= current_buffer
->display_table
;
60 if (VECTORP (thisbuf
) && XVECTOR (thisbuf
)->size
== DISP_TABLE_SIZE
)
61 return XVECTOR (thisbuf
);
62 if (VECTORP (Vstandard_display_table
)
63 && XVECTOR (Vstandard_display_table
)->size
== DISP_TABLE_SIZE
)
64 return XVECTOR (Vstandard_display_table
);
68 /* Width run cache considerations. */
70 /* Return the width of character C under display table DP. */
72 character_width (c
, dp
)
74 struct Lisp_Vector
*dp
;
78 /* These width computations were determined by examining the cases
79 in display_text_line. */
81 /* Some characters are never handled by the display table. */
82 if (c
== '\n' || c
== '\t' || c
== '\015')
85 /* Everything else might be handled by the display table, if it's
86 present and the element is right. */
87 else if (dp
&& (elt
= DISP_CHAR_VECTOR (dp
, c
),
89 return XVECTOR (elt
)->size
;
91 /* In the absence of display table perversities, printing characters
93 else if (c
>= 040 && c
< 0177)
96 /* Everybody else (control characters, metacharacters) has other
97 widths. We could return their actual widths here, but they
98 depend on things like ctl_arrow and crud like that, and they're
99 not very common at all. So we'll just claim we don't know their
105 /* Return true iff the display table DISPTAB specifies the same widths
106 for characters as WIDTHTAB. We use this to decide when to
107 invalidate the buffer's width_run_cache. */
109 disptab_matches_widthtab (disptab
, widthtab
)
110 struct Lisp_Vector
*disptab
;
111 struct Lisp_Vector
*widthtab
;
115 if (widthtab
->size
!= 256)
118 for (i
= 0; i
< 256; i
++)
119 if (character_width (i
, disptab
)
120 != XFASTINT (widthtab
->contents
[i
]))
126 /* Recompute BUF's width table, using the display table DISPTAB. */
128 recompute_width_table (buf
, disptab
)
130 struct Lisp_Vector
*disptab
;
133 struct Lisp_Vector
*widthtab
134 = (VECTORP (buf
->width_table
)
135 ? XVECTOR (buf
->width_table
)
136 : XVECTOR (Fmake_vector (make_number (256), make_number (0))));
138 if (widthtab
->size
!= 256)
141 for (i
= 0; i
< 256; i
++)
142 widthtab
->contents
[i
] = character_width (i
, disptab
);
145 /* Allocate or free the width run cache, as requested by the current
146 state of current_buffer's cache_long_line_scans variable. */
148 width_run_cache_on_off ()
150 if (NILP (current_buffer
->cache_long_line_scans
))
152 /* It should be off. */
153 if (current_buffer
->width_run_cache
)
155 free_region_cache (current_buffer
->width_run_cache
);
156 current_buffer
->width_run_cache
= 0;
157 current_buffer
->width_table
= Qnil
;
162 /* It should be on. */
163 if (current_buffer
->width_run_cache
== 0)
165 current_buffer
->width_run_cache
= new_region_cache ();
166 current_buffer
->width_table
= Fmake_vector (make_number (256),
168 recompute_width_table (current_buffer
, buffer_display_table ());
174 DEFUN ("current-column", Fcurrent_column
, Scurrent_column
, 0, 0, 0,
175 "Return the horizontal position of point. Beginning of line is column 0.\n\
176 This is calculated by adding together the widths of all the displayed\n\
177 representations of the character between the start of the previous line\n\
178 and point. (eg control characters will have a width of 2 or 4, tabs\n\
179 will have a variable width)\n\
180 Ignores finite width of frame, which means that this function may return\n\
181 values greater than (frame-width).\n\
182 Whether the line is visible (if `selective-display' is t) has no effect;\n\
183 however, ^M is treated as end of line when `selective-display' is t.")
187 XSETFASTINT (temp
, current_column ());
191 /* Cancel any recorded value of the horizontal position. */
193 invalidate_current_column ()
195 last_known_column_point
= 0;
202 register unsigned char *ptr
, *stop
;
203 register int tab_seen
;
206 register int tab_width
= XINT (current_buffer
->tab_width
);
207 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
208 register struct Lisp_Vector
*dp
= buffer_display_table ();
211 if (point
== last_known_column_point
212 && MODIFF
== last_known_column_modified
)
213 return last_known_column
;
215 /* Make a pointer for decrementing through the chars before point. */
216 ptr
= &FETCH_CHAR (point
- 1) + 1;
217 /* Make a pointer to where consecutive chars leave off,
218 going backwards from point. */
221 else if (point
<= GPT
|| BEGV
> GPT
)
226 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
228 col
= 0, tab_seen
= 0, post_tab
= 0;
234 /* We stopped either for the beginning of the buffer
236 if (ptr
== BEGV_ADDR
)
238 /* It was the gap. Jump back over it. */
241 /* Check whether that brings us to beginning of buffer. */
242 if (BEGV
>= GPT
) break;
246 if (c
>= 040 && c
< 0177
247 && (dp
== 0 || !VECTORP (DISP_CHAR_VECTOR (dp
, c
))))
253 else if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
258 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
264 else if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
265 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
267 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
272 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
276 last_known_column
= col
;
277 last_known_column_point
= point
;
278 last_known_column_modified
= MODIFF
;
283 DEFUN ("indent-to", Findent_to
, Sindent_to
, 1, 2, "NIndent to column: ",
284 "Indent from point with tabs and spaces until COLUMN is reached.\n\
285 Optional second argument MIN says always do at least MIN spaces\n\
286 even if that goes past COLUMN; by default, MIN is zero.")
288 Lisp_Object col
, minimum
;
291 register int fromcol
;
292 register int tab_width
= XINT (current_buffer
->tab_width
);
294 CHECK_NUMBER (col
, 0);
296 XSETFASTINT (minimum
, 0);
297 CHECK_NUMBER (minimum
, 1);
299 fromcol
= current_column ();
300 mincol
= fromcol
+ XINT (minimum
);
301 if (mincol
< XINT (col
)) mincol
= XINT (col
);
303 if (fromcol
== mincol
)
304 return make_number (mincol
);
306 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
308 if (indent_tabs_mode
)
311 XSETFASTINT (n
, mincol
/ tab_width
- fromcol
/ tab_width
);
312 if (XFASTINT (n
) != 0)
314 Finsert_char (make_number ('\t'), n
, Qt
);
316 fromcol
= (mincol
/ tab_width
) * tab_width
;
320 XSETFASTINT (col
, mincol
- fromcol
);
321 Finsert_char (make_number (' '), col
, Qt
);
323 last_known_column
= mincol
;
324 last_known_column_point
= point
;
325 last_known_column_modified
= MODIFF
;
327 XSETINT (col
, mincol
);
332 DEFUN ("current-indentation", Fcurrent_indentation
, Scurrent_indentation
,
334 "Return the indentation of the current line.\n\
335 This is the horizontal position of the character\n\
336 following any initial whitespace.")
341 XSETFASTINT (val
, position_indentation (find_next_newline (point
, -1)));
345 position_indentation (pos
)
348 register int column
= 0;
349 register int tab_width
= XINT (current_buffer
->tab_width
);
350 register unsigned char *p
;
351 register unsigned char *stop
;
353 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
355 stop
= &FETCH_CHAR (BUFFER_CEILING_OF (pos
)) + 1;
356 p
= &FETCH_CHAR (pos
);
363 pos
+= p
- &FETCH_CHAR (pos
);
364 p
= &FETCH_CHAR (pos
);
365 stop
= &FETCH_CHAR (BUFFER_CEILING_OF (pos
)) + 1;
373 column
+= tab_width
- column
% tab_width
;
381 /* Test whether the line beginning at POS is indented beyond COLUMN.
382 Blank lines are treated as if they had the same indentation as the
385 indented_beyond_p (pos
, column
)
388 while (pos
> BEGV
&& FETCH_CHAR (pos
) == '\n')
389 pos
= find_next_newline_no_quit (pos
- 1, -1);
390 return (position_indentation (pos
) >= column
);
394 DEFUN ("move-to-column", Fmove_to_column
, Smove_to_column
, 1, 2, 0,
395 "Move point to column COLUMN in the current line.\n\
396 The column of a character is calculated by adding together the widths\n\
397 as displayed of the previous characters in the line.\n\
398 This function ignores line-continuation;\n\
399 there is no upper limit on the column number a character can have\n\
400 and horizontal scrolling has no effect.\n\
402 If specified column is within a character, point goes after that character.\n\
403 If it's past end of line, point goes to end of line.\n\n\
404 A non-nil second (optional) argument FORCE means, if the line\n\
405 is too short to reach column COLUMN then add spaces/tabs to get there,\n\
406 and if COLUMN is in the middle of a tab character, change it to spaces.")
408 Lisp_Object column
, force
;
411 register int col
= current_column ();
414 register int tab_width
= XINT (current_buffer
->tab_width
);
415 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
416 register struct Lisp_Vector
*dp
= buffer_display_table ();
422 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
423 CHECK_NATNUM (column
, 0);
424 goal
= XINT (column
);
430 /* If we're starting past the desired column,
431 back up to beginning of line and scan from there. */
434 pos
= find_next_newline (pos
, -1);
438 while (col
< goal
&& pos
< end
)
440 c
= FETCH_CHAR (pos
);
443 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
450 col
= col
/ tab_width
* tab_width
;
452 else if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
453 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
454 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
456 else if (c
< 040 || c
>= 0177)
464 /* If a tab char made us overshoot, change it to spaces
465 and scan through it again. */
466 if (!NILP (force
) && col
> goal
&& c
== '\t' && prev_col
< goal
)
470 del_range (point
- 1, point
);
471 Findent_to (make_number (goal
), Qnil
);
473 Findent_to (make_number (col
), Qnil
);
475 /* Set the last_known... vars consistently. */
479 /* If line ends prematurely, add space to the end. */
480 if (col
< goal
&& !NILP (force
))
481 Findent_to (make_number (col
= goal
), Qnil
);
483 last_known_column
= col
;
484 last_known_column_point
= point
;
485 last_known_column_modified
= MODIFF
;
487 XSETFASTINT (val
, col
);
492 /* compute_motion: compute buffer posn given screen posn and vice versa */
494 struct position val_compute_motion
;
496 /* Scan the current buffer forward from offset FROM, pretending that
497 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
498 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
499 and return the ending buffer position and screen location. If we
500 can't hit the requested column exactly (because of a tab or other
501 multi-column character), overshoot.
503 WIDTH is the number of columns available to display text;
504 compute_motion uses this to handle continuation lines and such.
505 HSCROLL is the number of columns not being displayed at the left
506 margin; this is usually taken from a window's hscroll member.
507 TAB_OFFSET is the number of columns of the first tab that aren't
508 being displayed, perhaps because of a continuation line or
511 compute_motion returns a pointer to a struct position. The bufpos
512 member gives the buffer position at the end of the scan, and hpos
513 and vpos give its cartesian location. prevhpos is the column at
514 which the character before bufpos started, and contin is non-zero
515 if we reached the current line by continuing the previous.
517 Note that FROMHPOS and TOHPOS should be expressed in real screen
518 columns, taking HSCROLL and the truncation glyph at the left margin
519 into account. That is, beginning-of-line moves you to the hpos
520 -HSCROLL + (HSCROLL > 0).
522 Note that FROMHPOS and TOHPOS should be expressed in real screen
523 columns, taking HSCROLL and the truncation glyph at the left margin
524 into account. That is, beginning-of-line moves you to the hpos
525 -HSCROLL + (HSCROLL > 0).
527 For example, to find the buffer position of column COL of line LINE
528 of a certain window, pass the window's starting location as FROM
529 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
530 Pass the buffer's ZV as TO, to limit the scan to the end of the
531 visible section of the buffer, and pass LINE and COL as TOVPOS and
534 When displaying in window w, a typical formula for WIDTH is:
537 - (has_vertical_scroll_bars
538 ? FRAME_SCROLL_BAR_COLS (XFRAME (window->frame))
539 : (window_width + window_left != frame_width))
542 window_width is XFASTINT (w->width),
543 window_left is XFASTINT (w->left),
544 has_vertical_scroll_bars is
545 FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (WINDOW_FRAME (window)))
546 and frame_width = FRAME_WIDTH (XFRAME (window->frame))
548 Or you can let window_internal_width do this all for you, and write:
549 window_internal_width (w) - 1
551 The `-1' accounts for the continuation-line backslashes; the rest
552 accounts for window borders if the window is split horizontally, and
553 the scroll bars if they are turned on. */
556 compute_motion (from
, fromvpos
, fromhpos
, to
, tovpos
, tohpos
, width
, hscroll
, tab_offset
, win
)
557 int from
, fromvpos
, fromhpos
, to
, tovpos
, tohpos
;
559 int hscroll
, tab_offset
;
562 register int hpos
= fromhpos
;
563 register int vpos
= fromvpos
;
567 register int tab_width
= XFASTINT (current_buffer
->tab_width
);
568 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
569 register struct Lisp_Vector
*dp
= window_display_table (win
);
571 = (INTEGERP (current_buffer
->selective_display
)
572 ? XINT (current_buffer
->selective_display
)
573 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
574 int prev_vpos
= vpos
, prev_hpos
= 0;
576 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
577 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
: 0);
578 #ifdef USE_TEXT_PROPERTIES
579 /* The next location where the `invisible' property changes */
580 int next_invisible
= from
;
581 Lisp_Object prop
, position
;
584 /* For computing runs of characters with similar widths.
585 Invariant: width_run_width is zero, or all the characters
586 from width_run_start to width_run_end have a fixed width of
588 int width_run_start
= from
;
589 int width_run_end
= from
;
590 int width_run_width
= 0;
591 Lisp_Object
*width_table
;
593 /* The next buffer pos where we should consult the width run cache. */
594 int next_width_run
= from
;
596 width_run_cache_on_off ();
597 if (dp
== buffer_display_table ())
598 width_table
= (VECTORP (current_buffer
->width_table
)
599 ? XVECTOR (current_buffer
->width_table
)->contents
602 /* If the window has its own display table, we can't use the width
603 run cache, because that's based on the buffer's display table. */
606 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
607 for (pos
= from
; pos
< to
; )
609 /* Stop if past the target screen position. */
611 || (vpos
== tovpos
&& hpos
>= tohpos
))
617 #ifdef USE_TEXT_PROPERTIES
618 /* if the `invisible' property is set, we can skip to
619 the next property change */
620 while (pos
== next_invisible
&& pos
< to
)
622 XSETFASTINT (position
, pos
);
623 prop
= Fget_char_property (position
,
627 Lisp_Object end
, limit
;
629 recenter_overlay_lists (current_buffer
, pos
);
630 /* This is just an estimate to give reasonable
631 performance; nothing should go wrong if it is too small. */
632 limit
= Fnext_overlay_change (position
);
633 if (XFASTINT (limit
) > pos
+ 100)
634 XSETFASTINT (limit
, pos
+ 100);
635 end
= Fnext_single_property_change (position
, Qinvisible
,
636 Fcurrent_buffer (), limit
);
638 next_invisible
= XINT (end
);
642 pos
= next_invisible
;
649 /* Consult the width run cache to see if we can avoid inspecting
650 the text character-by-character. */
651 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
655 = region_cache_forward (current_buffer
,
656 current_buffer
->width_run_cache
,
659 /* A width of zero means the character's width varies (like
660 a tab), is meaningless (like a newline), or we just don't
661 want to skip over it for some other reason. */
662 if (common_width
!= 0)
666 /* Don't go past the final buffer posn the user
671 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
673 /* Don't go past the final horizontal position the user
675 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
677 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
678 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
681 /* Don't go past the margin. */
682 if (run_end_hpos
>= width
)
684 run_end
= pos
+ (width
- hpos
) / common_width
;
685 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
690 prev_hpos
= hpos
- common_width
;
694 next_width_run
= run_end
+ 1;
697 /* We have to scan the text character-by-character. */
700 c
= FETCH_CHAR (pos
);
703 /* Perhaps add some info to the width_run_cache. */
704 if (current_buffer
->width_run_cache
)
706 /* Is this character part of the current run? If so, extend
708 if (pos
- 1 == width_run_end
709 && width_table
[c
] == width_run_width
)
712 /* The previous run is over, since this is a character at a
713 different position, or a different width. */
716 /* Have we accumulated a run to put in the cache?
717 (Currently, we only cache runs of width == 1. */
718 if (width_run_start
< width_run_end
719 && width_run_width
== 1)
720 know_region_cache (current_buffer
,
721 current_buffer
->width_run_cache
,
722 width_run_start
, width_run_end
);
724 /* Start recording a new width run. */
725 width_run_width
= width_table
[c
];
726 width_run_start
= pos
- 1;
731 if (c
>= 040 && c
< 0177
732 && (dp
== 0 || ! VECTORP (DISP_CHAR_VECTOR (dp
, c
))))
736 hpos
+= tab_width
- ((hpos
+ tab_offset
+ hscroll
- (hscroll
> 0)
737 /* Add tab_width here to make sure
738 positive. hpos can be negative
739 after continuation but can't be
740 less than -tab_width. */
746 if (selective
> 0 && indented_beyond_p (pos
, selective
))
748 /* Skip any number of invisible lines all at once */
750 pos
= find_before_next_newline (pos
, to
, 1);
752 && indented_beyond_p (pos
, selective
));
753 /* Allow for the " ..." that is displayed for them. */
756 hpos
+= selective_rlen
;
760 /* We have skipped the invis text, but not the
765 /* A visible line. */
769 /* Count the truncation glyph on column 0 */
775 else if (c
== CR
&& selective
< 0)
777 /* In selective display mode,
778 everything from a ^M to the end of the line is invisible.
779 Stop *before* the real newline. */
780 pos
= find_before_next_newline (pos
, to
, 1);
781 /* Allow for the " ..." that is displayed for them. */
784 hpos
+= selective_rlen
;
789 else if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
790 hpos
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
792 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
795 /* Handle right margin. */
799 && FETCH_CHAR (pos
) != '\n')))
802 || (vpos
== tovpos
&& hpos
>= tohpos
))
805 || (truncate_partial_width_windows
806 && width
+ 1 < FRAME_WIDTH (XFRAME (WINDOW_FRAME (win
))))
807 || !NILP (current_buffer
->truncate_lines
))
809 /* Truncating: skip to newline. */
810 pos
= find_before_next_newline (pos
, to
, 1);
824 /* Remember any final width run in the cache. */
825 if (current_buffer
->width_run_cache
826 && width_run_width
== 1
827 && width_run_start
< width_run_end
)
828 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
829 width_run_start
, width_run_end
);
831 val_compute_motion
.bufpos
= pos
;
832 val_compute_motion
.hpos
= hpos
;
833 val_compute_motion
.vpos
= vpos
;
834 val_compute_motion
.prevhpos
= prev_hpos
;
836 /* Nonzero if have just continued a line */
837 val_compute_motion
.contin
839 && (val_compute_motion
.vpos
!= prev_vpos
)
842 return &val_compute_motion
;
845 #if 0 /* The doc string is too long for some compilers,
846 but make-docfile can find it in this comment. */
847 DEFUN ("compute-motion", Ffoo
, Sfoo
, 7, 7, 0,
848 "Scan through the current buffer, calculating screen position.\n\
849 Scan the current buffer forward from offset FROM,\n\
850 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--\n\
851 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--\n\
852 and return the ending buffer position and screen location.\n\
854 There are three additional arguments:\n\
856 WIDTH is the number of columns available to display text;\n\
857 this affects handling of continuation lines.\n\
858 This is usually the value returned by `window-width', less one (to allow\n\
859 for the continuation glyph).\n\
861 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).\n\
862 HSCROLL is the number of columns not being displayed at the left\n\
863 margin; this is usually taken from a window's hscroll member.\n\
864 TAB-OFFSET is the number of columns of the first tab that aren't\n\
865 being displayed, perhaps because the line was continued within it.\n\
866 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.\n\
868 WINDOW is the window to operate on. Currently this is used only to\n\
869 find the display table. It does not matter what buffer WINDOW displays;\n\
870 `compute-motion' always operates on the current buffer.\n\
872 The value is a list of five elements:\n\
873 (POS HPOS VPOS PREVHPOS CONTIN)\n\
874 POS is the buffer position where the scan stopped.\n\
875 VPOS is the vertical position where the scan stopped.\n\
876 HPOS is the horizontal position where the scan stopped.\n\
878 PREVHPOS is the horizontal position one character back from POS.\n\
879 CONTIN is t if a line was continued after (or within) the previous character.\n\
881 For example, to find the buffer position of column COL of line LINE\n\
882 of a certain window, pass the window's starting location as FROM\n\
883 and the window's upper-left coordinates as FROMPOS.\n\
884 Pass the buffer's (point-max) as TO, to limit the scan to the end of the\n\
885 visible section of the buffer, and pass LINE and COL as TOPOS.")
886 (from
, frompos
, to
, topos
, width
, offsets
, window
)
889 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
891 (from
, frompos
, to
, topos
, width
, offsets
, window
)
892 Lisp_Object from
, frompos
, to
, topos
;
893 Lisp_Object width
, offsets
, window
;
895 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
, contin
;
896 struct position
*pos
;
897 int hscroll
, tab_offset
;
899 CHECK_NUMBER_COERCE_MARKER (from
, 0);
900 CHECK_CONS (frompos
, 0);
901 CHECK_NUMBER (XCONS (frompos
)->car
, 0);
902 CHECK_NUMBER (XCONS (frompos
)->cdr
, 0);
903 CHECK_NUMBER_COERCE_MARKER (to
, 0);
904 CHECK_CONS (topos
, 0);
905 CHECK_NUMBER (XCONS (topos
)->car
, 0);
906 CHECK_NUMBER (XCONS (topos
)->cdr
, 0);
907 CHECK_NUMBER (width
, 0);
910 CHECK_CONS (offsets
, 0);
911 CHECK_NUMBER (XCONS (offsets
)->car
, 0);
912 CHECK_NUMBER (XCONS (offsets
)->cdr
, 0);
913 hscroll
= XINT (XCONS (offsets
)->car
);
914 tab_offset
= XINT (XCONS (offsets
)->cdr
);
917 hscroll
= tab_offset
= 0;
920 window
= Fselected_window ();
922 CHECK_LIVE_WINDOW (window
, 0);
924 pos
= compute_motion (XINT (from
), XINT (XCONS (frompos
)->cdr
),
925 XINT (XCONS (frompos
)->car
),
926 XINT (to
), XINT (XCONS (topos
)->cdr
),
927 XINT (XCONS (topos
)->car
),
928 XINT (width
), hscroll
, tab_offset
,
931 XSETFASTINT (bufpos
, pos
->bufpos
);
932 XSETINT (hpos
, pos
->hpos
);
933 XSETINT (vpos
, pos
->vpos
);
934 XSETINT (prevhpos
, pos
->prevhpos
);
936 return Fcons (bufpos
,
940 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
944 /* Return the column of position POS in window W's buffer.
945 The result is rounded down to a multiple of the internal width of W.
946 This is the amount of indentation of position POS
947 that is not visible in its horizontal position in the window. */
950 pos_tab_offset (w
, pos
)
956 int width
= window_internal_width (w
) - 1;
958 if (pos
== BEGV
|| FETCH_CHAR (pos
- 1) == '\n')
961 col
= current_column ();
962 TEMP_SET_PT (opoint
);
963 return col
- (col
% width
);
967 /* Fvertical_motion and vmotion */
968 struct position val_vmotion
;
971 vmotion (from
, vtarget
, width
, hscroll
, window
)
972 register int from
, vtarget
, width
;
977 /* vpos is cumulative vertical position, changed as from is changed */
978 register int vpos
= 0;
979 Lisp_Object prevline
;
981 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
983 = (INTEGERP (current_buffer
->selective_display
)
984 ? XINT (current_buffer
->selective_display
)
985 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
986 /* The omission of the clause
987 && marker_position (XWINDOW (window)->start) == BEG
988 here is deliberate; I think we want to measure from the prompt
989 position even if the minibuffer window has scrolled. */
990 int start_hpos
= (EQ (window
, minibuf_window
) ? minibuf_prompt_width
: 0);
995 /* Moving downward is simple, but must calculate from beg of line
996 to determine hpos of starting point */
997 if (from
> BEGV
&& FETCH_CHAR (from
- 1) != '\n')
999 XSETFASTINT (prevline
, find_next_newline_no_quit (from
, -1));
1000 while (XFASTINT (prevline
) > BEGV
1002 && indented_beyond_p (XFASTINT (prevline
), selective
))
1003 #ifdef USE_TEXT_PROPERTIES
1004 /* watch out for newlines with `invisible' property */
1005 || ! NILP (Fget_char_property (prevline
,
1010 XSETFASTINT (prevline
,
1011 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1013 pos
= *compute_motion (XFASTINT (prevline
), 0,
1014 lmargin
+ (XFASTINT (prevline
) == 1
1016 from
, 1 << (INTBITS
- 2), 0,
1017 width
, hscroll
, 0, XWINDOW (window
));
1021 pos
.hpos
= lmargin
+ (from
== 1 ? start_hpos
: 0);
1024 return compute_motion (from
, vpos
, pos
.hpos
,
1025 ZV
, vtarget
, - (1 << (INTBITS
- 2)),
1026 width
, hscroll
, pos
.vpos
* width
,
1030 /* To move upward, go a line at a time until
1031 we have gone at least far enough */
1035 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1037 XSETFASTINT (prevline
, from
);
1040 XSETFASTINT (prevline
,
1041 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1043 if (XFASTINT (prevline
) == BEGV
1045 || ! indented_beyond_p (XFASTINT (prevline
), selective
))
1046 #ifdef USE_TEXT_PROPERTIES
1047 /* watch out for newlines with `invisible' property */
1048 && NILP (Fget_char_property (prevline
, Qinvisible
, window
))
1053 pos
= *compute_motion (XFASTINT (prevline
), 0,
1054 lmargin
+ (XFASTINT (prevline
) == 1
1056 from
, 1 << (INTBITS
- 2), 0,
1057 width
, hscroll
, 0, XWINDOW (window
));
1060 from
= XFASTINT (prevline
);
1063 /* If we made exactly the desired vertical distance,
1064 or if we hit beginning of buffer,
1065 return point found */
1066 if (vpos
>= vtarget
)
1068 val_vmotion
.bufpos
= from
;
1069 val_vmotion
.vpos
= vpos
;
1070 val_vmotion
.hpos
= lmargin
;
1071 val_vmotion
.contin
= 0;
1072 val_vmotion
.prevhpos
= 0;
1073 return &val_vmotion
;
1076 /* Otherwise find the correct spot by moving down */
1080 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
1081 "Move to start of screen line LINES lines down.\n\
1082 If LINES is negative, this is moving up.\n\
1084 The optional second argument WINDOW specifies the window to use for\n\
1085 parameters such as width, horizontal scrolling, and so on.\n\
1086 the default is the selected window.\n\
1087 It does not matter what buffer is displayed in WINDOW.\n\
1088 `vertical-motion' always uses the current buffer.\n\
1090 Sets point to position found; this may be start of line\n\
1091 or just the start of a continuation line.\n\
1092 Returns number of lines moved; may be closer to zero than LINES\n\
1093 if beginning or end of buffer was reached.")
1095 Lisp_Object lines
, window
;
1097 struct position pos
;
1098 register struct window
*w
;
1100 CHECK_NUMBER (lines
, 0);
1101 if (! NILP (window
))
1102 CHECK_WINDOW (window
, 0);
1104 window
= selected_window
;
1106 w
= XWINDOW (window
);
1108 pos
= *vmotion (point
, XINT (lines
), window_internal_width (w
) - 1,
1109 /* Not XFASTINT since perhaps could be negative */
1110 XINT (w
->hscroll
), window
);
1112 SET_PT (pos
.bufpos
);
1113 return make_number (pos
.vpos
);
1116 /* file's initialization. */
1120 DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode
,
1121 "*Indentation can insert tabs if this is non-nil.\n\
1122 Setting this variable automatically makes it local to the current buffer.");
1123 indent_tabs_mode
= 1;
1125 defsubr (&Scurrent_indentation
);
1126 defsubr (&Sindent_to
);
1127 defsubr (&Scurrent_column
);
1128 defsubr (&Smove_to_column
);
1129 defsubr (&Svertical_motion
);
1130 defsubr (&Scompute_motion
);