1 /* Indentation functions.
2 Copyright (C) 1985,86,87,88,93,94,95 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
32 #include "intervals.h"
33 #include "region-cache.h"
35 /* Indentation can insert tabs if this is non-zero;
36 otherwise always uses spaces */
39 #define min(a, b) ((a) < (b) ? (a) : (b))
40 #define max(a, b) ((a) > (b) ? (a) : (b))
44 /* These three values memoize the current column to avoid recalculation */
45 /* Some things in set last_known_column_point to -1
46 to mark the memoized value as invalid */
47 /* Last value returned by current_column */
48 int last_known_column
;
49 /* Value of point when current_column was called */
50 int last_known_column_point
;
51 /* Value of MODIFF when current_column was called */
52 int last_known_column_modified
;
54 static int current_column_1 ();
56 /* Cache of beginning of line found by the last call of
58 int current_column_bol_cache
;
60 /* Get the display table to use for the current buffer. */
62 struct Lisp_Char_Table
*
63 buffer_display_table ()
67 thisbuf
= current_buffer
->display_table
;
68 if (DISP_TABLE_P (thisbuf
))
69 return XCHAR_TABLE (thisbuf
);
70 if (DISP_TABLE_P (Vstandard_display_table
))
71 return XCHAR_TABLE (Vstandard_display_table
);
75 /* Width run cache considerations. */
77 /* Return the width of character C under display table DP. */
80 character_width (c
, dp
)
82 struct Lisp_Char_Table
*dp
;
86 /* These width computations were determined by examining the cases
87 in display_text_line. */
89 /* Everything can be handled by the display table, if it's
90 present and the element is right. */
91 if (dp
&& (elt
= DISP_CHAR_VECTOR (dp
, c
), VECTORP (elt
)))
92 return XVECTOR (elt
)->size
;
94 /* Some characters are special. */
95 if (c
== '\n' || c
== '\t' || c
== '\015')
98 /* Printing characters have width 1. */
99 else if (c
>= 040 && c
< 0177)
102 /* Everybody else (control characters, metacharacters) has other
103 widths. We could return their actual widths here, but they
104 depend on things like ctl_arrow and crud like that, and they're
105 not very common at all. So we'll just claim we don't know their
111 /* Return true iff the display table DISPTAB specifies the same widths
112 for characters as WIDTHTAB. We use this to decide when to
113 invalidate the buffer's width_run_cache. */
115 disptab_matches_widthtab (disptab
, widthtab
)
116 struct Lisp_Char_Table
*disptab
;
117 struct Lisp_Vector
*widthtab
;
121 if (widthtab
->size
!= 256)
124 for (i
= 0; i
< 256; i
++)
125 if (character_width (i
, disptab
)
126 != XFASTINT (widthtab
->contents
[i
]))
132 /* Recompute BUF's width table, using the display table DISPTAB. */
134 recompute_width_table (buf
, disptab
)
136 struct Lisp_Char_Table
*disptab
;
139 struct Lisp_Vector
*widthtab
;
141 if (!VECTORP (buf
->width_table
))
142 buf
->width_table
= Fmake_vector (make_number (256), make_number (0));
143 widthtab
= XVECTOR (buf
->width_table
);
144 if (widthtab
->size
!= 256)
147 for (i
= 0; i
< 256; i
++)
148 XSETFASTINT (widthtab
->contents
[i
], character_width (i
, disptab
));
151 /* Allocate or free the width run cache, as requested by the current
152 state of current_buffer's cache_long_line_scans variable. */
154 width_run_cache_on_off ()
156 if (NILP (current_buffer
->cache_long_line_scans
)
157 /* And, for the moment, this feature doesn't work on multibyte
159 || !NILP (current_buffer
->enable_multibyte_characters
))
161 /* It should be off. */
162 if (current_buffer
->width_run_cache
)
164 free_region_cache (current_buffer
->width_run_cache
);
165 current_buffer
->width_run_cache
= 0;
166 current_buffer
->width_table
= Qnil
;
171 /* It should be on. */
172 if (current_buffer
->width_run_cache
== 0)
174 current_buffer
->width_run_cache
= new_region_cache ();
175 recompute_width_table (current_buffer
, buffer_display_table ());
181 /* Skip some invisible characters starting from POS.
182 This includes characters invisible because of text properties
183 and characters invisible because of overlays.
185 If position POS is followed by invisible characters,
186 skip some of them and return the position after them.
187 Otherwise return POS itself.
189 Set *NEXT_BOUNDARY_P to the next position at which
190 it will be necessary to call this function again.
192 Don't scan past TO, and don't set *NEXT_BOUNDARY_P
193 to a value greater than TO.
195 If WINDOW is non-nil, and this buffer is displayed in WINDOW,
196 take account of overlays that apply only in WINDOW.
198 We don't necessarily skip all the invisible characters after POS
199 because that could take a long time. We skip a reasonable number
200 which can be skipped quickly. If there might be more invisible
201 characters immediately following, then *NEXT_BOUNDARY_P
202 will equal the return value. */
205 skip_invisible (pos
, next_boundary_p
, to
, window
)
207 int *next_boundary_p
;
211 Lisp_Object prop
, position
, overlay_limit
, proplimit
;
215 XSETFASTINT (position
, pos
);
216 XSETBUFFER (buffer
, current_buffer
);
218 /* Give faster response for overlay lookup near POS. */
219 recenter_overlay_lists (current_buffer
, pos
);
221 /* We must not advance farther than the next overlay change.
222 The overlay change might change the invisible property;
223 or there might be overlay strings to be displayed there. */
224 overlay_limit
= Fnext_overlay_change (position
);
225 /* As for text properties, this gives a lower bound
226 for where the invisible text property could change. */
227 proplimit
= Fnext_property_change (position
, buffer
, Qt
);
228 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
229 proplimit
= overlay_limit
;
230 /* PROPLIMIT is now a lower bound for the next change
231 in invisible status. If that is plenty far away,
232 use that lower bound. */
233 if (XFASTINT (proplimit
) > pos
+ 100 || XFASTINT (proplimit
) >= to
)
234 *next_boundary_p
= XFASTINT (proplimit
);
235 /* Otherwise, scan for the next `invisible' property change. */
238 /* Don't scan terribly far. */
239 XSETFASTINT (proplimit
, min (pos
+ 100, to
));
240 /* No matter what. don't go past next overlay change. */
241 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
242 proplimit
= overlay_limit
;
243 end
= XFASTINT (Fnext_single_property_change (position
, Qinvisible
,
245 /* Don't put the boundary in the middle of multibyte form if
246 there is no actual property change. */
248 && !NILP (current_buffer
->enable_multibyte_characters
)
250 while (pos
< end
&& !CHAR_HEAD_P (POS_ADDR (end
)))
252 *next_boundary_p
= end
;
254 /* if the `invisible' property is set, we can skip to
255 the next property change */
256 if (!NILP (window
) && EQ (XWINDOW (window
)->buffer
, buffer
))
257 prop
= Fget_char_property (position
, Qinvisible
, window
);
259 prop
= Fget_char_property (position
, Qinvisible
, buffer
);
260 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
261 return *next_boundary_p
;
265 DEFUN ("current-column", Fcurrent_column
, Scurrent_column
, 0, 0, 0,
266 "Return the horizontal position of point. Beginning of line is column 0.\n\
267 This is calculated by adding together the widths of all the displayed\n\
268 representations of the character between the start of the previous line\n\
269 and point. (eg control characters will have a width of 2 or 4, tabs\n\
270 will have a variable width)\n\
271 Ignores finite width of frame, which means that this function may return\n\
272 values greater than (frame-width).\n\
273 Whether the line is visible (if `selective-display' is t) has no effect;\n\
274 however, ^M is treated as end of line when `selective-display' is t.")
278 XSETFASTINT (temp
, current_column ());
282 /* Cancel any recorded value of the horizontal position. */
284 invalidate_current_column ()
286 last_known_column_point
= 0;
293 register unsigned char *ptr
, *stop
;
294 register int tab_seen
;
297 register int tab_width
= XINT (current_buffer
->tab_width
);
298 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
299 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
302 if (PT
== last_known_column_point
303 && MODIFF
== last_known_column_modified
)
304 return last_known_column
;
306 /* If the buffer has overlays, text properties, or multibyte,
307 use a more general algorithm. */
308 if (BUF_INTERVALS (current_buffer
)
309 || !NILP (current_buffer
->overlays_before
)
310 || !NILP (current_buffer
->overlays_after
)
311 || !NILP (current_buffer
->enable_multibyte_characters
))
312 return current_column_1 (PT
);
314 /* Scan backwards from point to the previous newline,
315 counting width. Tab characters are the only complicated case. */
317 /* Make a pointer for decrementing through the chars before point. */
318 ptr
= POS_ADDR (PT
- 1) + 1;
319 /* Make a pointer to where consecutive chars leave off,
320 going backwards from point. */
323 else if (PT
<= GPT
|| BEGV
> GPT
)
328 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
330 col
= 0, tab_seen
= 0, post_tab
= 0;
336 /* We stopped either for the beginning of the buffer
338 if (ptr
== BEGV_ADDR
)
340 /* It was the gap. Jump back over it. */
343 /* Check whether that brings us to beginning of buffer. */
344 if (BEGV
>= GPT
) break;
348 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
349 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
350 else if (c
>= 040 && c
< 0177)
354 else if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
359 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
366 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
371 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
375 if (ptr
== BEGV_ADDR
)
376 current_column_bol_cache
= BEGV
;
378 current_column_bol_cache
= PTR_CHAR_POS ((ptr
+1));
379 last_known_column
= col
;
380 last_known_column_point
= PT
;
381 last_known_column_modified
= MODIFF
;
386 /* Return the column number of position POS
387 by scanning forward from the beginning of the line.
388 This function handles characters that are invisible
389 due to text properties or overlays. */
392 current_column_1 (pos
)
395 register int tab_width
= XINT (current_buffer
->tab_width
);
396 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
397 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
399 /* Start the scan at the beginning of this line with column number 0. */
400 register int col
= 0;
401 int scan
= current_column_bol_cache
= find_next_newline (pos
, -1);
402 int next_boundary
= scan
;
403 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
405 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
407 /* Scan forward to the target position. */
412 /* Occasionally we may need to skip invisible text. */
413 while (scan
== next_boundary
)
415 /* This updates NEXT_BOUNDARY to the next place
416 where we might need to skip more invisible text. */
417 scan
= skip_invisible (scan
, &next_boundary
, pos
, Qnil
);
422 c
= FETCH_BYTE (scan
);
423 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
425 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
431 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
438 col
= col
/ tab_width
* tab_width
;
440 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
443 /* Start of multi-byte form. */
444 if (c
== LEADING_CODE_COMPOSITION
)
446 unsigned char *ptr
= POS_ADDR (scan
);
448 int cmpchar_id
= str_cmpchar_id (ptr
, next_boundary
- scan
);
451 scan
+= cmpchar_table
[cmpchar_id
]->len
,
452 col
+= cmpchar_table
[cmpchar_id
]->width
;
455 { /* invalid composite character */
462 /* Here, we check that the following bytes are valid
463 constituents of multi-byte form. */
464 int len
= BYTES_BY_CHAR_HEAD (c
), i
;
466 for (i
= 1, scan
++; i
< len
; i
++, scan
++)
467 /* We don't need range checking for PTR because there
468 are anchors (`\0') at GAP and Z. */
469 if (CHAR_HEAD_P (POS_ADDR (scan
))) break;
471 col
+= 4, scan
-= i
- 1;
473 col
+= WIDTH_BY_CHAR_HEAD (c
);
476 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
478 else if (c
< 040 || c
>= 0177)
485 last_known_column
= col
;
486 last_known_column_point
= PT
;
487 last_known_column_modified
= MODIFF
;
492 /* Return the width in columns of the part of STRING from BEG to END.
493 If BEG is nil, that stands for the beginning of STRING.
494 If END is nil, that stands for the end of STRING. */
497 string_display_width (string
, beg
, end
)
498 Lisp_Object string
, beg
, end
;
501 register unsigned char *ptr
, *stop
;
502 register int tab_seen
;
505 register int tab_width
= XINT (current_buffer
->tab_width
);
506 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
507 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
511 e
= XSTRING (string
)->size
;
514 CHECK_NUMBER (end
, 0);
522 CHECK_NUMBER (beg
, 0);
526 /* Make a pointer for decrementing through the chars before point. */
527 ptr
= XSTRING (string
)->data
+ e
;
528 /* Make a pointer to where consecutive chars leave off,
529 going backwards from point. */
530 stop
= XSTRING (string
)->data
+ b
;
532 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
534 col
= 0, tab_seen
= 0, post_tab
= 0;
542 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
543 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
544 else if (c
>= 040 && c
< 0177)
551 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
558 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
563 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
570 DEFUN ("indent-to", Findent_to
, Sindent_to
, 1, 2, "NIndent to column: ",
571 "Indent from point with tabs and spaces until COLUMN is reached.\n\
572 Optional second argument MININUM says always do at least MININUM spaces\n\
573 even if that goes past COLUMN; by default, MININUM is zero.")
575 Lisp_Object column
, minimum
;
578 register int fromcol
;
579 register int tab_width
= XINT (current_buffer
->tab_width
);
581 CHECK_NUMBER (column
, 0);
583 XSETFASTINT (minimum
, 0);
584 CHECK_NUMBER (minimum
, 1);
586 fromcol
= current_column ();
587 mincol
= fromcol
+ XINT (minimum
);
588 if (mincol
< XINT (column
)) mincol
= XINT (column
);
590 if (fromcol
== mincol
)
591 return make_number (mincol
);
593 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
595 if (indent_tabs_mode
)
598 XSETFASTINT (n
, mincol
/ tab_width
- fromcol
/ tab_width
);
599 if (XFASTINT (n
) != 0)
601 Finsert_char (make_number ('\t'), n
, Qt
);
603 fromcol
= (mincol
/ tab_width
) * tab_width
;
607 XSETFASTINT (column
, mincol
- fromcol
);
608 Finsert_char (make_number (' '), column
, Qt
);
610 last_known_column
= mincol
;
611 last_known_column_point
= PT
;
612 last_known_column_modified
= MODIFF
;
614 XSETINT (column
, mincol
);
619 DEFUN ("current-indentation", Fcurrent_indentation
, Scurrent_indentation
,
621 "Return the indentation of the current line.\n\
622 This is the horizontal position of the character\n\
623 following any initial whitespace.")
628 XSETFASTINT (val
, position_indentation (find_next_newline (PT
, -1)));
632 position_indentation (pos
)
635 register int column
= 0;
636 register int tab_width
= XINT (current_buffer
->tab_width
);
637 register unsigned char *p
;
638 register unsigned char *stop
;
639 unsigned char *start
;
640 int next_boundary
= pos
;
643 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
646 /* STOP records the value of P at which we will need
647 to think about the gap, or about invisible text,
648 or about the end of the buffer. */
650 /* START records the starting value of P. */
658 /* If we have updated P, set POS to match.
659 The first time we enter the loop, POS is already right. */
661 pos
= PTR_CHAR_POS (p
);
662 /* Consider the various reasons STOP might have been set here. */
665 if (pos
== next_boundary
)
666 pos
= skip_invisible (pos
, &next_boundary
, ZV
, Qnil
);
668 ceiling
= BUFFER_CEILING_OF (pos
) + 1;
669 /* Compute the next place we need to stop and think,
670 and set STOP accordingly. */
671 stop_pos
= min (ceiling
, next_boundary
);
672 /* The -1 and +1 arrange to point at the first byte of gap
673 (if STOP_POS is the position of the gap)
674 rather than at the data after the gap. */
676 stop
= POS_ADDR (stop_pos
- 1) + 1;
685 column
+= tab_width
- column
% tab_width
;
693 /* Test whether the line beginning at POS is indented beyond COLUMN.
694 Blank lines are treated as if they had the same indentation as the
697 indented_beyond_p (pos
, column
)
700 while (pos
> BEGV
&& FETCH_BYTE (pos
) == '\n')
701 pos
= find_next_newline_no_quit (pos
- 1, -1);
702 return (position_indentation (pos
) >= column
);
705 DEFUN ("move-to-column", Fmove_to_column
, Smove_to_column
, 1, 2, "p",
706 "Move point to column COLUMN in the current line.\n\
707 The column of a character is calculated by adding together the widths\n\
708 as displayed of the previous characters in the line.\n\
709 This function ignores line-continuation;\n\
710 there is no upper limit on the column number a character can have\n\
711 and horizontal scrolling has no effect.\n\
713 If specified column is within a character, point goes after that character.\n\
714 If it's past end of line, point goes to end of line.\n\n\
715 A non-nil second (optional) argument FORCE means, if the line\n\
716 is too short to reach column COLUMN then add spaces/tabs to get there,\n\
717 and if COLUMN is in the middle of a tab character, change it to spaces.\n\
719 The return value is the current column.")
721 Lisp_Object column
, force
;
724 register int col
= current_column ();
727 register int tab_width
= XINT (current_buffer
->tab_width
);
728 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
729 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
730 register int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
738 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
739 CHECK_NATNUM (column
, 0);
740 goal
= XINT (column
);
746 /* If we're starting past the desired column,
747 back up to beginning of line and scan from there. */
751 pos
= current_column_bol_cache
;
757 while (pos
== next_boundary
)
759 pos
= skip_invisible (pos
, &next_boundary
, end
, Qnil
);
764 /* Test reaching the goal column. We do this after skipping
765 invisible characters, so that we put point before the
766 character on which the cursor will appear. */
770 c
= FETCH_BYTE (pos
);
771 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
773 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
779 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
786 col
= col
/ tab_width
* tab_width
;
788 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
790 else if (c
< 040 || c
== 0177)
794 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
796 /* Start of multi-byte form. */
799 pos
--; /* rewind to the character head */
800 ptr
= POS_ADDR (pos
);
801 if (c
== LEADING_CODE_COMPOSITION
)
803 int cmpchar_id
= str_cmpchar_id (ptr
, end
- pos
);
807 col
+= cmpchar_table
[cmpchar_id
]->width
;
808 pos
+= cmpchar_table
[cmpchar_id
]->len
;
811 { /* invalid composite character */
818 /* Here, we check that the following bytes are valid
819 constituents of multi-byte form. */
820 int len
= BYTES_BY_CHAR_HEAD (c
), i
;
822 for (i
= 1, ptr
++; i
< len
; i
++, ptr
++)
823 /* We don't need range checking for PTR because there
824 are anchors (`\0') both at GPT and Z. */
825 if (CHAR_HEAD_P (ptr
)) break;
829 col
+= WIDTH_BY_CHAR_HEAD (c
), pos
+= i
;
839 /* If a tab char made us overshoot, change it to spaces
840 and scan through it again. */
841 if (!NILP (force
) && col
> goal
&& c
== '\t' && prev_col
< goal
)
845 del_range (PT
- 1, PT
);
846 Findent_to (make_number (goal
), Qnil
);
848 Findent_to (make_number (col
), Qnil
);
850 /* Set the last_known... vars consistently. */
854 /* If line ends prematurely, add space to the end. */
855 if (col
< goal
&& !NILP (force
))
856 Findent_to (make_number (col
= goal
), Qnil
);
858 last_known_column
= col
;
859 last_known_column_point
= PT
;
860 last_known_column_modified
= MODIFF
;
862 XSETFASTINT (val
, col
);
866 /* compute_motion: compute buffer posn given screen posn and vice versa */
868 struct position val_compute_motion
;
870 /* Scan the current buffer forward from offset FROM, pretending that
871 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
872 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
873 and return the ending buffer position and screen location. If we
874 can't hit the requested column exactly (because of a tab or other
875 multi-column character), overshoot.
877 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
878 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
879 earlier call to compute_motion. The other common case is that FROMHPOS
880 is zero and FROM is a position that "belongs" at column zero, but might
881 be shifted by overlay strings; in this case DID_MOTION should be 0.
883 WIDTH is the number of columns available to display text;
884 compute_motion uses this to handle continuation lines and such.
885 HSCROLL is the number of columns not being displayed at the left
886 margin; this is usually taken from a window's hscroll member.
887 TAB_OFFSET is the number of columns of the first tab that aren't
888 being displayed, perhaps because of a continuation line or
891 compute_motion returns a pointer to a struct position. The bufpos
892 member gives the buffer position at the end of the scan, and hpos
893 and vpos give its cartesian location. prevhpos is the column at
894 which the character before bufpos started, and contin is non-zero
895 if we reached the current line by continuing the previous.
897 Note that FROMHPOS and TOHPOS should be expressed in real screen
898 columns, taking HSCROLL and the truncation glyph at the left margin
899 into account. That is, beginning-of-line moves you to the hpos
900 -HSCROLL + (HSCROLL > 0).
902 For example, to find the buffer position of column COL of line LINE
903 of a certain window, pass the window's starting location as FROM
904 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
905 Pass the buffer's ZV as TO, to limit the scan to the end of the
906 visible section of the buffer, and pass LINE and COL as TOVPOS and
909 When displaying in window w, a typical formula for WIDTH is:
912 - (has_vertical_scroll_bars
913 ? FRAME_SCROLL_BAR_COLS (XFRAME (window->frame))
914 : (window_width + window_left != frame_width))
917 window_width is XFASTINT (w->width),
918 window_left is XFASTINT (w->left),
919 has_vertical_scroll_bars is
920 FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (WINDOW_FRAME (window)))
921 and frame_width = FRAME_WIDTH (XFRAME (window->frame))
923 Or you can let window_internal_width do this all for you, and write:
924 window_internal_width (w) - 1
926 The `-1' accounts for the continuation-line backslashes; the rest
927 accounts for window borders if the window is split horizontally, and
928 the scroll bars if they are turned on. */
931 compute_motion (from
, fromvpos
, fromhpos
, did_motion
, to
, tovpos
, tohpos
, width
, hscroll
, tab_offset
, win
)
932 int from
, fromvpos
, fromhpos
, to
, tovpos
, tohpos
;
935 int hscroll
, tab_offset
;
938 register int hpos
= fromhpos
;
939 register int vpos
= fromvpos
;
943 register int tab_width
= XFASTINT (current_buffer
->tab_width
);
944 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
945 register struct Lisp_Char_Table
*dp
= window_display_table (win
);
947 = (INTEGERP (current_buffer
->selective_display
)
948 ? XINT (current_buffer
->selective_display
)
949 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
952 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
953 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
: 0);
954 /* The next location where the `invisible' property changes, or an
955 overlay starts or ends. */
956 int next_boundary
= from
;
958 /* For computing runs of characters with similar widths.
959 Invariant: width_run_width is zero, or all the characters
960 from width_run_start to width_run_end have a fixed width of
962 int width_run_start
= from
;
963 int width_run_end
= from
;
964 int width_run_width
= 0;
965 Lisp_Object
*width_table
;
968 /* The next buffer pos where we should consult the width run cache. */
969 int next_width_run
= from
;
972 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
973 int wide_column
= 0; /* Set to 1 when a previous character
975 int prev_pos
; /* Previous buffer position. */
976 int contin_hpos
; /* HPOS of last column of continued line. */
977 int prev_tab_offset
; /* Previous tab offset. */
979 XSETBUFFER (buffer
, current_buffer
);
980 XSETWINDOW (window
, win
);
982 width_run_cache_on_off ();
983 if (dp
== buffer_display_table ())
984 width_table
= (VECTORP (current_buffer
->width_table
)
985 ? XVECTOR (current_buffer
->width_table
)->contents
988 /* If the window has its own display table, we can't use the width
989 run cache, because that's based on the buffer's display table. */
992 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
994 pos
= prev_pos
= from
;
996 prev_tab_offset
= tab_offset
;
999 while (pos
== next_boundary
)
1003 /* If the caller says that the screen position came from an earlier
1004 call to compute_motion, then we've already accounted for the
1005 overlay strings at point. This is only true the first time
1006 through, so clear the flag after testing it. */
1008 /* We need to skip past the overlay strings. Currently those
1009 strings must not contain TAB;
1010 if we want to relax that restriction, something will have
1011 to be changed here. */
1013 unsigned char *ovstr
;
1014 int ovlen
= overlay_strings (pos
, win
, &ovstr
);
1015 hpos
+= (multibyte
? strwidth (ovstr
, ovlen
) : ovlen
);
1022 /* Advance POS past invisible characters
1023 (but not necessarily all that there are here),
1024 and store in next_boundary the next position where
1025 we need to call skip_invisible. */
1026 newpos
= skip_invisible (pos
, &next_boundary
, to
, window
);
1034 /* Handle right margin. */
1035 /* Note on a wide-column character.
1037 Characters are classified into the following three categories
1038 according to the width (columns occupied on screen).
1040 (1) single-column character: ex. `a'
1041 (2) multi-column character: ex. `^A', TAB, `\033'
1042 (3) wide-column character: ex. Japanese character, Chinese character
1043 (In the following example, `W_' stands for them.)
1045 Multi-column characters can be divided around the right margin,
1046 but wide-column characters cannot.
1050 (*) The cursor is placed on the next character after the point.
1054 j ^---- next after the point
1055 ^--- next char. after the point.
1057 In case of sigle-column character
1061 033 ^---- next after the point, next char. after the point.
1063 In case of multi-column character
1067 W_ ^---- next after the point
1068 ^---- next char. after the point.
1070 In case of wide-column character
1072 The problem here is continuation at a wide-column character.
1073 In this case, the line may shorter less than WIDTH.
1074 And we find the continuation AFTER it occurs.
1081 || (truncate_partial_width_windows
1082 && width
+ 1 < FRAME_WIDTH (XFRAME (WINDOW_FRAME (win
))))
1083 || !NILP (current_buffer
->truncate_lines
))
1085 /* Truncating: skip to newline. */
1086 if (pos
<= to
) /* This IF is needed because we may past TO */
1087 pos
= find_before_next_newline (pos
, to
, 1);
1089 /* If we just skipped next_boundary,
1090 loop around in the main while
1092 if (pos
>= next_boundary
)
1093 next_boundary
= pos
+ 1;
1095 prev_tab_offset
= tab_offset
;
1100 /* Remember the previous value. */
1101 prev_tab_offset
= tab_offset
;
1106 tab_offset
+= prev_hpos
;
1110 tab_offset
+= width
;
1114 contin_hpos
= prev_hpos
;
1119 /* Stop if past the target buffer position or screen position. */
1122 /* Go back to the previous position. */
1125 tab_offset
= prev_tab_offset
;
1127 /* NOTE on contin_hpos, hpos, and prev_hpos.
1131 W_ ^---- contin_hpos
1137 if (contin_hpos
&& prev_hpos
== 0
1138 && contin_hpos
< width
&& !wide_column
)
1140 /* Line breaking occurs in the middle of multi-column
1141 character. Go back to previous line. */
1146 /* If previous character is NEWLINE,
1147 set VPOS back to previous line */
1152 if (vpos
> tovpos
|| vpos
== tovpos
&& hpos
>= tohpos
)
1154 if (contin_hpos
&& prev_hpos
== 0
1155 && (contin_hpos
== width
|| wide_column
))
1156 { /* Line breaks because we can't put the character at the
1157 previous line any more. It is not the multi-column
1158 character continued in middle. Go back to previous
1159 buffer position, screen position, and set tab offset
1160 to previous value. It's the beginning of the
1164 tab_offset
= prev_tab_offset
;
1168 if (pos
== ZV
) /* We cannot go beyond ZV. Stop here. */
1175 /* Consult the width run cache to see if we can avoid inspecting
1176 the text character-by-character. */
1177 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
1181 = region_cache_forward (current_buffer
,
1182 current_buffer
->width_run_cache
,
1185 /* A width of zero means the character's width varies (like
1186 a tab), is meaningless (like a newline), or we just don't
1187 want to skip over it for some other reason. */
1188 if (common_width
!= 0)
1192 /* Don't go past the final buffer posn the user
1197 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1199 /* Don't go past the final horizontal position the user
1201 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
1203 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
1204 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1207 /* Don't go past the margin. */
1208 if (run_end_hpos
>= width
)
1210 run_end
= pos
+ (width
- hpos
) / common_width
;
1211 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1214 hpos
= run_end_hpos
;
1216 prev_hpos
= hpos
- common_width
;
1220 next_width_run
= run_end
+ 1;
1223 /* We have to scan the text character-by-character. */
1226 c
= FETCH_BYTE (pos
);
1229 /* Perhaps add some info to the width_run_cache. */
1230 if (current_buffer
->width_run_cache
)
1232 /* Is this character part of the current run? If so, extend
1234 if (pos
- 1 == width_run_end
1235 && XFASTINT (width_table
[c
]) == width_run_width
)
1236 width_run_end
= pos
;
1238 /* The previous run is over, since this is a character at a
1239 different position, or a different width. */
1242 /* Have we accumulated a run to put in the cache?
1243 (Currently, we only cache runs of width == 1). */
1244 if (width_run_start
< width_run_end
1245 && width_run_width
== 1)
1246 know_region_cache (current_buffer
,
1247 current_buffer
->width_run_cache
,
1248 width_run_start
, width_run_end
);
1250 /* Start recording a new width run. */
1251 width_run_width
= XFASTINT (width_table
[c
]);
1252 width_run_start
= pos
- 1;
1253 width_run_end
= pos
;
1257 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1258 hpos
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
1259 else if (c
>= 040 && c
< 0177)
1263 int tem
= (hpos
+ tab_offset
+ hscroll
- (hscroll
> 0)) % tab_width
;
1266 hpos
+= tab_width
- tem
;
1270 if (selective
> 0 && indented_beyond_p (pos
, selective
))
1272 /* If (pos == to), we don't have to take care of
1273 selective display. */
1276 /* Skip any number of invisible lines all at once */
1278 pos
= find_before_next_newline (pos
, to
, 1) + 1;
1280 && indented_beyond_p (pos
, selective
));
1281 /* Allow for the " ..." that is displayed for them. */
1284 hpos
+= selective_rlen
;
1289 /* We have skipped the invis text, but not the
1295 /* A visible line. */
1299 /* Count the truncation glyph on column 0 */
1306 else if (c
== CR
&& selective
< 0)
1308 /* In selective display mode,
1309 everything from a ^M to the end of the line is invisible.
1310 Stop *before* the real newline. */
1312 pos
= find_before_next_newline (pos
, to
, 1);
1313 /* If we just skipped next_boundary,
1314 loop around in the main while
1316 if (pos
> next_boundary
)
1317 next_boundary
= pos
;
1318 /* Allow for the " ..." that is displayed for them. */
1321 hpos
+= selective_rlen
;
1326 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
1328 /* Start of multi-byte form. */
1331 pos
--; /* rewind POS */
1332 ptr
= POS_ADDR (pos
);
1334 if (c
== LEADING_CODE_COMPOSITION
)
1336 int cmpchar_id
= str_cmpchar_id (ptr
, next_boundary
- pos
);
1338 if (cmpchar_id
>= 0)
1340 if (cmpchar_table
[cmpchar_id
]->width
>= 2)
1342 hpos
+= cmpchar_table
[cmpchar_id
]->width
;
1343 pos
+= cmpchar_table
[cmpchar_id
]->len
;
1346 { /* invalid composite character */
1353 /* Here, we check that the following bytes are valid
1354 constituents of multi-byte form. */
1355 int len
= BYTES_BY_CHAR_HEAD (c
), i
;
1357 for (i
= 1, ptr
++; i
< len
; i
++, ptr
++)
1358 /* We don't need range checking for PTR because
1359 there are anchors ('\0') both at GPT and Z. */
1360 if (CHAR_HEAD_P (ptr
)) break;
1364 hpos
+= WIDTH_BY_CHAR_HEAD (c
), pos
+= i
, wide_column
= 1;
1368 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
1374 /* Remember any final width run in the cache. */
1375 if (current_buffer
->width_run_cache
1376 && width_run_width
== 1
1377 && width_run_start
< width_run_end
)
1378 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
1379 width_run_start
, width_run_end
);
1381 val_compute_motion
.bufpos
= pos
;
1382 val_compute_motion
.hpos
= hpos
;
1383 val_compute_motion
.vpos
= vpos
;
1384 val_compute_motion
.prevhpos
= prev_hpos
;
1385 /* We alalways handle all of them here; none of them remain to do. */
1386 val_compute_motion
.ovstring_chars_done
= 0;
1388 /* Nonzero if have just continued a line */
1389 val_compute_motion
.contin
= (contin_hpos
&& prev_hpos
== 0);
1391 return &val_compute_motion
;
1394 #if 0 /* The doc string is too long for some compilers,
1395 but make-docfile can find it in this comment. */
1396 DEFUN ("compute-motion", Ffoo
, Sfoo
, 7, 7, 0,
1397 "Scan through the current buffer, calculating screen position.\n\
1398 Scan the current buffer forward from offset FROM,\n\
1399 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--\n\
1400 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--\n\
1401 and return the ending buffer position and screen location.\n\
1403 There are three additional arguments:\n\
1405 WIDTH is the number of columns available to display text;\n\
1406 this affects handling of continuation lines.\n\
1407 This is usually the value returned by `window-width', less one (to allow\n\
1408 for the continuation glyph).\n\
1410 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).\n\
1411 HSCROLL is the number of columns not being displayed at the left\n\
1412 margin; this is usually taken from a window's hscroll member.\n\
1413 TAB-OFFSET is the number of columns of the first tab that aren't\n\
1414 being displayed, perhaps because the line was continued within it.\n\
1415 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.\n\
1417 WINDOW is the window to operate on. It is used to choose the display table;\n\
1418 if it is showing the current buffer, it is used also for\n\
1419 deciding which overlay properties apply.\n\
1420 Note that `compute-motion' always operates on the current buffer.\n\
1422 The value is a list of five elements:\n\
1423 (POS HPOS VPOS PREVHPOS CONTIN)\n\
1424 POS is the buffer position where the scan stopped.\n\
1425 VPOS is the vertical position where the scan stopped.\n\
1426 HPOS is the horizontal position where the scan stopped.\n\
1428 PREVHPOS is the horizontal position one character back from POS.\n\
1429 CONTIN is t if a line was continued after (or within) the previous character.\n\
1431 For example, to find the buffer position of column COL of line LINE\n\
1432 of a certain window, pass the window's starting location as FROM\n\
1433 and the window's upper-left coordinates as FROMPOS.\n\
1434 Pass the buffer's (point-max) as TO, to limit the scan to the end of the\n\
1435 visible section of the buffer, and pass LINE and COL as TOPOS.")
1436 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1439 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
1441 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1442 Lisp_Object from
, frompos
, to
, topos
;
1443 Lisp_Object width
, offsets
, window
;
1445 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
, contin
;
1446 struct position
*pos
;
1447 int hscroll
, tab_offset
;
1449 CHECK_NUMBER_COERCE_MARKER (from
, 0);
1450 CHECK_CONS (frompos
, 0);
1451 CHECK_NUMBER (XCONS (frompos
)->car
, 0);
1452 CHECK_NUMBER (XCONS (frompos
)->cdr
, 0);
1453 CHECK_NUMBER_COERCE_MARKER (to
, 0);
1454 CHECK_CONS (topos
, 0);
1455 CHECK_NUMBER (XCONS (topos
)->car
, 0);
1456 CHECK_NUMBER (XCONS (topos
)->cdr
, 0);
1457 CHECK_NUMBER (width
, 0);
1458 if (!NILP (offsets
))
1460 CHECK_CONS (offsets
, 0);
1461 CHECK_NUMBER (XCONS (offsets
)->car
, 0);
1462 CHECK_NUMBER (XCONS (offsets
)->cdr
, 0);
1463 hscroll
= XINT (XCONS (offsets
)->car
);
1464 tab_offset
= XINT (XCONS (offsets
)->cdr
);
1467 hscroll
= tab_offset
= 0;
1470 window
= Fselected_window ();
1472 CHECK_LIVE_WINDOW (window
, 0);
1474 pos
= compute_motion (XINT (from
), XINT (XCONS (frompos
)->cdr
),
1475 XINT (XCONS (frompos
)->car
), 0,
1476 XINT (to
), XINT (XCONS (topos
)->cdr
),
1477 XINT (XCONS (topos
)->car
),
1478 XINT (width
), hscroll
, tab_offset
,
1481 XSETFASTINT (bufpos
, pos
->bufpos
);
1482 XSETINT (hpos
, pos
->hpos
);
1483 XSETINT (vpos
, pos
->vpos
);
1484 XSETINT (prevhpos
, pos
->prevhpos
);
1486 return Fcons (bufpos
,
1490 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
1494 /* Return the column of position POS in window W's buffer.
1495 The result is rounded down to a multiple of the internal width of W.
1496 This is the amount of indentation of position POS
1497 that is not visible in its horizontal position in the window. */
1500 pos_tab_offset (w
, pos
)
1506 int width
= window_internal_width (w
) - 1;
1509 return MINI_WINDOW_P (w
) ? -minibuf_prompt_width
: 0;
1510 if (FETCH_BYTE (pos
- 1) == '\n')
1513 col
= current_column ();
1514 TEMP_SET_PT (opoint
);
1515 /* Modulo is no longer valid, as a line may get shorter than WIDTH
1516 columns by continuation of a wide-column character. Just return
1519 /* In the continuation of the first line in a minibuffer we must
1520 take the width of the prompt into account. */
1521 if (MINI_WINDOW_P (w
) && col
>= width
- minibuf_prompt_width
1522 && find_next_newline_no_quit (pos
, -1) == BEGV
)
1523 return col
- (col
+ minibuf_prompt_width
) % width
;
1524 return col
- (col
% width
);
1530 /* Fvertical_motion and vmotion */
1531 struct position val_vmotion
;
1534 vmotion (from
, vtarget
, w
)
1535 register int from
, vtarget
;
1538 int width
= window_internal_width (w
) - 1;
1539 int hscroll
= XINT (w
->hscroll
);
1540 struct position pos
;
1541 /* vpos is cumulative vertical position, changed as from is changed */
1542 register int vpos
= 0;
1543 Lisp_Object prevline
;
1545 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1547 = (INTEGERP (current_buffer
->selective_display
)
1548 ? XINT (current_buffer
->selective_display
)
1549 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1554 XSETWINDOW (window
, w
);
1556 /* The omission of the clause
1557 && marker_position (w->start) == BEG
1558 here is deliberate; I think we want to measure from the prompt
1559 position even if the minibuffer window has scrolled. */
1560 if (EQ (window
, minibuf_window
))
1562 if (minibuf_prompt_width
== 0 && STRINGP (minibuf_prompt
))
1563 minibuf_prompt_width
1564 = string_display_width (minibuf_prompt
, Qnil
, Qnil
);
1566 start_hpos
= minibuf_prompt_width
;
1569 if (vpos
>= vtarget
)
1571 /* To move upward, go a line at a time until
1572 we have gone at least far enough */
1576 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1578 Lisp_Object propval
;
1580 XSETFASTINT (prevline
, find_next_newline_no_quit (from
- 1, -1));
1581 while (XFASTINT (prevline
) > BEGV
1583 && indented_beyond_p (XFASTINT (prevline
), selective
))
1584 #ifdef USE_TEXT_PROPERTIES
1585 /* watch out for newlines with `invisible' property */
1586 || (propval
= Fget_char_property (prevline
,
1589 TEXT_PROP_MEANS_INVISIBLE (propval
))
1592 XSETFASTINT (prevline
,
1593 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1595 pos
= *compute_motion (XFASTINT (prevline
), 0,
1596 lmargin
+ (XFASTINT (prevline
) == BEG
1600 /* Don't care for VPOS... */
1601 1 << (BITS_PER_SHORT
- 1),
1603 1 << (BITS_PER_SHORT
- 1),
1605 /* This compensates for start_hpos
1606 so that a tab as first character
1607 still occupies 8 columns. */
1608 (XFASTINT (prevline
) == BEG
1613 from
= XFASTINT (prevline
);
1616 /* If we made exactly the desired vertical distance,
1617 or if we hit beginning of buffer,
1618 return point found */
1619 if (vpos
>= vtarget
)
1621 val_vmotion
.bufpos
= from
;
1622 val_vmotion
.vpos
= vpos
;
1623 val_vmotion
.hpos
= lmargin
;
1624 val_vmotion
.contin
= 0;
1625 val_vmotion
.prevhpos
= 0;
1626 val_vmotion
.ovstring_chars_done
= 0;
1627 val_vmotion
.tab_offset
= 0; /* For accumulating tab offset. */
1628 return &val_vmotion
;
1631 /* Otherwise find the correct spot by moving down */
1633 /* Moving downward is simple, but must calculate from beg of line
1634 to determine hpos of starting point */
1635 if (from
> BEGV
&& FETCH_BYTE (from
- 1) != '\n')
1637 Lisp_Object propval
;
1639 XSETFASTINT (prevline
, find_next_newline_no_quit (from
, -1));
1640 while (XFASTINT (prevline
) > BEGV
1642 && indented_beyond_p (XFASTINT (prevline
), selective
))
1643 #ifdef USE_TEXT_PROPERTIES
1644 /* watch out for newlines with `invisible' property */
1645 || (propval
= Fget_char_property (prevline
, Qinvisible
,
1647 TEXT_PROP_MEANS_INVISIBLE (propval
))
1650 XSETFASTINT (prevline
,
1651 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1653 pos
= *compute_motion (XFASTINT (prevline
), 0,
1654 lmargin
+ (XFASTINT (prevline
) == BEG
1658 /* Don't care for VPOS... */
1659 1 << (BITS_PER_SHORT
- 1),
1661 1 << (BITS_PER_SHORT
- 1),
1663 (XFASTINT (prevline
) == BEG
? -start_hpos
: 0),
1669 pos
.hpos
= lmargin
+ (from
== BEG
? start_hpos
: 0);
1674 return compute_motion (from
, vpos
, pos
.hpos
, did_motion
,
1675 ZV
, vtarget
, - (1 << (BITS_PER_SHORT
- 1)),
1677 pos
.tab_offset
- (from
== BEG
? start_hpos
: 0),
1681 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
1682 "Move point to start of the screen line LINES lines down.\n\
1683 If LINES is negative, this means moving up.\n\
1685 This function is an ordinary cursor motion function\n\
1686 which calculates the new position based on how text would be displayed.\n\
1687 The new position may be the start of a line,\n\
1688 or just the start of a continuation line.\n\
1689 The function returns number of screen lines moved over;\n\
1690 that usually equals LINES, but may be closer to zero\n\
1691 if beginning or end of buffer was reached.\n\
1693 The optional second argument WINDOW specifies the window to use for\n\
1694 parameters such as width, horizontal scrolling, and so on.\n\
1695 The default is to use the selected window's parameters.\n\
1697 `vertical-motion' always uses the current buffer,\n\
1698 regardless of which buffer is displayed in WINDOW.\n\
1699 This is consistent with other cursor motion functions\n\
1700 and makes it possible to use `vertical-motion' in any buffer,\n\
1701 whether or not it is currently displayed in some window.")
1703 Lisp_Object lines
, window
;
1705 struct position pos
;
1707 CHECK_NUMBER (lines
, 0);
1708 if (! NILP (window
))
1709 CHECK_WINDOW (window
, 0);
1711 window
= selected_window
;
1713 pos
= *vmotion (PT
, (int) XINT (lines
), XWINDOW (window
));
1715 SET_PT (pos
.bufpos
);
1716 return make_number (pos
.vpos
);
1719 /* file's initialization. */
1723 DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode
,
1724 "*Indentation can insert tabs if this is non-nil.\n\
1725 Setting this variable automatically makes it local to the current buffer.");
1726 indent_tabs_mode
= 1;
1728 defsubr (&Scurrent_indentation
);
1729 defsubr (&Sindent_to
);
1730 defsubr (&Scurrent_column
);
1731 defsubr (&Smove_to_column
);
1732 defsubr (&Svertical_motion
);
1733 defsubr (&Scompute_motion
);