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)
353 || (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
)))
361 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
368 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
373 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
377 if (ptr
== BEGV_ADDR
)
378 current_column_bol_cache
= BEGV
;
380 current_column_bol_cache
= PTR_CHAR_POS (ptr
);
381 last_known_column
= col
;
382 last_known_column_point
= PT
;
383 last_known_column_modified
= MODIFF
;
388 /* Return the column number of position POS
389 by scanning forward from the beginning of the line.
390 This function handles characters that are invisible
391 due to text properties or overlays. */
394 current_column_1 (pos
)
397 register int tab_width
= XINT (current_buffer
->tab_width
);
398 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
399 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
401 /* Start the scan at the beginning of this line with column number 0. */
402 register int col
= 0;
403 int scan
= current_column_bol_cache
= find_next_newline (pos
, -1);
404 int next_boundary
= scan
;
405 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
407 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
409 /* Scan forward to the target position. */
414 /* Occasionally we may need to skip invisible text. */
415 while (scan
== next_boundary
)
417 /* This updates NEXT_BOUNDARY to the next place
418 where we might need to skip more invisible text. */
419 scan
= skip_invisible (scan
, &next_boundary
, pos
, Qnil
);
424 c
= FETCH_BYTE (scan
);
425 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
427 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
433 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
440 col
= col
/ tab_width
* tab_width
;
442 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
445 /* Start of multi-byte form. */
446 if (c
== LEADING_CODE_COMPOSITION
)
448 unsigned char *ptr
= POS_ADDR (scan
);
450 int cmpchar_id
= str_cmpchar_id (ptr
, next_boundary
- scan
);
453 scan
+= cmpchar_table
[cmpchar_id
]->len
,
454 col
+= cmpchar_table
[cmpchar_id
]->width
;
457 { /* invalid composite character */
464 /* Here, we check that the following bytes are valid
465 constituents of multi-byte form. */
466 int len
= BYTES_BY_CHAR_HEAD (c
), i
;
468 for (i
= 1, scan
++; i
< len
; i
++, scan
++)
469 /* We don't need range checking for PTR because there
470 are anchors (`\0') at GAP and Z. */
471 if (CHAR_HEAD_P (POS_ADDR (scan
))) break;
473 col
+= 4, scan
-= i
- 1;
475 col
+= WIDTH_BY_CHAR_HEAD (c
);
478 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
480 else if (c
< 040 || c
>= 0177)
487 last_known_column
= col
;
488 last_known_column_point
= PT
;
489 last_known_column_modified
= MODIFF
;
494 /* Return the width in columns of the part of STRING from BEG to END.
495 If BEG is nil, that stands for the beginning of STRING.
496 If END is nil, that stands for the end of STRING. */
499 string_display_width (string
, beg
, end
)
500 Lisp_Object string
, beg
, end
;
503 register unsigned char *ptr
, *stop
;
504 register int tab_seen
;
507 register int tab_width
= XINT (current_buffer
->tab_width
);
508 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
509 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
513 e
= XSTRING (string
)->size
;
516 CHECK_NUMBER (end
, 0);
524 CHECK_NUMBER (beg
, 0);
528 /* Make a pointer for decrementing through the chars before point. */
529 ptr
= XSTRING (string
)->data
+ e
;
530 /* Make a pointer to where consecutive chars leave off,
531 going backwards from point. */
532 stop
= XSTRING (string
)->data
+ b
;
534 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
536 col
= 0, tab_seen
= 0, post_tab
= 0;
544 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
545 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
546 else if (c
>= 040 && c
< 0177)
553 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
560 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
565 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
572 DEFUN ("indent-to", Findent_to
, Sindent_to
, 1, 2, "NIndent to column: ",
573 "Indent from point with tabs and spaces until COLUMN is reached.\n\
574 Optional second argument MININUM says always do at least MININUM spaces\n\
575 even if that goes past COLUMN; by default, MININUM is zero.")
577 Lisp_Object column
, minimum
;
580 register int fromcol
;
581 register int tab_width
= XINT (current_buffer
->tab_width
);
583 CHECK_NUMBER (column
, 0);
585 XSETFASTINT (minimum
, 0);
586 CHECK_NUMBER (minimum
, 1);
588 fromcol
= current_column ();
589 mincol
= fromcol
+ XINT (minimum
);
590 if (mincol
< XINT (column
)) mincol
= XINT (column
);
592 if (fromcol
== mincol
)
593 return make_number (mincol
);
595 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
597 if (indent_tabs_mode
)
600 XSETFASTINT (n
, mincol
/ tab_width
- fromcol
/ tab_width
);
601 if (XFASTINT (n
) != 0)
603 Finsert_char (make_number ('\t'), n
, Qt
);
605 fromcol
= (mincol
/ tab_width
) * tab_width
;
609 XSETFASTINT (column
, mincol
- fromcol
);
610 Finsert_char (make_number (' '), column
, Qt
);
612 last_known_column
= mincol
;
613 last_known_column_point
= PT
;
614 last_known_column_modified
= MODIFF
;
616 XSETINT (column
, mincol
);
621 DEFUN ("current-indentation", Fcurrent_indentation
, Scurrent_indentation
,
623 "Return the indentation of the current line.\n\
624 This is the horizontal position of the character\n\
625 following any initial whitespace.")
630 XSETFASTINT (val
, position_indentation (find_next_newline (PT
, -1)));
634 position_indentation (pos
)
637 register int column
= 0;
638 register int tab_width
= XINT (current_buffer
->tab_width
);
639 register unsigned char *p
;
640 register unsigned char *stop
;
641 unsigned char *start
;
642 int next_boundary
= pos
;
645 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
648 /* STOP records the value of P at which we will need
649 to think about the gap, or about invisible text,
650 or about the end of the buffer. */
652 /* START records the starting value of P. */
660 /* If we have updated P, set POS to match.
661 The first time we enter the loop, POS is already right. */
663 pos
= PTR_CHAR_POS (p
);
664 /* Consider the various reasons STOP might have been set here. */
667 if (pos
== next_boundary
)
668 pos
= skip_invisible (pos
, &next_boundary
, ZV
, Qnil
);
670 ceiling
= BUFFER_CEILING_OF (pos
) + 1;
671 /* Compute the next place we need to stop and think,
672 and set STOP accordingly. */
673 stop_pos
= min (ceiling
, next_boundary
);
674 /* The -1 and +1 arrange to point at the first byte of gap
675 (if STOP_POS is the position of the gap)
676 rather than at the data after the gap. */
678 stop
= POS_ADDR (stop_pos
- 1) + 1;
687 column
+= tab_width
- column
% tab_width
;
695 /* Test whether the line beginning at POS is indented beyond COLUMN.
696 Blank lines are treated as if they had the same indentation as the
699 indented_beyond_p (pos
, column
)
702 while (pos
> BEGV
&& FETCH_BYTE (pos
) == '\n')
703 pos
= find_next_newline_no_quit (pos
- 1, -1);
704 return (position_indentation (pos
) >= column
);
707 DEFUN ("move-to-column", Fmove_to_column
, Smove_to_column
, 1, 2, "p",
708 "Move point to column COLUMN in the current line.\n\
709 The column of a character is calculated by adding together the widths\n\
710 as displayed of the previous characters in the line.\n\
711 This function ignores line-continuation;\n\
712 there is no upper limit on the column number a character can have\n\
713 and horizontal scrolling has no effect.\n\
715 If specified column is within a character, point goes after that character.\n\
716 If it's past end of line, point goes to end of line.\n\n\
717 A non-nil second (optional) argument FORCE means, if the line\n\
718 is too short to reach column COLUMN then add spaces/tabs to get there,\n\
719 and if COLUMN is in the middle of a tab character, change it to spaces.\n\
721 The return value is the current column.")
723 Lisp_Object column
, force
;
726 register int col
= current_column ();
729 register int tab_width
= XINT (current_buffer
->tab_width
);
730 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
731 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
732 register int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
740 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
741 CHECK_NATNUM (column
, 0);
742 goal
= XINT (column
);
748 /* If we're starting past the desired column,
749 back up to beginning of line and scan from there. */
753 pos
= current_column_bol_cache
;
759 while (pos
== next_boundary
)
761 pos
= skip_invisible (pos
, &next_boundary
, end
, Qnil
);
766 /* Test reaching the goal column. We do this after skipping
767 invisible characters, so that we put point before the
768 character on which the cursor will appear. */
772 c
= FETCH_BYTE (pos
);
773 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
775 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
781 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
788 col
= col
/ tab_width
* tab_width
;
790 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
792 else if (c
< 040 || c
== 0177)
796 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
798 /* Start of multi-byte form. */
801 pos
--; /* rewind to the character head */
802 ptr
= POS_ADDR (pos
);
803 if (c
== LEADING_CODE_COMPOSITION
)
805 int cmpchar_id
= str_cmpchar_id (ptr
, end
- pos
);
809 col
+= cmpchar_table
[cmpchar_id
]->width
;
810 pos
+= cmpchar_table
[cmpchar_id
]->len
;
813 { /* invalid composite character */
820 /* Here, we check that the following bytes are valid
821 constituents of multi-byte form. */
822 int len
= BYTES_BY_CHAR_HEAD (c
), i
;
824 for (i
= 1, ptr
++; i
< len
; i
++, ptr
++)
825 /* We don't need range checking for PTR because there
826 are anchors (`\0') both at GPT and Z. */
827 if (CHAR_HEAD_P (ptr
)) break;
831 col
+= WIDTH_BY_CHAR_HEAD (c
), pos
+= i
;
841 /* If a tab char made us overshoot, change it to spaces
842 and scan through it again. */
843 if (!NILP (force
) && col
> goal
&& c
== '\t' && prev_col
< goal
)
847 del_range (PT
- 1, PT
);
848 Findent_to (make_number (goal
), Qnil
);
850 Findent_to (make_number (col
), Qnil
);
852 /* Set the last_known... vars consistently. */
856 /* If line ends prematurely, add space to the end. */
857 if (col
< goal
&& !NILP (force
))
858 Findent_to (make_number (col
= goal
), Qnil
);
860 last_known_column
= col
;
861 last_known_column_point
= PT
;
862 last_known_column_modified
= MODIFF
;
864 XSETFASTINT (val
, col
);
868 /* compute_motion: compute buffer posn given screen posn and vice versa */
870 struct position val_compute_motion
;
872 /* Scan the current buffer forward from offset FROM, pretending that
873 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
874 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
875 and return the ending buffer position and screen location. If we
876 can't hit the requested column exactly (because of a tab or other
877 multi-column character), overshoot.
879 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
880 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
881 earlier call to compute_motion. The other common case is that FROMHPOS
882 is zero and FROM is a position that "belongs" at column zero, but might
883 be shifted by overlay strings; in this case DID_MOTION should be 0.
885 WIDTH is the number of columns available to display text;
886 compute_motion uses this to handle continuation lines and such.
887 HSCROLL is the number of columns not being displayed at the left
888 margin; this is usually taken from a window's hscroll member.
889 TAB_OFFSET is the number of columns of the first tab that aren't
890 being displayed, perhaps because of a continuation line or
893 compute_motion returns a pointer to a struct position. The bufpos
894 member gives the buffer position at the end of the scan, and hpos
895 and vpos give its cartesian location. prevhpos is the column at
896 which the character before bufpos started, and contin is non-zero
897 if we reached the current line by continuing the previous.
899 Note that FROMHPOS and TOHPOS should be expressed in real screen
900 columns, taking HSCROLL and the truncation glyph at the left margin
901 into account. That is, beginning-of-line moves you to the hpos
902 -HSCROLL + (HSCROLL > 0).
904 For example, to find the buffer position of column COL of line LINE
905 of a certain window, pass the window's starting location as FROM
906 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
907 Pass the buffer's ZV as TO, to limit the scan to the end of the
908 visible section of the buffer, and pass LINE and COL as TOVPOS and
911 When displaying in window w, a typical formula for WIDTH is:
914 - (has_vertical_scroll_bars
915 ? FRAME_SCROLL_BAR_COLS (XFRAME (window->frame))
916 : (window_width + window_left != frame_width))
919 window_width is XFASTINT (w->width),
920 window_left is XFASTINT (w->left),
921 has_vertical_scroll_bars is
922 FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (WINDOW_FRAME (window)))
923 and frame_width = FRAME_WIDTH (XFRAME (window->frame))
925 Or you can let window_internal_width do this all for you, and write:
926 window_internal_width (w) - 1
928 The `-1' accounts for the continuation-line backslashes; the rest
929 accounts for window borders if the window is split horizontally, and
930 the scroll bars if they are turned on. */
933 compute_motion (from
, fromvpos
, fromhpos
, did_motion
, to
, tovpos
, tohpos
, width
, hscroll
, tab_offset
, win
)
934 int from
, fromvpos
, fromhpos
, to
, tovpos
, tohpos
;
937 int hscroll
, tab_offset
;
940 register int hpos
= fromhpos
;
941 register int vpos
= fromvpos
;
945 register int tab_width
= XFASTINT (current_buffer
->tab_width
);
946 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
947 register struct Lisp_Char_Table
*dp
= window_display_table (win
);
949 = (INTEGERP (current_buffer
->selective_display
)
950 ? XINT (current_buffer
->selective_display
)
951 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
954 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
955 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
: 0);
956 /* The next location where the `invisible' property changes, or an
957 overlay starts or ends. */
958 int next_boundary
= from
;
960 /* For computing runs of characters with similar widths.
961 Invariant: width_run_width is zero, or all the characters
962 from width_run_start to width_run_end have a fixed width of
964 int width_run_start
= from
;
965 int width_run_end
= from
;
966 int width_run_width
= 0;
967 Lisp_Object
*width_table
;
970 /* The next buffer pos where we should consult the width run cache. */
971 int next_width_run
= from
;
974 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
975 int wide_column
= 0; /* Set to 1 when a previous character
977 int prev_pos
; /* Previous buffer position. */
978 int contin_hpos
; /* HPOS of last column of continued line. */
979 int prev_tab_offset
; /* Previous tab offset. */
981 XSETBUFFER (buffer
, current_buffer
);
982 XSETWINDOW (window
, win
);
984 width_run_cache_on_off ();
985 if (dp
== buffer_display_table ())
986 width_table
= (VECTORP (current_buffer
->width_table
)
987 ? XVECTOR (current_buffer
->width_table
)->contents
990 /* If the window has its own display table, we can't use the width
991 run cache, because that's based on the buffer's display table. */
994 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
996 pos
= prev_pos
= from
;
998 prev_tab_offset
= tab_offset
;
1001 while (pos
== next_boundary
)
1005 /* If the caller says that the screen position came from an earlier
1006 call to compute_motion, then we've already accounted for the
1007 overlay strings at point. This is only true the first time
1008 through, so clear the flag after testing it. */
1010 /* We need to skip past the overlay strings. Currently those
1011 strings must not contain TAB;
1012 if we want to relax that restriction, something will have
1013 to be changed here. */
1015 unsigned char *ovstr
;
1016 int ovlen
= overlay_strings (pos
, win
, &ovstr
);
1017 hpos
+= (multibyte
? strwidth (ovstr
, ovlen
) : ovlen
);
1024 /* Advance POS past invisible characters
1025 (but not necessarily all that there are here),
1026 and store in next_boundary the next position where
1027 we need to call skip_invisible. */
1028 newpos
= skip_invisible (pos
, &next_boundary
, to
, window
);
1036 /* Handle right margin. */
1037 /* Note on a wide-column character.
1039 Characters are classified into the following three categories
1040 according to the width (columns occupied on screen).
1042 (1) single-column character: ex. `a'
1043 (2) multi-column character: ex. `^A', TAB, `\033'
1044 (3) wide-column character: ex. Japanese character, Chinese character
1045 (In the following example, `W_' stands for them.)
1047 Multi-column characters can be divided around the right margin,
1048 but wide-column characters cannot.
1052 (*) The cursor is placed on the next character after the point.
1056 j ^---- next after the point
1057 ^--- next char. after the point.
1059 In case of sigle-column character
1063 033 ^---- next after the point, next char. after the point.
1065 In case of multi-column character
1069 W_ ^---- next after the point
1070 ^---- next char. after the point.
1072 In case of wide-column character
1074 The problem here is continuation at a wide-column character.
1075 In this case, the line may shorter less than WIDTH.
1076 And we find the continuation AFTER it occurs.
1083 || (truncate_partial_width_windows
1084 && width
+ 1 < FRAME_WIDTH (XFRAME (WINDOW_FRAME (win
))))
1085 || !NILP (current_buffer
->truncate_lines
))
1087 /* Truncating: skip to newline. */
1088 if (pos
<= to
) /* This IF is needed because we may past TO */
1089 pos
= find_before_next_newline (pos
, to
, 1);
1091 /* If we just skipped next_boundary,
1092 loop around in the main while
1094 if (pos
>= next_boundary
)
1095 next_boundary
= pos
+ 1;
1097 prev_tab_offset
= tab_offset
;
1102 /* Remember the previous value. */
1103 prev_tab_offset
= tab_offset
;
1108 tab_offset
+= prev_hpos
;
1112 tab_offset
+= width
;
1116 contin_hpos
= prev_hpos
;
1121 /* Stop if past the target buffer position or screen position. */
1124 /* Go back to the previous position. */
1127 tab_offset
= prev_tab_offset
;
1129 /* NOTE on contin_hpos, hpos, and prev_hpos.
1133 W_ ^---- contin_hpos
1139 if (contin_hpos
&& prev_hpos
== 0
1140 && contin_hpos
< width
&& !wide_column
)
1142 /* Line breaking occurs in the middle of multi-column
1143 character. Go back to previous line. */
1148 /* If previous character is NEWLINE,
1149 set VPOS back to previous line */
1154 if (vpos
> tovpos
|| vpos
== tovpos
&& hpos
>= tohpos
)
1156 if (contin_hpos
&& prev_hpos
== 0
1157 && ((hpos
> tohpos
&& contin_hpos
== width
) || wide_column
))
1158 { /* Line breaks because we can't put the character at the
1159 previous line any more. It is not the multi-column
1160 character continued in middle. Go back to previous
1161 buffer position, screen position, and set tab offset
1162 to previous value. It's the beginning of the
1166 tab_offset
= prev_tab_offset
;
1170 if (pos
== ZV
) /* We cannot go beyond ZV. Stop here. */
1177 /* Consult the width run cache to see if we can avoid inspecting
1178 the text character-by-character. */
1179 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
1183 = region_cache_forward (current_buffer
,
1184 current_buffer
->width_run_cache
,
1187 /* A width of zero means the character's width varies (like
1188 a tab), is meaningless (like a newline), or we just don't
1189 want to skip over it for some other reason. */
1190 if (common_width
!= 0)
1194 /* Don't go past the final buffer posn the user
1199 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1201 /* Don't go past the final horizontal position the user
1203 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
1205 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
1206 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1209 /* Don't go past the margin. */
1210 if (run_end_hpos
>= width
)
1212 run_end
= pos
+ (width
- hpos
) / common_width
;
1213 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1216 hpos
= run_end_hpos
;
1218 prev_hpos
= hpos
- common_width
;
1222 next_width_run
= run_end
+ 1;
1225 /* We have to scan the text character-by-character. */
1228 c
= FETCH_BYTE (pos
);
1231 /* Perhaps add some info to the width_run_cache. */
1232 if (current_buffer
->width_run_cache
)
1234 /* Is this character part of the current run? If so, extend
1236 if (pos
- 1 == width_run_end
1237 && XFASTINT (width_table
[c
]) == width_run_width
)
1238 width_run_end
= pos
;
1240 /* The previous run is over, since this is a character at a
1241 different position, or a different width. */
1244 /* Have we accumulated a run to put in the cache?
1245 (Currently, we only cache runs of width == 1). */
1246 if (width_run_start
< width_run_end
1247 && width_run_width
== 1)
1248 know_region_cache (current_buffer
,
1249 current_buffer
->width_run_cache
,
1250 width_run_start
, width_run_end
);
1252 /* Start recording a new width run. */
1253 width_run_width
= XFASTINT (width_table
[c
]);
1254 width_run_start
= pos
- 1;
1255 width_run_end
= pos
;
1259 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
))
1260 && ! (multibyte
&& BASE_LEADING_CODE_P (c
)))
1261 hpos
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
1262 else if (c
>= 040 && c
< 0177)
1266 int tem
= (hpos
+ tab_offset
+ hscroll
- (hscroll
> 0)) % tab_width
;
1269 hpos
+= tab_width
- tem
;
1273 if (selective
> 0 && indented_beyond_p (pos
, selective
))
1275 /* If (pos == to), we don't have to take care of
1276 selective display. */
1279 /* Skip any number of invisible lines all at once */
1281 pos
= find_before_next_newline (pos
, to
, 1) + 1;
1283 && indented_beyond_p (pos
, selective
));
1284 /* Allow for the " ..." that is displayed for them. */
1287 hpos
+= selective_rlen
;
1292 /* We have skipped the invis text, but not the
1298 /* A visible line. */
1302 /* Count the truncation glyph on column 0 */
1309 else if (c
== CR
&& selective
< 0)
1311 /* In selective display mode,
1312 everything from a ^M to the end of the line is invisible.
1313 Stop *before* the real newline. */
1315 pos
= find_before_next_newline (pos
, to
, 1);
1316 /* If we just skipped next_boundary,
1317 loop around in the main while
1319 if (pos
> next_boundary
)
1320 next_boundary
= pos
;
1321 /* Allow for the " ..." that is displayed for them. */
1324 hpos
+= selective_rlen
;
1329 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
1331 /* Start of multi-byte form. */
1333 int len
, actual_len
;
1335 pos
--; /* rewind POS */
1337 ptr
= (((pos
) >= GPT
? GAP_SIZE
: 0) + (pos
) + BEG_ADDR
- 1);
1338 len
= ((pos
) >= GPT
? ZV
: GPT
) - (pos
);
1340 c
= STRING_CHAR_AND_LENGTH (ptr
, len
, actual_len
);
1342 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1343 hpos
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
1344 else if (actual_len
== 1)
1346 else if (COMPOSITE_CHAR_P (c
))
1348 int id
= COMPOSITE_CHAR_ID (c
);
1349 int width
= (id
< n_cmpchars
) ? cmpchar_table
[id
]->width
: 0;
1356 int width
= WIDTH_BY_CHAR_HEAD (*ptr
);
1365 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
1371 /* Remember any final width run in the cache. */
1372 if (current_buffer
->width_run_cache
1373 && width_run_width
== 1
1374 && width_run_start
< width_run_end
)
1375 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
1376 width_run_start
, width_run_end
);
1378 val_compute_motion
.bufpos
= pos
;
1379 val_compute_motion
.hpos
= hpos
;
1380 val_compute_motion
.vpos
= vpos
;
1381 val_compute_motion
.prevhpos
= prev_hpos
;
1382 /* We alalways handle all of them here; none of them remain to do. */
1383 val_compute_motion
.ovstring_chars_done
= 0;
1385 /* Nonzero if have just continued a line */
1386 val_compute_motion
.contin
= (contin_hpos
&& prev_hpos
== 0);
1388 return &val_compute_motion
;
1391 #if 0 /* The doc string is too long for some compilers,
1392 but make-docfile can find it in this comment. */
1393 DEFUN ("compute-motion", Ffoo
, Sfoo
, 7, 7, 0,
1394 "Scan through the current buffer, calculating screen position.\n\
1395 Scan the current buffer forward from offset FROM,\n\
1396 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--\n\
1397 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--\n\
1398 and return the ending buffer position and screen location.\n\
1400 There are three additional arguments:\n\
1402 WIDTH is the number of columns available to display text;\n\
1403 this affects handling of continuation lines.\n\
1404 This is usually the value returned by `window-width', less one (to allow\n\
1405 for the continuation glyph).\n\
1407 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).\n\
1408 HSCROLL is the number of columns not being displayed at the left\n\
1409 margin; this is usually taken from a window's hscroll member.\n\
1410 TAB-OFFSET is the number of columns of the first tab that aren't\n\
1411 being displayed, perhaps because the line was continued within it.\n\
1412 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.\n\
1414 WINDOW is the window to operate on. It is used to choose the display table;\n\
1415 if it is showing the current buffer, it is used also for\n\
1416 deciding which overlay properties apply.\n\
1417 Note that `compute-motion' always operates on the current buffer.\n\
1419 The value is a list of five elements:\n\
1420 (POS HPOS VPOS PREVHPOS CONTIN)\n\
1421 POS is the buffer position where the scan stopped.\n\
1422 VPOS is the vertical position where the scan stopped.\n\
1423 HPOS is the horizontal position where the scan stopped.\n\
1425 PREVHPOS is the horizontal position one character back from POS.\n\
1426 CONTIN is t if a line was continued after (or within) the previous character.\n\
1428 For example, to find the buffer position of column COL of line LINE\n\
1429 of a certain window, pass the window's starting location as FROM\n\
1430 and the window's upper-left coordinates as FROMPOS.\n\
1431 Pass the buffer's (point-max) as TO, to limit the scan to the end of the\n\
1432 visible section of the buffer, and pass LINE and COL as TOPOS.")
1433 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1436 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
1438 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1439 Lisp_Object from
, frompos
, to
, topos
;
1440 Lisp_Object width
, offsets
, window
;
1442 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
, contin
;
1443 struct position
*pos
;
1444 int hscroll
, tab_offset
;
1446 CHECK_NUMBER_COERCE_MARKER (from
, 0);
1447 CHECK_CONS (frompos
, 0);
1448 CHECK_NUMBER (XCONS (frompos
)->car
, 0);
1449 CHECK_NUMBER (XCONS (frompos
)->cdr
, 0);
1450 CHECK_NUMBER_COERCE_MARKER (to
, 0);
1451 CHECK_CONS (topos
, 0);
1452 CHECK_NUMBER (XCONS (topos
)->car
, 0);
1453 CHECK_NUMBER (XCONS (topos
)->cdr
, 0);
1454 CHECK_NUMBER (width
, 0);
1455 if (!NILP (offsets
))
1457 CHECK_CONS (offsets
, 0);
1458 CHECK_NUMBER (XCONS (offsets
)->car
, 0);
1459 CHECK_NUMBER (XCONS (offsets
)->cdr
, 0);
1460 hscroll
= XINT (XCONS (offsets
)->car
);
1461 tab_offset
= XINT (XCONS (offsets
)->cdr
);
1464 hscroll
= tab_offset
= 0;
1467 window
= Fselected_window ();
1469 CHECK_LIVE_WINDOW (window
, 0);
1471 pos
= compute_motion (XINT (from
), XINT (XCONS (frompos
)->cdr
),
1472 XINT (XCONS (frompos
)->car
), 0,
1473 XINT (to
), XINT (XCONS (topos
)->cdr
),
1474 XINT (XCONS (topos
)->car
),
1475 XINT (width
), hscroll
, tab_offset
,
1478 XSETFASTINT (bufpos
, pos
->bufpos
);
1479 XSETINT (hpos
, pos
->hpos
);
1480 XSETINT (vpos
, pos
->vpos
);
1481 XSETINT (prevhpos
, pos
->prevhpos
);
1483 return Fcons (bufpos
,
1487 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
1491 /* Return the column of position POS in window W's buffer.
1492 The result is rounded down to a multiple of the internal width of W.
1493 This is the amount of indentation of position POS
1494 that is not visible in its horizontal position in the window. */
1497 pos_tab_offset (w
, pos
)
1503 int width
= window_internal_width (w
) - 1;
1506 return MINI_WINDOW_P (w
) ? -minibuf_prompt_width
: 0;
1507 if (FETCH_BYTE (pos
- 1) == '\n')
1510 col
= current_column ();
1511 TEMP_SET_PT (opoint
);
1512 /* Modulo is no longer valid, as a line may get shorter than WIDTH
1513 columns by continuation of a wide-column character. Just return
1516 /* In the continuation of the first line in a minibuffer we must
1517 take the width of the prompt into account. */
1518 if (MINI_WINDOW_P (w
) && col
>= width
- minibuf_prompt_width
1519 && find_next_newline_no_quit (pos
, -1) == BEGV
)
1520 return col
- (col
+ minibuf_prompt_width
) % width
;
1521 return col
- (col
% width
);
1527 /* Fvertical_motion and vmotion */
1528 struct position val_vmotion
;
1531 vmotion (from
, vtarget
, w
)
1532 register int from
, vtarget
;
1535 int width
= window_internal_width (w
) - 1;
1536 int hscroll
= XINT (w
->hscroll
);
1537 struct position pos
;
1538 /* vpos is cumulative vertical position, changed as from is changed */
1539 register int vpos
= 0;
1540 Lisp_Object prevline
;
1542 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1544 = (INTEGERP (current_buffer
->selective_display
)
1545 ? XINT (current_buffer
->selective_display
)
1546 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1551 XSETWINDOW (window
, w
);
1553 /* The omission of the clause
1554 && marker_position (w->start) == BEG
1555 here is deliberate; I think we want to measure from the prompt
1556 position even if the minibuffer window has scrolled. */
1557 if (EQ (window
, minibuf_window
))
1559 if (minibuf_prompt_width
== 0 && STRINGP (minibuf_prompt
))
1560 minibuf_prompt_width
1561 = string_display_width (minibuf_prompt
, Qnil
, Qnil
);
1563 start_hpos
= minibuf_prompt_width
;
1566 if (vpos
>= vtarget
)
1568 /* To move upward, go a line at a time until
1569 we have gone at least far enough */
1573 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1575 Lisp_Object propval
;
1577 XSETFASTINT (prevline
, find_next_newline_no_quit (from
- 1, -1));
1578 while (XFASTINT (prevline
) > BEGV
1580 && indented_beyond_p (XFASTINT (prevline
), selective
))
1581 #ifdef USE_TEXT_PROPERTIES
1582 /* watch out for newlines with `invisible' property */
1583 || (propval
= Fget_char_property (prevline
,
1586 TEXT_PROP_MEANS_INVISIBLE (propval
))
1589 XSETFASTINT (prevline
,
1590 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1592 pos
= *compute_motion (XFASTINT (prevline
), 0,
1593 lmargin
+ (XFASTINT (prevline
) == BEG
1597 /* Don't care for VPOS... */
1598 1 << (BITS_PER_SHORT
- 1),
1600 1 << (BITS_PER_SHORT
- 1),
1602 /* This compensates for start_hpos
1603 so that a tab as first character
1604 still occupies 8 columns. */
1605 (XFASTINT (prevline
) == BEG
1610 from
= XFASTINT (prevline
);
1613 /* If we made exactly the desired vertical distance,
1614 or if we hit beginning of buffer,
1615 return point found */
1616 if (vpos
>= vtarget
)
1618 val_vmotion
.bufpos
= from
;
1619 val_vmotion
.vpos
= vpos
;
1620 val_vmotion
.hpos
= lmargin
;
1621 val_vmotion
.contin
= 0;
1622 val_vmotion
.prevhpos
= 0;
1623 val_vmotion
.ovstring_chars_done
= 0;
1624 val_vmotion
.tab_offset
= 0; /* For accumulating tab offset. */
1625 return &val_vmotion
;
1628 /* Otherwise find the correct spot by moving down */
1630 /* Moving downward is simple, but must calculate from beg of line
1631 to determine hpos of starting point */
1632 if (from
> BEGV
&& FETCH_BYTE (from
- 1) != '\n')
1634 Lisp_Object propval
;
1636 XSETFASTINT (prevline
, find_next_newline_no_quit (from
, -1));
1637 while (XFASTINT (prevline
) > BEGV
1639 && indented_beyond_p (XFASTINT (prevline
), selective
))
1640 #ifdef USE_TEXT_PROPERTIES
1641 /* watch out for newlines with `invisible' property */
1642 || (propval
= Fget_char_property (prevline
, Qinvisible
,
1644 TEXT_PROP_MEANS_INVISIBLE (propval
))
1647 XSETFASTINT (prevline
,
1648 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1650 pos
= *compute_motion (XFASTINT (prevline
), 0,
1651 lmargin
+ (XFASTINT (prevline
) == BEG
1655 /* Don't care for VPOS... */
1656 1 << (BITS_PER_SHORT
- 1),
1658 1 << (BITS_PER_SHORT
- 1),
1660 (XFASTINT (prevline
) == BEG
? -start_hpos
: 0),
1666 pos
.hpos
= lmargin
+ (from
== BEG
? start_hpos
: 0);
1671 return compute_motion (from
, vpos
, pos
.hpos
, did_motion
,
1672 ZV
, vtarget
, - (1 << (BITS_PER_SHORT
- 1)),
1674 pos
.tab_offset
- (from
== BEG
? start_hpos
: 0),
1678 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
1679 "Move point to start of the screen line LINES lines down.\n\
1680 If LINES is negative, this means moving up.\n\
1682 This function is an ordinary cursor motion function\n\
1683 which calculates the new position based on how text would be displayed.\n\
1684 The new position may be the start of a line,\n\
1685 or just the start of a continuation line.\n\
1686 The function returns number of screen lines moved over;\n\
1687 that usually equals LINES, but may be closer to zero\n\
1688 if beginning or end of buffer was reached.\n\
1690 The optional second argument WINDOW specifies the window to use for\n\
1691 parameters such as width, horizontal scrolling, and so on.\n\
1692 The default is to use the selected window's parameters.\n\
1694 `vertical-motion' always uses the current buffer,\n\
1695 regardless of which buffer is displayed in WINDOW.\n\
1696 This is consistent with other cursor motion functions\n\
1697 and makes it possible to use `vertical-motion' in any buffer,\n\
1698 whether or not it is currently displayed in some window.")
1700 Lisp_Object lines
, window
;
1702 struct position pos
;
1704 CHECK_NUMBER (lines
, 0);
1705 if (! NILP (window
))
1706 CHECK_WINDOW (window
, 0);
1708 window
= selected_window
;
1710 pos
= *vmotion (PT
, (int) XINT (lines
), XWINDOW (window
));
1712 SET_PT (pos
.bufpos
);
1713 return make_number (pos
.vpos
);
1716 /* file's initialization. */
1720 DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode
,
1721 "*Indentation can insert tabs if this is non-nil.\n\
1722 Setting this variable automatically makes it local to the current buffer.");
1723 indent_tabs_mode
= 1;
1725 defsubr (&Scurrent_indentation
);
1726 defsubr (&Sindent_to
);
1727 defsubr (&Scurrent_column
);
1728 defsubr (&Smove_to_column
);
1729 defsubr (&Svertical_motion
);
1730 defsubr (&Scompute_motion
);