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
, end
, overlay_limit
, proplimit
;
214 XSETFASTINT (position
, pos
);
215 XSETBUFFER (buffer
, current_buffer
);
217 /* Give faster response for overlay lookup near POS. */
218 recenter_overlay_lists (current_buffer
, pos
);
220 /* We must not advance farther than the next overlay change.
221 The overlay change might change the invisible property;
222 or there might be overlay strings to be displayed there. */
223 overlay_limit
= Fnext_overlay_change (position
);
224 /* As for text properties, this gives a lower bound
225 for where the invisible text property could change. */
226 proplimit
= Fnext_property_change (position
, buffer
, Qt
);
227 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
228 proplimit
= overlay_limit
;
229 /* PROPLIMIT is now a lower bound for the next change
230 in invisible status. If that is plenty far away,
231 use that lower bound. */
232 if (XFASTINT (proplimit
) > pos
+ 100 || XFASTINT (proplimit
) >= to
)
233 *next_boundary_p
= XFASTINT (proplimit
);
234 /* Otherwise, scan for the next `invisible' property change. */
237 /* Don't scan terribly far. */
238 XSETFASTINT (proplimit
, min (pos
+ 100, to
));
239 /* No matter what. don't go past next overlay change. */
240 if (XFASTINT (overlay_limit
) < XFASTINT (proplimit
))
241 proplimit
= overlay_limit
;
242 end
= Fnext_single_property_change (position
, Qinvisible
,
244 /* Don't put the boundary in the middle of multibyte form if
245 there is no actual property change. */
247 && !NILP (current_buffer
->enable_multibyte_characters
)
249 while (pos
< end
&& !CHAR_HEAD_P (POS_ADDR (end
)))
251 *next_boundary_p
= XFASTINT (end
);
253 /* if the `invisible' property is set, we can skip to
254 the next property change */
255 if (!NILP (window
) && EQ (XWINDOW (window
)->buffer
, buffer
))
256 prop
= Fget_char_property (position
, Qinvisible
, window
);
258 prop
= Fget_char_property (position
, Qinvisible
, buffer
);
259 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
260 return *next_boundary_p
;
264 DEFUN ("current-column", Fcurrent_column
, Scurrent_column
, 0, 0, 0,
265 "Return the horizontal position of point. Beginning of line is column 0.\n\
266 This is calculated by adding together the widths of all the displayed\n\
267 representations of the character between the start of the previous line\n\
268 and point. (eg control characters will have a width of 2 or 4, tabs\n\
269 will have a variable width)\n\
270 Ignores finite width of frame, which means that this function may return\n\
271 values greater than (frame-width).\n\
272 Whether the line is visible (if `selective-display' is t) has no effect;\n\
273 however, ^M is treated as end of line when `selective-display' is t.")
277 XSETFASTINT (temp
, current_column ());
281 /* Cancel any recorded value of the horizontal position. */
283 invalidate_current_column ()
285 last_known_column_point
= 0;
292 register unsigned char *ptr
, *stop
;
293 register int tab_seen
;
296 register int tab_width
= XINT (current_buffer
->tab_width
);
297 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
298 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
301 if (PT
== last_known_column_point
302 && MODIFF
== last_known_column_modified
)
303 return last_known_column
;
305 /* If the buffer has overlays, text properties, or multibyte,
306 use a more general algorithm. */
307 if (BUF_INTERVALS (current_buffer
)
308 || !NILP (current_buffer
->overlays_before
)
309 || !NILP (current_buffer
->overlays_after
)
310 || !NILP (current_buffer
->enable_multibyte_characters
))
311 return current_column_1 (PT
);
313 /* Scan backwards from point to the previous newline,
314 counting width. Tab characters are the only complicated case. */
316 /* Make a pointer for decrementing through the chars before point. */
317 ptr
= POS_ADDR (PT
- 1) + 1;
318 /* Make a pointer to where consecutive chars leave off,
319 going backwards from point. */
322 else if (PT
<= GPT
|| BEGV
> GPT
)
327 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
329 col
= 0, tab_seen
= 0, post_tab
= 0;
335 /* We stopped either for the beginning of the buffer
337 if (ptr
== BEGV_ADDR
)
339 /* It was the gap. Jump back over it. */
342 /* Check whether that brings us to beginning of buffer. */
343 if (BEGV
>= GPT
) break;
347 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
348 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
349 else if (c
>= 040 && c
< 0177)
353 else if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
358 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
365 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
370 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
374 if (ptr
== BEGV_ADDR
)
375 current_column_bol_cache
= BEGV
;
377 current_column_bol_cache
= PTR_CHAR_POS ((ptr
+1));
378 last_known_column
= col
;
379 last_known_column_point
= PT
;
380 last_known_column_modified
= MODIFF
;
385 /* Return the column number of position POS
386 by scanning forward from the beginning of the line.
387 This function handles characters that are invisible
388 due to text properties or overlays. */
391 current_column_1 (pos
)
394 register int tab_width
= XINT (current_buffer
->tab_width
);
395 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
396 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
398 /* Start the scan at the beginning of this line with column number 0. */
399 register int col
= 0;
400 int scan
= current_column_bol_cache
= find_next_newline (pos
, -1);
401 int next_boundary
= scan
;
402 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
404 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
406 /* Scan forward to the target position. */
411 /* Occasionally we may need to skip invisible text. */
412 while (scan
== next_boundary
)
414 /* This updates NEXT_BOUNDARY to the next place
415 where we might need to skip more invisible text. */
416 scan
= skip_invisible (scan
, &next_boundary
, pos
, Qnil
);
421 c
= FETCH_BYTE (scan
);
422 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
424 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
430 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
437 col
= col
/ tab_width
* tab_width
;
439 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
442 /* Start of multi-byte form. */
443 if (c
== LEADING_CODE_COMPOSITION
)
445 unsigned char *ptr
= POS_ADDR (scan
);
447 int cmpchar_id
= str_cmpchar_id (ptr
, next_boundary
- scan
);
450 scan
+= cmpchar_table
[cmpchar_id
]->len
,
451 col
+= cmpchar_table
[cmpchar_id
]->width
;
454 { /* invalid composite character */
461 /* Here, we check that the following bytes are valid
462 constituents of multi-byte form. */
463 int len
= BYTES_BY_CHAR_HEAD (c
), i
;
465 for (i
= 1, scan
++; i
< len
; i
++, scan
++)
466 /* We don't need range checking for PTR because there
467 are anchors (`\0') at GAP and Z. */
468 if (CHAR_HEAD_P (POS_ADDR (scan
))) break;
470 col
+= 4, scan
-= i
- 1;
472 col
+= WIDTH_BY_CHAR_HEAD (c
);
475 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
477 else if (c
< 040 || c
>= 0177)
484 last_known_column
= col
;
485 last_known_column_point
= PT
;
486 last_known_column_modified
= MODIFF
;
491 /* Return the width in columns of the part of STRING from BEG to END.
492 If BEG is nil, that stands for the beginning of STRING.
493 If END is nil, that stands for the end of STRING. */
496 string_display_width (string
, beg
, end
)
497 Lisp_Object string
, beg
, end
;
500 register unsigned char *ptr
, *stop
;
501 register int tab_seen
;
504 register int tab_width
= XINT (current_buffer
->tab_width
);
505 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
506 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
510 e
= XSTRING (string
)->size
;
513 CHECK_NUMBER (end
, 0);
521 CHECK_NUMBER (beg
, 0);
525 /* Make a pointer for decrementing through the chars before point. */
526 ptr
= XSTRING (string
)->data
+ e
;
527 /* Make a pointer to where consecutive chars leave off,
528 going backwards from point. */
529 stop
= XSTRING (string
)->data
+ b
;
531 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
533 col
= 0, tab_seen
= 0, post_tab
= 0;
541 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
542 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
543 else if (c
>= 040 && c
< 0177)
550 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
557 col
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
562 col
= ((col
+ tab_width
) / tab_width
) * tab_width
;
569 DEFUN ("indent-to", Findent_to
, Sindent_to
, 1, 2, "NIndent to column: ",
570 "Indent from point with tabs and spaces until COLUMN is reached.\n\
571 Optional second argument MININUM says always do at least MININUM spaces\n\
572 even if that goes past COLUMN; by default, MININUM is zero.")
574 Lisp_Object column
, minimum
;
577 register int fromcol
;
578 register int tab_width
= XINT (current_buffer
->tab_width
);
580 CHECK_NUMBER (column
, 0);
582 XSETFASTINT (minimum
, 0);
583 CHECK_NUMBER (minimum
, 1);
585 fromcol
= current_column ();
586 mincol
= fromcol
+ XINT (minimum
);
587 if (mincol
< XINT (column
)) mincol
= XINT (column
);
589 if (fromcol
== mincol
)
590 return make_number (mincol
);
592 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
594 if (indent_tabs_mode
)
597 XSETFASTINT (n
, mincol
/ tab_width
- fromcol
/ tab_width
);
598 if (XFASTINT (n
) != 0)
600 Finsert_char (make_number ('\t'), n
, Qt
);
602 fromcol
= (mincol
/ tab_width
) * tab_width
;
606 XSETFASTINT (column
, mincol
- fromcol
);
607 Finsert_char (make_number (' '), column
, Qt
);
609 last_known_column
= mincol
;
610 last_known_column_point
= PT
;
611 last_known_column_modified
= MODIFF
;
613 XSETINT (column
, mincol
);
618 DEFUN ("current-indentation", Fcurrent_indentation
, Scurrent_indentation
,
620 "Return the indentation of the current line.\n\
621 This is the horizontal position of the character\n\
622 following any initial whitespace.")
627 XSETFASTINT (val
, position_indentation (find_next_newline (PT
, -1)));
631 position_indentation (pos
)
634 register int column
= 0;
635 register int tab_width
= XINT (current_buffer
->tab_width
);
636 register unsigned char *p
;
637 register unsigned char *stop
;
638 unsigned char *start
;
639 int next_boundary
= pos
;
642 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
645 /* STOP records the value of P at which we will need
646 to think about the gap, or about invisible text,
647 or about the end of the buffer. */
649 /* START records the starting value of P. */
657 /* If we have updated P, set POS to match.
658 The first time we enter the loop, POS is already right. */
660 pos
= PTR_CHAR_POS (p
);
661 /* Consider the various reasons STOP might have been set here. */
664 if (pos
== next_boundary
)
665 pos
= skip_invisible (pos
, &next_boundary
, ZV
, Qnil
);
667 ceiling
= BUFFER_CEILING_OF (pos
) + 1;
668 /* Compute the next place we need to stop and think,
669 and set STOP accordingly. */
670 stop_pos
= min (ceiling
, next_boundary
);
671 /* The -1 and +1 arrange to point at the first byte of gap
672 (if STOP_POS is the position of the gap)
673 rather than at the data after the gap. */
675 stop
= POS_ADDR (stop_pos
- 1) + 1;
684 column
+= tab_width
- column
% tab_width
;
692 /* Test whether the line beginning at POS is indented beyond COLUMN.
693 Blank lines are treated as if they had the same indentation as the
696 indented_beyond_p (pos
, column
)
699 while (pos
> BEGV
&& FETCH_BYTE (pos
) == '\n')
700 pos
= find_next_newline_no_quit (pos
- 1, -1);
701 return (position_indentation (pos
) >= column
);
704 DEFUN ("move-to-column", Fmove_to_column
, Smove_to_column
, 1, 2, "p",
705 "Move point to column COLUMN in the current line.\n\
706 The column of a character is calculated by adding together the widths\n\
707 as displayed of the previous characters in the line.\n\
708 This function ignores line-continuation;\n\
709 there is no upper limit on the column number a character can have\n\
710 and horizontal scrolling has no effect.\n\
712 If specified column is within a character, point goes after that character.\n\
713 If it's past end of line, point goes to end of line.\n\n\
714 A non-nil second (optional) argument FORCE means, if the line\n\
715 is too short to reach column COLUMN then add spaces/tabs to get there,\n\
716 and if COLUMN is in the middle of a tab character, change it to spaces.\n\
718 The return value is the current column.")
720 Lisp_Object column
, force
;
723 register int col
= current_column ();
726 register int tab_width
= XINT (current_buffer
->tab_width
);
727 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
728 register struct Lisp_Char_Table
*dp
= buffer_display_table ();
729 register int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
737 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
738 CHECK_NATNUM (column
, 0);
739 goal
= XINT (column
);
745 /* If we're starting past the desired column,
746 back up to beginning of line and scan from there. */
750 pos
= current_column_bol_cache
;
756 while (pos
== next_boundary
)
758 pos
= skip_invisible (pos
, &next_boundary
, end
, Qnil
);
763 /* Test reaching the goal column. We do this after skipping
764 invisible characters, so that we put point before the
765 character on which the cursor will appear. */
769 c
= FETCH_BYTE (pos
);
770 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
772 col
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
778 if (c
== '\r' && EQ (current_buffer
->selective_display
, Qt
))
785 col
= col
/ tab_width
* tab_width
;
787 else if (ctl_arrow
&& (c
< 040 || c
== 0177))
789 else if (c
< 040 || c
== 0177)
793 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
795 /* Start of multi-byte form. */
798 pos
--; /* rewind to the character head */
799 ptr
= POS_ADDR (pos
);
800 if (c
== LEADING_CODE_COMPOSITION
)
802 int cmpchar_id
= str_cmpchar_id (ptr
, end
- pos
);
806 col
+= cmpchar_table
[cmpchar_id
]->width
;
807 pos
+= cmpchar_table
[cmpchar_id
]->len
;
810 { /* invalid composite character */
817 /* Here, we check that the following bytes are valid
818 constituents of multi-byte form. */
819 int len
= BYTES_BY_CHAR_HEAD (c
), i
;
821 for (i
= 1, ptr
++; i
< len
; i
++, ptr
++)
822 /* We don't need range checking for PTR because there
823 are anchors (`\0') both at GPT and Z. */
824 if (CHAR_HEAD_P (ptr
)) break;
828 col
+= WIDTH_BY_CHAR_HEAD (c
), pos
+= i
;
838 /* If a tab char made us overshoot, change it to spaces
839 and scan through it again. */
840 if (!NILP (force
) && col
> goal
&& c
== '\t' && prev_col
< goal
)
844 del_range (PT
- 1, PT
);
845 Findent_to (make_number (goal
), Qnil
);
847 Findent_to (make_number (col
), Qnil
);
849 /* Set the last_known... vars consistently. */
853 /* If line ends prematurely, add space to the end. */
854 if (col
< goal
&& !NILP (force
))
855 Findent_to (make_number (col
= goal
), Qnil
);
857 last_known_column
= col
;
858 last_known_column_point
= PT
;
859 last_known_column_modified
= MODIFF
;
861 XSETFASTINT (val
, col
);
865 /* compute_motion: compute buffer posn given screen posn and vice versa */
867 struct position val_compute_motion
;
869 /* Scan the current buffer forward from offset FROM, pretending that
870 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
871 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
872 and return the ending buffer position and screen location. If we
873 can't hit the requested column exactly (because of a tab or other
874 multi-column character), overshoot.
876 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
877 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
878 earlier call to compute_motion. The other common case is that FROMHPOS
879 is zero and FROM is a position that "belongs" at column zero, but might
880 be shifted by overlay strings; in this case DID_MOTION should be 0.
882 WIDTH is the number of columns available to display text;
883 compute_motion uses this to handle continuation lines and such.
884 HSCROLL is the number of columns not being displayed at the left
885 margin; this is usually taken from a window's hscroll member.
886 TAB_OFFSET is the number of columns of the first tab that aren't
887 being displayed, perhaps because of a continuation line or
890 compute_motion returns a pointer to a struct position. The bufpos
891 member gives the buffer position at the end of the scan, and hpos
892 and vpos give its cartesian location. prevhpos is the column at
893 which the character before bufpos started, and contin is non-zero
894 if we reached the current line by continuing the previous.
896 Note that FROMHPOS and TOHPOS should be expressed in real screen
897 columns, taking HSCROLL and the truncation glyph at the left margin
898 into account. That is, beginning-of-line moves you to the hpos
899 -HSCROLL + (HSCROLL > 0).
901 For example, to find the buffer position of column COL of line LINE
902 of a certain window, pass the window's starting location as FROM
903 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
904 Pass the buffer's ZV as TO, to limit the scan to the end of the
905 visible section of the buffer, and pass LINE and COL as TOVPOS and
908 When displaying in window w, a typical formula for WIDTH is:
911 - (has_vertical_scroll_bars
912 ? FRAME_SCROLL_BAR_COLS (XFRAME (window->frame))
913 : (window_width + window_left != frame_width))
916 window_width is XFASTINT (w->width),
917 window_left is XFASTINT (w->left),
918 has_vertical_scroll_bars is
919 FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (WINDOW_FRAME (window)))
920 and frame_width = FRAME_WIDTH (XFRAME (window->frame))
922 Or you can let window_internal_width do this all for you, and write:
923 window_internal_width (w) - 1
925 The `-1' accounts for the continuation-line backslashes; the rest
926 accounts for window borders if the window is split horizontally, and
927 the scroll bars if they are turned on. */
930 compute_motion (from
, fromvpos
, fromhpos
, did_motion
, to
, tovpos
, tohpos
, width
, hscroll
, tab_offset
, win
)
931 int from
, fromvpos
, fromhpos
, to
, tovpos
, tohpos
;
934 int hscroll
, tab_offset
;
937 register int hpos
= fromhpos
;
938 register int vpos
= fromvpos
;
942 register int tab_width
= XFASTINT (current_buffer
->tab_width
);
943 register int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
944 register struct Lisp_Char_Table
*dp
= window_display_table (win
);
946 = (INTEGERP (current_buffer
->selective_display
)
947 ? XINT (current_buffer
->selective_display
)
948 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
951 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
952 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
: 0);
953 /* The next location where the `invisible' property changes, or an
954 overlay starts or ends. */
955 int next_boundary
= from
;
957 /* For computing runs of characters with similar widths.
958 Invariant: width_run_width is zero, or all the characters
959 from width_run_start to width_run_end have a fixed width of
961 int width_run_start
= from
;
962 int width_run_end
= from
;
963 int width_run_width
= 0;
964 Lisp_Object
*width_table
;
967 /* The next buffer pos where we should consult the width run cache. */
968 int next_width_run
= from
;
971 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
972 int wide_column
= 0; /* Set to 1 when a previous character
974 int prev_pos
; /* Previous buffer position. */
975 int contin_hpos
; /* HPOS of last column of continued line. */
976 int prev_tab_offset
; /* Previous tab offset. */
978 XSETBUFFER (buffer
, current_buffer
);
979 XSETWINDOW (window
, win
);
981 width_run_cache_on_off ();
982 if (dp
== buffer_display_table ())
983 width_table
= (VECTORP (current_buffer
->width_table
)
984 ? XVECTOR (current_buffer
->width_table
)->contents
987 /* If the window has its own display table, we can't use the width
988 run cache, because that's based on the buffer's display table. */
991 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
993 pos
= prev_pos
= from
;
995 prev_tab_offset
= tab_offset
;
998 while (pos
== next_boundary
)
1002 /* If the caller says that the screen position came from an earlier
1003 call to compute_motion, then we've already accounted for the
1004 overlay strings at point. This is only true the first time
1005 through, so clear the flag after testing it. */
1007 /* We need to skip past the overlay strings. Currently those
1008 strings must not contain TAB;
1009 if we want to relax that restriction, something will have
1010 to be changed here. */
1012 unsigned char *ovstr
;
1013 int ovlen
= overlay_strings (pos
, win
, &ovstr
);
1014 hpos
+= (multibyte
? strwidth (ovstr
, ovlen
) : ovlen
);
1021 /* Advance POS past invisible characters
1022 (but not necessarily all that there are here),
1023 and store in next_boundary the next position where
1024 we need to call skip_invisible. */
1025 newpos
= skip_invisible (pos
, &next_boundary
, to
, window
);
1033 /* Handle right margin. */
1034 /* Note on a wide-column character.
1036 Characters are classified into the following three categories
1037 according to the width (columns occupied on screen).
1039 (1) single-column character: ex. `a'
1040 (2) multi-column character: ex. `^A', TAB, `\033'
1041 (3) wide-column character: ex. Japanese character, Chinese character
1042 (In the following example, `W_' stands for them.)
1044 Multi-column characters can be divided around the right margin,
1045 but wide-column characters cannot.
1049 (*) The cursor is placed on the next character after the point.
1053 j ^---- next after the point
1054 ^--- next char. after the point.
1056 In case of sigle-column character
1060 033 ^---- next after the point, next char. after the point.
1062 In case of multi-column character
1066 W_ ^---- next after the point
1067 ^---- next char. after the point.
1069 In case of wide-column character
1071 The problem here is continuation at a wide-column character.
1072 In this case, the line may shorter less than WIDTH.
1073 And we find the continuation AFTER it occurs.
1080 || (truncate_partial_width_windows
1081 && width
+ 1 < FRAME_WIDTH (XFRAME (WINDOW_FRAME (win
))))
1082 || !NILP (current_buffer
->truncate_lines
))
1084 /* Truncating: skip to newline. */
1085 if (pos
<= to
) /* This IF is needed because we may past TO */
1086 pos
= find_before_next_newline (pos
, to
, 1);
1088 /* If we just skipped next_boundary,
1089 loop around in the main while
1091 if (pos
>= next_boundary
)
1092 next_boundary
= pos
+ 1;
1094 prev_tab_offset
= tab_offset
;
1099 /* Remember the previous value. */
1100 prev_tab_offset
= tab_offset
;
1105 tab_offset
+= prev_hpos
;
1109 tab_offset
+= width
;
1113 contin_hpos
= prev_hpos
;
1118 /* Stop if past the target buffer position or screen position. */
1121 /* Go back to the previous position. */
1124 tab_offset
= prev_tab_offset
;
1126 /* NOTE on contin_hpos, hpos, and prev_hpos.
1130 W_ ^---- contin_hpos
1136 if (contin_hpos
&& prev_hpos
== 0
1137 && contin_hpos
< width
&& !wide_column
)
1139 /* Line breaking occurs in the middle of multi-column
1140 character. Go back to previous line. */
1145 /* If previous character is NEWLINE,
1146 set VPOS back to previous line */
1151 if (vpos
> tovpos
|| vpos
== tovpos
&& hpos
>= tohpos
)
1153 if (contin_hpos
&& prev_hpos
== 0
1154 && (contin_hpos
== width
|| wide_column
))
1155 { /* Line breaks because we can't put the character at the
1156 previous line any more. It is not the multi-column
1157 character continued in middle. Go back to previous
1158 buffer position, screen position, and set tab offset
1159 to previous value. It's the beginning of the
1163 tab_offset
= prev_tab_offset
;
1167 if (pos
== ZV
) /* We cannot go beyond ZV. Stop here. */
1174 /* Consult the width run cache to see if we can avoid inspecting
1175 the text character-by-character. */
1176 if (current_buffer
->width_run_cache
&& pos
>= next_width_run
)
1180 = region_cache_forward (current_buffer
,
1181 current_buffer
->width_run_cache
,
1184 /* A width of zero means the character's width varies (like
1185 a tab), is meaningless (like a newline), or we just don't
1186 want to skip over it for some other reason. */
1187 if (common_width
!= 0)
1191 /* Don't go past the final buffer posn the user
1196 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1198 /* Don't go past the final horizontal position the user
1200 if (vpos
== tovpos
&& run_end_hpos
> tohpos
)
1202 run_end
= pos
+ (tohpos
- hpos
) / common_width
;
1203 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1206 /* Don't go past the margin. */
1207 if (run_end_hpos
>= width
)
1209 run_end
= pos
+ (width
- hpos
) / common_width
;
1210 run_end_hpos
= hpos
+ (run_end
- pos
) * common_width
;
1213 hpos
= run_end_hpos
;
1215 prev_hpos
= hpos
- common_width
;
1219 next_width_run
= run_end
+ 1;
1222 /* We have to scan the text character-by-character. */
1225 c
= FETCH_BYTE (pos
);
1228 /* Perhaps add some info to the width_run_cache. */
1229 if (current_buffer
->width_run_cache
)
1231 /* Is this character part of the current run? If so, extend
1233 if (pos
- 1 == width_run_end
1234 && width_table
[c
] == width_run_width
)
1235 width_run_end
= pos
;
1237 /* The previous run is over, since this is a character at a
1238 different position, or a different width. */
1241 /* Have we accumulated a run to put in the cache?
1242 (Currently, we only cache runs of width == 1). */
1243 if (width_run_start
< width_run_end
1244 && width_run_width
== 1)
1245 know_region_cache (current_buffer
,
1246 current_buffer
->width_run_cache
,
1247 width_run_start
, width_run_end
);
1249 /* Start recording a new width run. */
1250 width_run_width
= width_table
[c
];
1251 width_run_start
= pos
- 1;
1252 width_run_end
= pos
;
1256 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
1257 hpos
+= XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
;
1258 else if (c
>= 040 && c
< 0177)
1262 int tem
= (hpos
+ tab_offset
+ hscroll
- (hscroll
> 0)) % tab_width
;
1265 hpos
+= tab_width
- tem
;
1269 if (selective
> 0 && indented_beyond_p (pos
, selective
))
1271 /* If (pos == to), we don't have to take care of
1272 selective display. */
1275 /* Skip any number of invisible lines all at once */
1277 pos
= find_before_next_newline (pos
, to
, 1) + 1;
1279 && indented_beyond_p (pos
, selective
));
1280 /* Allow for the " ..." that is displayed for them. */
1283 hpos
+= selective_rlen
;
1288 /* We have skipped the invis text, but not the
1294 /* A visible line. */
1298 /* Count the truncation glyph on column 0 */
1305 else if (c
== CR
&& selective
< 0)
1307 /* In selective display mode,
1308 everything from a ^M to the end of the line is invisible.
1309 Stop *before* the real newline. */
1311 pos
= find_before_next_newline (pos
, to
, 1);
1312 /* If we just skipped next_boundary,
1313 loop around in the main while
1315 if (pos
> next_boundary
)
1316 next_boundary
= pos
;
1317 /* Allow for the " ..." that is displayed for them. */
1320 hpos
+= selective_rlen
;
1325 else if (multibyte
&& BASE_LEADING_CODE_P (c
))
1327 /* Start of multi-byte form. */
1330 pos
--; /* rewind POS */
1331 ptr
= POS_ADDR (pos
);
1333 if (c
== LEADING_CODE_COMPOSITION
)
1335 int cmpchar_id
= str_cmpchar_id (ptr
, next_boundary
- pos
);
1337 if (cmpchar_id
>= 0)
1339 if (cmpchar_table
[cmpchar_id
]->width
>= 2)
1341 hpos
+= cmpchar_table
[cmpchar_id
]->width
;
1342 pos
+= cmpchar_table
[cmpchar_id
]->len
;
1345 { /* invalid composite character */
1352 /* Here, we check that the following bytes are valid
1353 constituents of multi-byte form. */
1354 int len
= BYTES_BY_CHAR_HEAD (c
), i
;
1356 for (i
= 1, ptr
++; i
< len
; i
++, ptr
++)
1357 /* We don't need range checking for PTR because
1358 there are anchors ('\0') both at GPT and Z. */
1359 if (CHAR_HEAD_P (ptr
)) break;
1363 hpos
+= WIDTH_BY_CHAR_HEAD (c
), pos
+= i
, wide_column
= 1;
1367 hpos
+= (ctl_arrow
&& c
< 0200) ? 2 : 4;
1373 /* Remember any final width run in the cache. */
1374 if (current_buffer
->width_run_cache
1375 && width_run_width
== 1
1376 && width_run_start
< width_run_end
)
1377 know_region_cache (current_buffer
, current_buffer
->width_run_cache
,
1378 width_run_start
, width_run_end
);
1380 val_compute_motion
.bufpos
= pos
;
1381 val_compute_motion
.hpos
= hpos
;
1382 val_compute_motion
.vpos
= vpos
;
1383 val_compute_motion
.prevhpos
= prev_hpos
;
1384 /* We alalways handle all of them here; none of them remain to do. */
1385 val_compute_motion
.ovstring_chars_done
= 0;
1387 /* Nonzero if have just continued a line */
1388 val_compute_motion
.contin
= (contin_hpos
&& prev_hpos
== 0);
1390 return &val_compute_motion
;
1393 #if 0 /* The doc string is too long for some compilers,
1394 but make-docfile can find it in this comment. */
1395 DEFUN ("compute-motion", Ffoo
, Sfoo
, 7, 7, 0,
1396 "Scan through the current buffer, calculating screen position.\n\
1397 Scan the current buffer forward from offset FROM,\n\
1398 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--\n\
1399 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--\n\
1400 and return the ending buffer position and screen location.\n\
1402 There are three additional arguments:\n\
1404 WIDTH is the number of columns available to display text;\n\
1405 this affects handling of continuation lines.\n\
1406 This is usually the value returned by `window-width', less one (to allow\n\
1407 for the continuation glyph).\n\
1409 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).\n\
1410 HSCROLL is the number of columns not being displayed at the left\n\
1411 margin; this is usually taken from a window's hscroll member.\n\
1412 TAB-OFFSET is the number of columns of the first tab that aren't\n\
1413 being displayed, perhaps because the line was continued within it.\n\
1414 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.\n\
1416 WINDOW is the window to operate on. It is used to choose the display table;\n\
1417 if it is showing the current buffer, it is used also for\n\
1418 deciding which overlay properties apply.\n\
1419 Note that `compute-motion' always operates on the current buffer.\n\
1421 The value is a list of five elements:\n\
1422 (POS HPOS VPOS PREVHPOS CONTIN)\n\
1423 POS is the buffer position where the scan stopped.\n\
1424 VPOS is the vertical position where the scan stopped.\n\
1425 HPOS is the horizontal position where the scan stopped.\n\
1427 PREVHPOS is the horizontal position one character back from POS.\n\
1428 CONTIN is t if a line was continued after (or within) the previous character.\n\
1430 For example, to find the buffer position of column COL of line LINE\n\
1431 of a certain window, pass the window's starting location as FROM\n\
1432 and the window's upper-left coordinates as FROMPOS.\n\
1433 Pass the buffer's (point-max) as TO, to limit the scan to the end of the\n\
1434 visible section of the buffer, and pass LINE and COL as TOPOS.")
1435 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1438 DEFUN ("compute-motion", Fcompute_motion
, Scompute_motion
, 7, 7, 0,
1440 (from
, frompos
, to
, topos
, width
, offsets
, window
)
1441 Lisp_Object from
, frompos
, to
, topos
;
1442 Lisp_Object width
, offsets
, window
;
1444 Lisp_Object bufpos
, hpos
, vpos
, prevhpos
, contin
;
1445 struct position
*pos
;
1446 int hscroll
, tab_offset
;
1448 CHECK_NUMBER_COERCE_MARKER (from
, 0);
1449 CHECK_CONS (frompos
, 0);
1450 CHECK_NUMBER (XCONS (frompos
)->car
, 0);
1451 CHECK_NUMBER (XCONS (frompos
)->cdr
, 0);
1452 CHECK_NUMBER_COERCE_MARKER (to
, 0);
1453 CHECK_CONS (topos
, 0);
1454 CHECK_NUMBER (XCONS (topos
)->car
, 0);
1455 CHECK_NUMBER (XCONS (topos
)->cdr
, 0);
1456 CHECK_NUMBER (width
, 0);
1457 if (!NILP (offsets
))
1459 CHECK_CONS (offsets
, 0);
1460 CHECK_NUMBER (XCONS (offsets
)->car
, 0);
1461 CHECK_NUMBER (XCONS (offsets
)->cdr
, 0);
1462 hscroll
= XINT (XCONS (offsets
)->car
);
1463 tab_offset
= XINT (XCONS (offsets
)->cdr
);
1466 hscroll
= tab_offset
= 0;
1469 window
= Fselected_window ();
1471 CHECK_LIVE_WINDOW (window
, 0);
1473 pos
= compute_motion (XINT (from
), XINT (XCONS (frompos
)->cdr
),
1474 XINT (XCONS (frompos
)->car
), 0,
1475 XINT (to
), XINT (XCONS (topos
)->cdr
),
1476 XINT (XCONS (topos
)->car
),
1477 XINT (width
), hscroll
, tab_offset
,
1480 XSETFASTINT (bufpos
, pos
->bufpos
);
1481 XSETINT (hpos
, pos
->hpos
);
1482 XSETINT (vpos
, pos
->vpos
);
1483 XSETINT (prevhpos
, pos
->prevhpos
);
1485 return Fcons (bufpos
,
1489 Fcons (pos
->contin
? Qt
: Qnil
, Qnil
)))));
1493 /* Return the column of position POS in window W's buffer.
1494 The result is rounded down to a multiple of the internal width of W.
1495 This is the amount of indentation of position POS
1496 that is not visible in its horizontal position in the window. */
1499 pos_tab_offset (w
, pos
)
1505 int width
= window_internal_width (w
) - 1;
1508 return MINI_WINDOW_P (w
) ? -minibuf_prompt_width
: 0;
1509 if (FETCH_BYTE (pos
- 1) == '\n')
1512 col
= current_column ();
1513 TEMP_SET_PT (opoint
);
1514 /* Modulo is no longer valid, as a line may get shorter than WIDTH
1515 columns by continuation of a wide-column character. Just return
1518 /* In the continuation of the first line in a minibuffer we must
1519 take the width of the prompt into account. */
1520 if (MINI_WINDOW_P (w
) && col
>= width
- minibuf_prompt_width
1521 && find_next_newline_no_quit (pos
, -1) == BEGV
)
1522 return col
- (col
+ minibuf_prompt_width
) % width
;
1523 return col
- (col
% width
);
1529 /* Fvertical_motion and vmotion */
1530 struct position val_vmotion
;
1533 vmotion (from
, vtarget
, w
)
1534 register int from
, vtarget
;
1537 int width
= window_internal_width (w
) - 1;
1538 int hscroll
= XINT (w
->hscroll
);
1539 struct position pos
;
1540 /* vpos is cumulative vertical position, changed as from is changed */
1541 register int vpos
= 0;
1542 Lisp_Object prevline
;
1544 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1546 = (INTEGERP (current_buffer
->selective_display
)
1547 ? XINT (current_buffer
->selective_display
)
1548 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1553 XSETWINDOW (window
, w
);
1555 /* The omission of the clause
1556 && marker_position (w->start) == BEG
1557 here is deliberate; I think we want to measure from the prompt
1558 position even if the minibuffer window has scrolled. */
1559 if (EQ (window
, minibuf_window
))
1561 if (minibuf_prompt_width
== 0 && STRINGP (minibuf_prompt
))
1562 minibuf_prompt_width
1563 = string_display_width (minibuf_prompt
, Qnil
, Qnil
);
1565 start_hpos
= minibuf_prompt_width
;
1568 if (vpos
>= vtarget
)
1570 /* To move upward, go a line at a time until
1571 we have gone at least far enough */
1575 while ((vpos
> vtarget
|| first
) && from
> BEGV
)
1577 Lisp_Object propval
;
1579 XSETFASTINT (prevline
, find_next_newline_no_quit (from
- 1, -1));
1580 while (XFASTINT (prevline
) > BEGV
1582 && indented_beyond_p (XFASTINT (prevline
), selective
))
1583 #ifdef USE_TEXT_PROPERTIES
1584 /* watch out for newlines with `invisible' property */
1585 || (propval
= Fget_char_property (prevline
,
1588 TEXT_PROP_MEANS_INVISIBLE (propval
))
1591 XSETFASTINT (prevline
,
1592 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1594 pos
= *compute_motion (XFASTINT (prevline
), 0,
1595 lmargin
+ (XFASTINT (prevline
) == BEG
1599 /* Don't care for VPOS... */
1600 1 << (BITS_PER_SHORT
- 1),
1602 1 << (BITS_PER_SHORT
- 1),
1604 /* This compensates for start_hpos
1605 so that a tab as first character
1606 still occupies 8 columns. */
1607 (XFASTINT (prevline
) == BEG
1612 from
= XFASTINT (prevline
);
1615 /* If we made exactly the desired vertical distance,
1616 or if we hit beginning of buffer,
1617 return point found */
1618 if (vpos
>= vtarget
)
1620 val_vmotion
.bufpos
= from
;
1621 val_vmotion
.vpos
= vpos
;
1622 val_vmotion
.hpos
= lmargin
;
1623 val_vmotion
.contin
= 0;
1624 val_vmotion
.prevhpos
= 0;
1625 val_vmotion
.ovstring_chars_done
= 0;
1626 val_vmotion
.tab_offset
= 0; /* For accumulating tab offset. */
1627 return &val_vmotion
;
1630 /* Otherwise find the correct spot by moving down */
1632 /* Moving downward is simple, but must calculate from beg of line
1633 to determine hpos of starting point */
1634 if (from
> BEGV
&& FETCH_BYTE (from
- 1) != '\n')
1636 Lisp_Object propval
;
1638 XSETFASTINT (prevline
, find_next_newline_no_quit (from
, -1));
1639 while (XFASTINT (prevline
) > BEGV
1641 && indented_beyond_p (XFASTINT (prevline
), selective
))
1642 #ifdef USE_TEXT_PROPERTIES
1643 /* watch out for newlines with `invisible' property */
1644 || (propval
= Fget_char_property (prevline
, Qinvisible
,
1646 TEXT_PROP_MEANS_INVISIBLE (propval
))
1649 XSETFASTINT (prevline
,
1650 find_next_newline_no_quit (XFASTINT (prevline
) - 1,
1652 pos
= *compute_motion (XFASTINT (prevline
), 0,
1653 lmargin
+ (XFASTINT (prevline
) == BEG
1657 /* Don't care for VPOS... */
1658 1 << (BITS_PER_SHORT
- 1),
1660 1 << (BITS_PER_SHORT
- 1),
1662 (XFASTINT (prevline
) == BEG
? -start_hpos
: 0),
1668 pos
.hpos
= lmargin
+ (from
== BEG
? start_hpos
: 0);
1673 return compute_motion (from
, vpos
, pos
.hpos
, did_motion
,
1674 ZV
, vtarget
, - (1 << (BITS_PER_SHORT
- 1)),
1676 pos
.tab_offset
- (from
== BEG
? start_hpos
: 0),
1680 DEFUN ("vertical-motion", Fvertical_motion
, Svertical_motion
, 1, 2, 0,
1681 "Move point to start of the screen line LINES lines down.\n\
1682 If LINES is negative, this means moving up.\n\
1684 This function is an ordinary cursor motion function\n\
1685 which calculates the new position based on how text would be displayed.\n\
1686 The new position may be the start of a line,\n\
1687 or just the start of a continuation line.\n\
1688 The function returns number of screen lines moved over;\n\
1689 that usually equals LINES, but may be closer to zero\n\
1690 if beginning or end of buffer was reached.\n\
1692 The optional second argument WINDOW specifies the window to use for\n\
1693 parameters such as width, horizontal scrolling, and so on.\n\
1694 The default is to use the selected window's parameters.\n\
1696 `vertical-motion' always uses the current buffer,\n\
1697 regardless of which buffer is displayed in WINDOW.\n\
1698 This is consistent with other cursor motion functions\n\
1699 and makes it possible to use `vertical-motion' in any buffer,\n\
1700 whether or not it is currently displayed in some window.")
1702 Lisp_Object lines
, window
;
1704 struct position pos
;
1706 CHECK_NUMBER (lines
, 0);
1707 if (! NILP (window
))
1708 CHECK_WINDOW (window
, 0);
1710 window
= selected_window
;
1712 pos
= *vmotion (PT
, (int) XINT (lines
), XWINDOW (window
));
1714 SET_PT (pos
.bufpos
);
1715 return make_number (pos
.vpos
);
1718 /* file's initialization. */
1722 DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode
,
1723 "*Indentation can insert tabs if this is non-nil.\n\
1724 Setting this variable automatically makes it local to the current buffer.");
1725 indent_tabs_mode
= 1;
1727 defsubr (&Scurrent_indentation
);
1728 defsubr (&Sindent_to
);
1729 defsubr (&Scurrent_column
);
1730 defsubr (&Smove_to_column
);
1731 defsubr (&Svertical_motion
);
1732 defsubr (&Scompute_motion
);