* lisp/obsolete/spell.el: Fix header comment.
[emacs.git] / src / indent.c
blobb40cb9f50b691bc4db3ed3ea475156c284ee2f75
1 /* Indentation functions.
2 Copyright (C) 1985-1988, 1993-1995, 1998, 2000-2011
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 #include <config.h>
21 #include <stdio.h>
22 #include <setjmp.h>
24 #include "lisp.h"
25 #include "buffer.h"
26 #include "character.h"
27 #include "category.h"
28 #include "composite.h"
29 #include "indent.h"
30 #include "keyboard.h"
31 #include "frame.h"
32 #include "window.h"
33 #include "termchar.h"
34 #include "termopts.h"
35 #include "disptab.h"
36 #include "intervals.h"
37 #include "dispextern.h"
38 #include "region-cache.h"
40 #define CR 015
42 /* These three values memorize the current column to avoid recalculation. */
44 /* Last value returned by current_column.
45 Some things in set last_known_column_point to -1
46 to mark the memorized value as invalid. */
48 static double last_known_column;
50 /* Value of point when current_column was called. */
52 EMACS_INT last_known_column_point;
54 /* Value of MODIFF when current_column was called. */
56 static int last_known_column_modified;
58 static double current_column_1 (void);
59 static double position_indentation (int);
61 /* Cache of beginning of line found by the last call of
62 current_column. */
64 static EMACS_INT current_column_bol_cache;
66 /* Get the display table to use for the current buffer. */
68 struct Lisp_Char_Table *
69 buffer_display_table (void)
71 Lisp_Object thisbuf;
73 thisbuf = current_buffer->display_table;
74 if (DISP_TABLE_P (thisbuf))
75 return XCHAR_TABLE (thisbuf);
76 if (DISP_TABLE_P (Vstandard_display_table))
77 return XCHAR_TABLE (Vstandard_display_table);
78 return 0;
81 /* Width run cache considerations. */
83 /* Return the width of character C under display table DP. */
85 static int
86 character_width (int c, struct Lisp_Char_Table *dp)
88 Lisp_Object elt;
90 /* These width computations were determined by examining the cases
91 in display_text_line. */
93 /* Everything can be handled by the display table, if it's
94 present and the element is right. */
95 if (dp && (elt = DISP_CHAR_VECTOR (dp, c), VECTORP (elt)))
96 return XVECTOR (elt)->size;
98 /* Some characters are special. */
99 if (c == '\n' || c == '\t' || c == '\015')
100 return 0;
102 /* Printing characters have width 1. */
103 else if (c >= 040 && c < 0177)
104 return 1;
106 /* Everybody else (control characters, metacharacters) has other
107 widths. We could return their actual widths here, but they
108 depend on things like ctl_arrow and crud like that, and they're
109 not very common at all. So we'll just claim we don't know their
110 widths. */
111 else
112 return 0;
115 /* Return true if the display table DISPTAB specifies the same widths
116 for characters as WIDTHTAB. We use this to decide when to
117 invalidate the buffer's width_run_cache. */
120 disptab_matches_widthtab (struct Lisp_Char_Table *disptab, struct Lisp_Vector *widthtab)
122 int i;
124 if (widthtab->size != 256)
125 abort ();
127 for (i = 0; i < 256; i++)
128 if (character_width (i, disptab)
129 != XFASTINT (widthtab->contents[i]))
130 return 0;
132 return 1;
135 /* Recompute BUF's width table, using the display table DISPTAB. */
137 void
138 recompute_width_table (struct buffer *buf, struct Lisp_Char_Table *disptab)
140 int i;
141 struct Lisp_Vector *widthtab;
143 if (!VECTORP (buf->width_table))
144 buf->width_table = Fmake_vector (make_number (256), make_number (0));
145 widthtab = XVECTOR (buf->width_table);
146 if (widthtab->size != 256)
147 abort ();
149 for (i = 0; i < 256; i++)
150 XSETFASTINT (widthtab->contents[i], character_width (i, disptab));
153 /* Allocate or free the width run cache, as requested by the current
154 state of current_buffer's cache_long_line_scans variable. */
156 static void
157 width_run_cache_on_off (void)
159 if (NILP (current_buffer->cache_long_line_scans)
160 /* And, for the moment, this feature doesn't work on multibyte
161 characters. */
162 || !NILP (current_buffer->enable_multibyte_characters))
164 /* It should be off. */
165 if (current_buffer->width_run_cache)
167 free_region_cache (current_buffer->width_run_cache);
168 current_buffer->width_run_cache = 0;
169 current_buffer->width_table = Qnil;
172 else
174 /* It should be on. */
175 if (current_buffer->width_run_cache == 0)
177 current_buffer->width_run_cache = new_region_cache ();
178 recompute_width_table (current_buffer, buffer_display_table ());
184 /* Skip some invisible characters starting from POS.
185 This includes characters invisible because of text properties
186 and characters invisible because of overlays.
188 If position POS is followed by invisible characters,
189 skip some of them and return the position after them.
190 Otherwise return POS itself.
192 Set *NEXT_BOUNDARY_P to the next position at which
193 it will be necessary to call this function again.
195 Don't scan past TO, and don't set *NEXT_BOUNDARY_P
196 to a value greater than TO.
198 If WINDOW is non-nil, and this buffer is displayed in WINDOW,
199 take account of overlays that apply only in WINDOW.
201 We don't necessarily skip all the invisible characters after POS
202 because that could take a long time. We skip a reasonable number
203 which can be skipped quickly. If there might be more invisible
204 characters immediately following, then *NEXT_BOUNDARY_P
205 will equal the return value. */
207 EMACS_INT
208 skip_invisible (EMACS_INT pos, EMACS_INT *next_boundary_p, EMACS_INT to, Lisp_Object window)
210 Lisp_Object prop, position, overlay_limit, proplimit;
211 Lisp_Object buffer, tmp;
212 EMACS_INT end;
213 int inv_p;
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. */
236 else
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 tmp = Fnext_single_property_change (position, Qinvisible,
244 buffer, proplimit);
245 end = XFASTINT (tmp);
246 #if 0
247 /* Don't put the boundary in the middle of multibyte form if
248 there is no actual property change. */
249 if (end == pos + 100
250 && !NILP (current_buffer->enable_multibyte_characters)
251 && end < ZV)
252 while (pos < end && !CHAR_HEAD_P (POS_ADDR (end)))
253 end--;
254 #endif
255 *next_boundary_p = end;
257 /* if the `invisible' property is set, we can skip to
258 the next property change */
259 prop = Fget_char_property (position, Qinvisible,
260 (!NILP (window)
261 && EQ (XWINDOW (window)->buffer, buffer))
262 ? window : buffer);
263 inv_p = TEXT_PROP_MEANS_INVISIBLE (prop);
264 /* When counting columns (window == nil), don't skip over ellipsis text. */
265 if (NILP (window) ? inv_p == 1 : inv_p)
266 return *next_boundary_p;
267 return pos;
270 /* Set variables WIDTH and BYTES for a multibyte sequence starting at P.
272 DP is a display table or NULL.
274 This macro is used in current_column_1, Fmove_to_column, and
275 compute_motion. */
277 #define MULTIBYTE_BYTES_WIDTH(p, dp) \
278 do { \
279 int c; \
281 wide_column = 0; \
282 c = STRING_CHAR_AND_LENGTH (p, bytes); \
283 if (BYTES_BY_CHAR_HEAD (*p) != bytes) \
284 width = bytes * 4; \
285 else \
287 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c))) \
288 width = XVECTOR (DISP_CHAR_VECTOR (dp, c))->size; \
289 else \
290 width = CHAR_WIDTH (c); \
291 if (width > 1) \
292 wide_column = width; \
294 } while (0)
297 DEFUN ("current-column", Fcurrent_column, Scurrent_column, 0, 0, 0,
298 doc: /* Return the horizontal position of point. Beginning of line is column 0.
299 This is calculated by adding together the widths of all the displayed
300 representations of the character between the start of the previous line
301 and point (eg. control characters will have a width of 2 or 4, tabs
302 will have a variable width).
303 Ignores finite width of frame, which means that this function may return
304 values greater than (frame-width).
305 Whether the line is visible (if `selective-display' is t) has no effect;
306 however, ^M is treated as end of line when `selective-display' is t.
307 Text that has an invisible property is considered as having width 0, unless
308 `buffer-invisibility-spec' specifies that it is replaced by an ellipsis. */)
309 (void)
311 Lisp_Object temp;
312 XSETFASTINT (temp, (int) current_column ()); /* iftc */
313 return temp;
316 /* Cancel any recorded value of the horizontal position. */
318 void
319 invalidate_current_column (void)
321 last_known_column_point = 0;
324 double
325 current_column (void)
327 register int col;
328 register unsigned char *ptr, *stop;
329 register int tab_seen;
330 int post_tab;
331 register int c;
332 register int tab_width = XINT (current_buffer->tab_width);
333 int ctl_arrow = !NILP (current_buffer->ctl_arrow);
334 register struct Lisp_Char_Table *dp = buffer_display_table ();
336 if (PT == last_known_column_point
337 && MODIFF == last_known_column_modified)
338 return last_known_column;
340 /* If the buffer has overlays, text properties,
341 or multibyte characters, use a more general algorithm. */
342 if (BUF_INTERVALS (current_buffer)
343 || current_buffer->overlays_before
344 || current_buffer->overlays_after
345 || Z != Z_BYTE)
346 return current_column_1 ();
348 /* Scan backwards from point to the previous newline,
349 counting width. Tab characters are the only complicated case. */
351 /* Make a pointer for decrementing through the chars before point. */
352 ptr = BYTE_POS_ADDR (PT_BYTE - 1) + 1;
353 /* Make a pointer to where consecutive chars leave off,
354 going backwards from point. */
355 if (PT == BEGV)
356 stop = ptr;
357 else if (PT <= GPT || BEGV > GPT)
358 stop = BEGV_ADDR;
359 else
360 stop = GAP_END_ADDR;
362 if (tab_width <= 0 || tab_width > 1000)
363 tab_width = 8;
365 col = 0, tab_seen = 0, post_tab = 0;
367 while (1)
369 EMACS_INT i, n;
370 Lisp_Object charvec;
372 if (ptr == stop)
374 /* We stopped either for the beginning of the buffer
375 or for the gap. */
376 if (ptr == BEGV_ADDR)
377 break;
379 /* It was the gap. Jump back over it. */
380 stop = BEGV_ADDR;
381 ptr = GPT_ADDR;
383 /* Check whether that brings us to beginning of buffer. */
384 if (BEGV >= GPT)
385 break;
388 c = *--ptr;
390 if (dp && VECTORP (DISP_CHAR_VECTOR (dp, c)))
392 charvec = DISP_CHAR_VECTOR (dp, c);
393 n = ASIZE (charvec);
395 else
397 charvec = Qnil;
398 n = 1;
401 for (i = n - 1; i >= 0; --i)
403 if (VECTORP (charvec))
405 /* This should be handled the same as
406 next_element_from_display_vector does it. */
407 Lisp_Object entry = AREF (charvec, i);
409 if (GLYPH_CODE_P (entry)
410 && GLYPH_CODE_CHAR_VALID_P (entry))
411 c = GLYPH_CODE_CHAR (entry);
412 else
413 c = ' ';
416 if (c >= 040 && c < 0177)
417 col++;
418 else if (c == '\n'
419 || (c == '\r'
420 && EQ (current_buffer->selective_display, Qt)))
422 ptr++;
423 goto start_of_line_found;
425 else if (c == '\t')
427 if (tab_seen)
428 col = ((col + tab_width) / tab_width) * tab_width;
430 post_tab += col;
431 col = 0;
432 tab_seen = 1;
434 else if (VECTORP (charvec))
435 /* With a display table entry, C is displayed as is, and
436 not displayed as \NNN or as ^N. If C is a single-byte
437 character, it takes one column. If C is multi-byte in
438 an unibyte buffer, it's translated to unibyte, so it
439 also takes one column. */
440 ++col;
441 else
442 col += (ctl_arrow && c < 0200) ? 2 : 4;
446 start_of_line_found:
448 if (tab_seen)
450 col = ((col + tab_width) / tab_width) * tab_width;
451 col += post_tab;
454 if (ptr == BEGV_ADDR)
455 current_column_bol_cache = BEGV;
456 else
457 current_column_bol_cache = BYTE_TO_CHAR (PTR_BYTE_POS (ptr));
459 last_known_column = col;
460 last_known_column_point = PT;
461 last_known_column_modified = MODIFF;
463 return col;
467 /* Check the presence of a display property and compute its width.
468 If a property was found and its width was found as well, return
469 its width (>= 0) and set the position of the end of the property
470 in ENDPOS.
471 Otherwise just return -1. */
472 static int
473 check_display_width (EMACS_INT pos, EMACS_INT col, EMACS_INT *endpos)
475 Lisp_Object val, overlay;
477 if (CONSP (val = get_char_property_and_overlay
478 (make_number (pos), Qdisplay, Qnil, &overlay))
479 && EQ (Qspace, XCAR (val)))
480 { /* FIXME: Use calc_pixel_width_or_height, as in term.c. */
481 Lisp_Object plist = XCDR (val), prop;
482 int width = -1;
484 if ((prop = Fplist_get (plist, QCwidth), NATNUMP (prop)))
485 width = XINT (prop);
486 else if (FLOATP (prop))
487 width = (int)(XFLOAT_DATA (prop) + 0.5);
488 else if ((prop = Fplist_get (plist, QCalign_to), NATNUMP (prop)))
489 width = XINT (prop) - col;
490 else if (FLOATP (prop))
491 width = (int)(XFLOAT_DATA (prop) + 0.5) - col;
493 if (width >= 0)
495 EMACS_INT start;
496 if (OVERLAYP (overlay))
497 *endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
498 else
499 get_property_and_range (pos, Qdisplay, &val, &start, endpos, Qnil);
500 return width;
503 return -1;
506 /* Scanning from the beginning of the current line, stop at the buffer
507 position ENDPOS or at the column GOALCOL or at the end of line, whichever
508 comes first.
509 Return the resulting buffer position and column in ENDPOS and GOALCOL.
510 PREVCOL gets set to the column of the previous position (it's always
511 strictly smaller than the goal column). */
512 static void
513 scan_for_column (EMACS_INT *endpos, EMACS_INT *goalcol, EMACS_INT *prevcol)
515 register EMACS_INT tab_width = XINT (current_buffer->tab_width);
516 register int ctl_arrow = !NILP (current_buffer->ctl_arrow);
517 register struct Lisp_Char_Table *dp = buffer_display_table ();
518 int multibyte = !NILP (current_buffer->enable_multibyte_characters);
519 struct composition_it cmp_it;
520 Lisp_Object window;
521 struct window *w;
523 /* Start the scan at the beginning of this line with column number 0. */
524 register EMACS_INT col = 0, prev_col = 0;
525 EMACS_INT goal = goalcol ? *goalcol : MOST_POSITIVE_FIXNUM;
526 EMACS_INT end = endpos ? *endpos : PT;
527 EMACS_INT scan, scan_byte;
528 EMACS_INT next_boundary;
530 EMACS_INT opoint = PT, opoint_byte = PT_BYTE;
531 scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -1, 1);
532 current_column_bol_cache = PT;
533 scan = PT, scan_byte = PT_BYTE;
534 SET_PT_BOTH (opoint, opoint_byte);
535 next_boundary = scan;
538 window = Fget_buffer_window (Fcurrent_buffer (), Qnil);
539 w = ! NILP (window) ? XWINDOW (window) : NULL;
541 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
542 memset (&cmp_it, 0, sizeof cmp_it);
543 cmp_it.id = -1;
544 composition_compute_stop_pos (&cmp_it, scan, scan_byte, end, Qnil);
546 /* Scan forward to the target position. */
547 while (scan < end)
549 int c;
551 /* Occasionally we may need to skip invisible text. */
552 while (scan == next_boundary)
554 EMACS_INT old_scan = scan;
555 /* This updates NEXT_BOUNDARY to the next place
556 where we might need to skip more invisible text. */
557 scan = skip_invisible (scan, &next_boundary, end, Qnil);
558 if (scan != old_scan)
559 scan_byte = CHAR_TO_BYTE (scan);
560 if (scan >= end)
561 goto endloop;
564 /* Test reaching the goal column. We do this after skipping
565 invisible characters, so that we put point before the
566 character on which the cursor will appear. */
567 if (col >= goal)
568 break;
569 prev_col = col;
571 { /* Check display property. */
572 EMACS_INT end;
573 int width = check_display_width (scan, col, &end);
574 if (width >= 0)
576 col += width;
577 if (end > scan) /* Avoid infinite loops with 0-width overlays. */
579 scan = end; scan_byte = charpos_to_bytepos (scan);
580 continue;
585 /* Check composition sequence. */
586 if (cmp_it.id >= 0
587 || (scan == cmp_it.stop_pos
588 && composition_reseat_it (&cmp_it, scan, scan_byte, end,
589 w, NULL, Qnil)))
590 composition_update_it (&cmp_it, scan, scan_byte, Qnil);
591 if (cmp_it.id >= 0)
593 scan += cmp_it.nchars;
594 scan_byte += cmp_it.nbytes;
595 if (scan <= end)
596 col += cmp_it.width;
597 if (cmp_it.to == cmp_it.nglyphs)
599 cmp_it.id = -1;
600 composition_compute_stop_pos (&cmp_it, scan, scan_byte, end,
601 Qnil);
603 else
604 cmp_it.from = cmp_it.to;
605 continue;
608 c = FETCH_BYTE (scan_byte);
610 /* See if there is a display table and it relates
611 to this character. */
613 if (dp != 0
614 && ! (multibyte && LEADING_CODE_P (c))
615 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
617 Lisp_Object charvec;
618 EMACS_INT i, n;
620 /* This character is displayed using a vector of glyphs.
621 Update the column/position based on those glyphs. */
623 charvec = DISP_CHAR_VECTOR (dp, c);
624 n = ASIZE (charvec);
626 for (i = 0; i < n; i++)
628 /* This should be handled the same as
629 next_element_from_display_vector does it. */
630 Lisp_Object entry = AREF (charvec, i);
632 if (GLYPH_CODE_P (entry)
633 && GLYPH_CODE_CHAR_VALID_P (entry))
634 c = GLYPH_CODE_CHAR (entry);
635 else
636 c = ' ';
638 if (c == '\n')
639 goto endloop;
640 if (c == '\r' && EQ (current_buffer->selective_display, Qt))
641 goto endloop;
642 if (c == '\t')
644 col += tab_width;
645 col = col / tab_width * tab_width;
647 else
648 ++col;
651 else
653 /* The display table doesn't affect this character;
654 it displays as itself. */
656 if (c == '\n')
657 goto endloop;
658 if (c == '\r' && EQ (current_buffer->selective_display, Qt))
659 goto endloop;
660 if (c == '\t')
662 col += tab_width;
663 col = col / tab_width * tab_width;
665 else if (multibyte && LEADING_CODE_P (c))
667 /* Start of multi-byte form. */
668 unsigned char *ptr;
669 int bytes, width, wide_column;
671 ptr = BYTE_POS_ADDR (scan_byte);
672 MULTIBYTE_BYTES_WIDTH (ptr, dp);
673 /* Subtract one to compensate for the increment
674 that is going to happen below. */
675 scan_byte += bytes - 1;
676 col += width;
678 else if (ctl_arrow && (c < 040 || c == 0177))
679 col += 2;
680 else if (c < 040 || c >= 0177)
681 col += 4;
682 else
683 col++;
685 scan++;
686 scan_byte++;
689 endloop:
691 last_known_column = col;
692 last_known_column_point = PT;
693 last_known_column_modified = MODIFF;
695 if (goalcol)
696 *goalcol = col;
697 if (endpos)
698 *endpos = scan;
699 if (prevcol)
700 *prevcol = prev_col;
703 /* Return the column number of position POS
704 by scanning forward from the beginning of the line.
705 This function handles characters that are invisible
706 due to text properties or overlays. */
708 static double
709 current_column_1 (void)
711 EMACS_INT col = MOST_POSITIVE_FIXNUM;
712 EMACS_INT opoint = PT;
714 scan_for_column (&opoint, &col, NULL);
715 return col;
719 #if 0 /* Not used. */
721 /* Return the width in columns of the part of STRING from BEG to END.
722 If BEG is nil, that stands for the beginning of STRING.
723 If END is nil, that stands for the end of STRING. */
725 static double
726 string_display_width (string, beg, end)
727 Lisp_Object string, beg, end;
729 register int col;
730 register unsigned char *ptr, *stop;
731 register int tab_seen;
732 int post_tab;
733 register int c;
734 register int tab_width = XINT (current_buffer->tab_width);
735 int ctl_arrow = !NILP (current_buffer->ctl_arrow);
736 register struct Lisp_Char_Table *dp = buffer_display_table ();
737 int b, e;
739 if (NILP (end))
740 e = SCHARS (string);
741 else
743 CHECK_NUMBER (end);
744 e = XINT (end);
747 if (NILP (beg))
748 b = 0;
749 else
751 CHECK_NUMBER (beg);
752 b = XINT (beg);
755 /* Make a pointer for decrementing through the chars before point. */
756 ptr = SDATA (string) + e;
757 /* Make a pointer to where consecutive chars leave off,
758 going backwards from point. */
759 stop = SDATA (string) + b;
761 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
763 col = 0, tab_seen = 0, post_tab = 0;
765 while (1)
767 if (ptr == stop)
768 break;
770 c = *--ptr;
771 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
772 col += XVECTOR (DISP_CHAR_VECTOR (dp, c))->size;
773 else if (c >= 040 && c < 0177)
774 col++;
775 else if (c == '\n')
776 break;
777 else if (c == '\t')
779 if (tab_seen)
780 col = ((col + tab_width) / tab_width) * tab_width;
782 post_tab += col;
783 col = 0;
784 tab_seen = 1;
786 else
787 col += (ctl_arrow && c < 0200) ? 2 : 4;
790 if (tab_seen)
792 col = ((col + tab_width) / tab_width) * tab_width;
793 col += post_tab;
796 return col;
799 #endif /* 0 */
802 DEFUN ("indent-to", Findent_to, Sindent_to, 1, 2, "NIndent to column: ",
803 doc: /* Indent from point with tabs and spaces until COLUMN is reached.
804 Optional second argument MINIMUM says always do at least MINIMUM spaces
805 even if that goes past COLUMN; by default, MINIMUM is zero.
807 The return value is COLUMN. */)
808 (Lisp_Object column, Lisp_Object minimum)
810 int mincol;
811 register int fromcol;
812 register int tab_width = XINT (current_buffer->tab_width);
814 CHECK_NUMBER (column);
815 if (NILP (minimum))
816 XSETFASTINT (minimum, 0);
817 CHECK_NUMBER (minimum);
819 fromcol = current_column ();
820 mincol = fromcol + XINT (minimum);
821 if (mincol < XINT (column)) mincol = XINT (column);
823 if (fromcol == mincol)
824 return make_number (mincol);
826 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
828 if (indent_tabs_mode)
830 Lisp_Object n;
831 XSETFASTINT (n, mincol / tab_width - fromcol / tab_width);
832 if (XFASTINT (n) != 0)
834 Finsert_char (make_number ('\t'), n, Qt);
836 fromcol = (mincol / tab_width) * tab_width;
840 XSETFASTINT (column, mincol - fromcol);
841 Finsert_char (make_number (' '), column, Qt);
843 last_known_column = mincol;
844 last_known_column_point = PT;
845 last_known_column_modified = MODIFF;
847 XSETINT (column, mincol);
848 return column;
852 static double position_indentation (int);
854 DEFUN ("current-indentation", Fcurrent_indentation, Scurrent_indentation,
855 0, 0, 0,
856 doc: /* Return the indentation of the current line.
857 This is the horizontal position of the character
858 following any initial whitespace. */)
859 (void)
861 Lisp_Object val;
862 EMACS_INT opoint = PT, opoint_byte = PT_BYTE;
864 scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -1, 1);
866 XSETFASTINT (val, (int) position_indentation (PT_BYTE)); /* iftc */
867 SET_PT_BOTH (opoint, opoint_byte);
868 return val;
871 static double
872 position_indentation (register int pos_byte)
874 register EMACS_INT column = 0;
875 register EMACS_INT tab_width = XINT (current_buffer->tab_width);
876 register unsigned char *p;
877 register unsigned char *stop;
878 unsigned char *start;
879 EMACS_INT next_boundary_byte = pos_byte;
880 EMACS_INT ceiling = next_boundary_byte;
882 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
884 p = BYTE_POS_ADDR (pos_byte);
885 /* STOP records the value of P at which we will need
886 to think about the gap, or about invisible text,
887 or about the end of the buffer. */
888 stop = p;
889 /* START records the starting value of P. */
890 start = p;
891 while (1)
893 while (p == stop)
895 EMACS_INT stop_pos_byte;
897 /* If we have updated P, set POS_BYTE to match.
898 The first time we enter the loop, POS_BYTE is already right. */
899 if (p != start)
900 pos_byte = PTR_BYTE_POS (p);
901 /* Consider the various reasons STOP might have been set here. */
902 if (pos_byte == ZV_BYTE)
903 return column;
904 if (pos_byte == next_boundary_byte)
906 EMACS_INT next_boundary;
907 EMACS_INT pos = BYTE_TO_CHAR (pos_byte);
908 pos = skip_invisible (pos, &next_boundary, ZV, Qnil);
909 pos_byte = CHAR_TO_BYTE (pos);
910 next_boundary_byte = CHAR_TO_BYTE (next_boundary);
912 if (pos_byte >= ceiling)
913 ceiling = BUFFER_CEILING_OF (pos_byte) + 1;
914 /* Compute the next place we need to stop and think,
915 and set STOP accordingly. */
916 stop_pos_byte = min (ceiling, next_boundary_byte);
917 /* The -1 and +1 arrange to point at the first byte of gap
918 (if STOP_POS_BYTE is the position of the gap)
919 rather than at the data after the gap. */
921 stop = BYTE_POS_ADDR (stop_pos_byte - 1) + 1;
922 p = BYTE_POS_ADDR (pos_byte);
924 switch (*p++)
926 case 0240:
927 if (! NILP (current_buffer->enable_multibyte_characters))
928 return column;
929 case ' ':
930 column++;
931 break;
932 case '\t':
933 column += tab_width - column % tab_width;
934 break;
935 default:
936 if (ASCII_BYTE_P (p[-1])
937 || NILP (current_buffer->enable_multibyte_characters))
938 return column;
940 int c;
941 pos_byte = PTR_BYTE_POS (p - 1);
942 c = FETCH_MULTIBYTE_CHAR (pos_byte);
943 if (CHAR_HAS_CATEGORY (c, ' '))
945 column++;
946 INC_POS (pos_byte);
947 p = BYTE_POS_ADDR (pos_byte);
949 else
950 return column;
956 /* Test whether the line beginning at POS is indented beyond COLUMN.
957 Blank lines are treated as if they had the same indentation as the
958 preceding line. */
961 indented_beyond_p (EMACS_INT pos, EMACS_INT pos_byte, double column)
963 double val;
964 EMACS_INT opoint = PT, opoint_byte = PT_BYTE;
966 SET_PT_BOTH (pos, pos_byte);
967 while (PT > BEGV && FETCH_BYTE (PT_BYTE) == '\n')
968 scan_newline (PT - 1, PT_BYTE - 1, BEGV, BEGV_BYTE, -1, 0);
970 val = position_indentation (PT_BYTE);
971 SET_PT_BOTH (opoint, opoint_byte);
972 return val >= column; /* hmm, float comparison */
975 DEFUN ("move-to-column", Fmove_to_column, Smove_to_column, 1, 2, "p",
976 doc: /* Move point to column COLUMN in the current line.
977 Interactively, COLUMN is the value of prefix numeric argument.
978 The column of a character is calculated by adding together the widths
979 as displayed of the previous characters in the line.
980 This function ignores line-continuation;
981 there is no upper limit on the column number a character can have
982 and horizontal scrolling has no effect.
984 If specified column is within a character, point goes after that character.
985 If it's past end of line, point goes to end of line.
987 Optional second argument FORCE non-nil means if COLUMN is in the
988 middle of a tab character, change it to spaces.
989 In addition, if FORCE is t, and the line is too short to reach
990 COLUMN, add spaces/tabs to get there.
992 The return value is the current column. */)
993 (Lisp_Object column, Lisp_Object force)
995 EMACS_INT pos;
996 EMACS_INT col, prev_col;
997 EMACS_INT goal;
999 CHECK_NATNUM (column);
1000 goal = XINT (column);
1002 col = goal;
1003 pos = ZV;
1004 scan_for_column (&pos, &col, &prev_col);
1006 SET_PT (pos);
1008 /* If a tab char made us overshoot, change it to spaces
1009 and scan through it again. */
1010 if (!NILP (force) && col > goal)
1012 int c;
1013 EMACS_INT pos_byte = PT_BYTE;
1015 DEC_POS (pos_byte);
1016 c = FETCH_CHAR (pos_byte);
1017 if (c == '\t' && prev_col < goal)
1019 EMACS_INT goal_pt, goal_pt_byte;
1021 /* Insert spaces in front of the tab to reach GOAL. Do this
1022 first so that a marker at the end of the tab gets
1023 adjusted. */
1024 SET_PT_BOTH (PT - 1, PT_BYTE - 1);
1025 Finsert_char (make_number (' '), make_number (goal - prev_col), Qt);
1027 /* Now delete the tab, and indent to COL. */
1028 del_range (PT, PT + 1);
1029 goal_pt = PT;
1030 goal_pt_byte = PT_BYTE;
1031 Findent_to (make_number (col), Qnil);
1032 SET_PT_BOTH (goal_pt, goal_pt_byte);
1034 /* Set the last_known... vars consistently. */
1035 col = goal;
1039 /* If line ends prematurely, add space to the end. */
1040 if (col < goal && EQ (force, Qt))
1041 Findent_to (make_number (col = goal), Qnil);
1043 last_known_column = col;
1044 last_known_column_point = PT;
1045 last_known_column_modified = MODIFF;
1047 return make_number (col);
1050 /* compute_motion: compute buffer posn given screen posn and vice versa */
1052 struct position val_compute_motion;
1054 /* Scan the current buffer forward from offset FROM, pretending that
1055 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
1056 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
1057 and return the ending buffer position and screen location. If we
1058 can't hit the requested column exactly (because of a tab or other
1059 multi-column character), overshoot.
1061 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
1062 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
1063 earlier call to compute_motion. The other common case is that FROMHPOS
1064 is zero and FROM is a position that "belongs" at column zero, but might
1065 be shifted by overlay strings; in this case DID_MOTION should be 0.
1067 WIDTH is the number of columns available to display text;
1068 compute_motion uses this to handle continuation lines and such.
1069 If WIDTH is -1, use width of window's text area adjusted for
1070 continuation glyph when needed.
1072 HSCROLL is the number of columns not being displayed at the left
1073 margin; this is usually taken from a window's hscroll member.
1074 TAB_OFFSET is the number of columns of the first tab that aren't
1075 being displayed, perhaps because of a continuation line or
1076 something.
1078 compute_motion returns a pointer to a struct position. The bufpos
1079 member gives the buffer position at the end of the scan, and hpos
1080 and vpos give its cartesian location. prevhpos is the column at
1081 which the character before bufpos started, and contin is non-zero
1082 if we reached the current line by continuing the previous.
1084 Note that FROMHPOS and TOHPOS should be expressed in real screen
1085 columns, taking HSCROLL and the truncation glyph at the left margin
1086 into account. That is, beginning-of-line moves you to the hpos
1087 -HSCROLL + (HSCROLL > 0).
1089 For example, to find the buffer position of column COL of line LINE
1090 of a certain window, pass the window's starting location as FROM
1091 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
1092 Pass the buffer's ZV as TO, to limit the scan to the end of the
1093 visible section of the buffer, and pass LINE and COL as TOVPOS and
1094 TOHPOS.
1096 When displaying in window w, a typical formula for WIDTH is:
1098 window_width - 1
1099 - (has_vertical_scroll_bars
1100 ? WINDOW_CONFIG_SCROLL_BAR_COLS (window)
1101 : (window_width + window_left != frame_cols))
1103 where
1104 window_width is XFASTINT (w->total_cols),
1105 window_left is XFASTINT (w->left_col),
1106 has_vertical_scroll_bars is
1107 WINDOW_HAS_VERTICAL_SCROLL_BAR (window)
1108 and frame_cols = FRAME_COLS (XFRAME (window->frame))
1110 Or you can let window_box_text_cols do this all for you, and write:
1111 window_box_text_cols (w) - 1
1113 The `-1' accounts for the continuation-line backslashes; the rest
1114 accounts for window borders if the window is split horizontally, and
1115 the scroll bars if they are turned on. */
1117 struct position *
1118 compute_motion (EMACS_INT from, EMACS_INT fromvpos, EMACS_INT fromhpos, int did_motion, EMACS_INT to, EMACS_INT tovpos, EMACS_INT tohpos, EMACS_INT width, EMACS_INT hscroll, EMACS_INT tab_offset, struct window *win)
1120 register EMACS_INT hpos = fromhpos;
1121 register EMACS_INT vpos = fromvpos;
1123 register EMACS_INT pos;
1124 EMACS_INT pos_byte;
1125 register int c = 0;
1126 register EMACS_INT tab_width = XFASTINT (current_buffer->tab_width);
1127 register int ctl_arrow = !NILP (current_buffer->ctl_arrow);
1128 register struct Lisp_Char_Table *dp = window_display_table (win);
1129 int selective
1130 = (INTEGERP (current_buffer->selective_display)
1131 ? XINT (current_buffer->selective_display)
1132 : !NILP (current_buffer->selective_display) ? -1 : 0);
1133 int selective_rlen
1134 = (selective && dp && VECTORP (DISP_INVIS_VECTOR (dp))
1135 ? XVECTOR (DISP_INVIS_VECTOR (dp))->size : 0);
1136 /* The next location where the `invisible' property changes, or an
1137 overlay starts or ends. */
1138 EMACS_INT next_boundary = from;
1140 /* For computing runs of characters with similar widths.
1141 Invariant: width_run_width is zero, or all the characters
1142 from width_run_start to width_run_end have a fixed width of
1143 width_run_width. */
1144 EMACS_INT width_run_start = from;
1145 EMACS_INT width_run_end = from;
1146 EMACS_INT width_run_width = 0;
1147 Lisp_Object *width_table;
1148 Lisp_Object buffer;
1150 /* The next buffer pos where we should consult the width run cache. */
1151 EMACS_INT next_width_run = from;
1152 Lisp_Object window;
1154 int multibyte = !NILP (current_buffer->enable_multibyte_characters);
1155 /* If previous char scanned was a wide character,
1156 this is the column where it ended. Otherwise, this is 0. */
1157 EMACS_INT wide_column_end_hpos = 0;
1158 EMACS_INT prev_pos; /* Previous buffer position. */
1159 EMACS_INT prev_pos_byte; /* Previous buffer position. */
1160 EMACS_INT prev_hpos = 0;
1161 EMACS_INT prev_vpos = 0;
1162 EMACS_INT contin_hpos; /* HPOS of last column of continued line. */
1163 EMACS_INT prev_tab_offset; /* Previous tab offset. */
1164 EMACS_INT continuation_glyph_width;
1166 struct composition_it cmp_it;
1168 XSETBUFFER (buffer, current_buffer);
1169 XSETWINDOW (window, win);
1171 width_run_cache_on_off ();
1172 if (dp == buffer_display_table ())
1173 width_table = (VECTORP (current_buffer->width_table)
1174 ? XVECTOR (current_buffer->width_table)->contents
1175 : 0);
1176 else
1177 /* If the window has its own display table, we can't use the width
1178 run cache, because that's based on the buffer's display table. */
1179 width_table = 0;
1181 if (tab_width <= 0 || tab_width > 1000)
1182 tab_width = 8;
1184 /* Negative width means use all available text columns. */
1185 if (width < 0)
1187 width = window_box_text_cols (win);
1188 /* We must make room for continuation marks if we don't have fringes. */
1189 #ifdef HAVE_WINDOW_SYSTEM
1190 if (!FRAME_WINDOW_P (XFRAME (win->frame)))
1191 #endif
1192 width -= 1;
1195 continuation_glyph_width = 1;
1196 #ifdef HAVE_WINDOW_SYSTEM
1197 if (FRAME_WINDOW_P (XFRAME (win->frame)))
1198 continuation_glyph_width = 0; /* In the fringe. */
1199 #endif
1201 immediate_quit = 1;
1202 QUIT;
1204 pos = prev_pos = from;
1205 pos_byte = prev_pos_byte = CHAR_TO_BYTE (from);
1206 contin_hpos = 0;
1207 prev_tab_offset = tab_offset;
1208 memset (&cmp_it, 0, sizeof cmp_it);
1209 cmp_it.id = -1;
1210 composition_compute_stop_pos (&cmp_it, pos, pos_byte, to, Qnil);
1212 while (1)
1214 while (pos == next_boundary)
1216 EMACS_INT pos_here = pos;
1217 EMACS_INT newpos;
1219 /* Don't skip invisible if we are already at the margin. */
1220 if (vpos > tovpos || (vpos == tovpos && hpos >= tohpos))
1222 if (contin_hpos && prev_hpos == 0
1223 && hpos > tohpos
1224 && (contin_hpos == width || wide_column_end_hpos > width))
1225 { /* Line breaks because we can't put the character at the
1226 previous line any more. It is not the multi-column
1227 character continued in middle. Go back to previous
1228 buffer position, screen position, and set tab offset
1229 to previous value. It's the beginning of the
1230 line. */
1231 pos = prev_pos;
1232 pos_byte = prev_pos_byte;
1233 hpos = prev_hpos;
1234 vpos = prev_vpos;
1235 tab_offset = prev_tab_offset;
1237 break;
1240 /* If the caller says that the screen position came from an earlier
1241 call to compute_motion, then we've already accounted for the
1242 overlay strings at point. This is only true the first time
1243 through, so clear the flag after testing it. */
1244 if (!did_motion)
1245 /* We need to skip past the overlay strings. Currently those
1246 strings must not contain TAB;
1247 if we want to relax that restriction, something will have
1248 to be changed here. */
1250 unsigned char *ovstr;
1251 EMACS_INT ovlen = overlay_strings (pos, win, &ovstr);
1252 hpos += ((multibyte && ovlen > 0)
1253 ? strwidth (ovstr, ovlen) : ovlen);
1255 did_motion = 0;
1257 if (pos >= to)
1258 break;
1260 /* Advance POS past invisible characters
1261 (but not necessarily all that there are here),
1262 and store in next_boundary the next position where
1263 we need to call skip_invisible. */
1264 newpos = skip_invisible (pos, &next_boundary, to, window);
1266 if (newpos >= to)
1268 pos = min (to, newpos);
1269 pos_byte = CHAR_TO_BYTE (pos);
1270 goto after_loop;
1273 if (newpos != pos_here)
1275 pos = newpos;
1276 pos_byte = CHAR_TO_BYTE (pos);
1280 /* Handle right margin. */
1281 /* Note on a wide-column character.
1283 Characters are classified into the following three categories
1284 according to the width (columns occupied on screen).
1286 (1) single-column character: ex. `a'
1287 (2) multi-column character: ex. `^A', TAB, `\033'
1288 (3) wide-column character: ex. Japanese character, Chinese character
1289 (In the following example, `W_' stands for them.)
1291 Multi-column characters can be divided around the right margin,
1292 but wide-column characters cannot.
1294 NOTE:
1296 (*) The cursor is placed on the next character after the point.
1298 ----------
1299 abcdefghi\
1300 j ^---- next after the point
1301 ^--- next char. after the point.
1302 ----------
1303 In case of sigle-column character
1305 ----------
1306 abcdefgh\\
1307 033 ^---- next after the point, next char. after the point.
1308 ----------
1309 In case of multi-column character
1311 ----------
1312 abcdefgh\\
1313 W_ ^---- next after the point
1314 ^---- next char. after the point.
1315 ----------
1316 In case of wide-column character
1318 The problem here is continuation at a wide-column character.
1319 In this case, the line may shorter less than WIDTH.
1320 And we find the continuation AFTER it occurs.
1324 if (hpos > width)
1326 int total_width = width + continuation_glyph_width;
1327 int truncate = 0;
1329 if (!NILP (Vtruncate_partial_width_windows)
1330 && (total_width < FRAME_COLS (XFRAME (WINDOW_FRAME (win)))))
1332 if (INTEGERP (Vtruncate_partial_width_windows))
1333 truncate
1334 = total_width < XFASTINT (Vtruncate_partial_width_windows);
1335 else
1336 truncate = 1;
1339 if (hscroll || truncate
1340 || !NILP (current_buffer->truncate_lines))
1342 /* Truncating: skip to newline, unless we are already past
1343 TO (we need to go back below). */
1344 if (pos <= to)
1346 pos = find_before_next_newline (pos, to, 1);
1347 pos_byte = CHAR_TO_BYTE (pos);
1348 hpos = width;
1349 /* If we just skipped next_boundary,
1350 loop around in the main while
1351 and handle it. */
1352 if (pos >= next_boundary)
1353 next_boundary = pos + 1;
1354 prev_hpos = width;
1355 prev_vpos = vpos;
1356 prev_tab_offset = tab_offset;
1359 else
1361 /* Continuing. */
1362 /* Remember the previous value. */
1363 prev_tab_offset = tab_offset;
1365 if (wide_column_end_hpos > width)
1367 hpos -= prev_hpos;
1368 tab_offset += prev_hpos;
1370 else
1372 tab_offset += width;
1373 hpos -= width;
1375 vpos++;
1376 contin_hpos = prev_hpos;
1377 prev_hpos = 0;
1378 prev_vpos = vpos;
1382 /* Stop if past the target buffer position or screen position. */
1383 if (pos > to)
1385 /* Go back to the previous position. */
1386 pos = prev_pos;
1387 pos_byte = prev_pos_byte;
1388 hpos = prev_hpos;
1389 vpos = prev_vpos;
1390 tab_offset = prev_tab_offset;
1392 /* NOTE on contin_hpos, hpos, and prev_hpos.
1394 ----------
1395 abcdefgh\\
1396 W_ ^---- contin_hpos
1397 | ^----- hpos
1398 \---- prev_hpos
1399 ----------
1402 if (contin_hpos && prev_hpos == 0
1403 && contin_hpos < width && !wide_column_end_hpos)
1405 /* Line breaking occurs in the middle of multi-column
1406 character. Go back to previous line. */
1407 hpos = contin_hpos;
1408 vpos = vpos - 1;
1410 break;
1413 if (vpos > tovpos || (vpos == tovpos && hpos >= tohpos))
1415 if (contin_hpos && prev_hpos == 0
1416 && hpos > tohpos
1417 && (contin_hpos == width || wide_column_end_hpos > width))
1418 { /* Line breaks because we can't put the character at the
1419 previous line any more. It is not the multi-column
1420 character continued in middle. Go back to previous
1421 buffer position, screen position, and set tab offset
1422 to previous value. It's the beginning of the
1423 line. */
1424 pos = prev_pos;
1425 pos_byte = prev_pos_byte;
1426 hpos = prev_hpos;
1427 vpos = prev_vpos;
1428 tab_offset = prev_tab_offset;
1430 break;
1432 if (pos == ZV) /* We cannot go beyond ZV. Stop here. */
1433 break;
1435 prev_hpos = hpos;
1436 prev_vpos = vpos;
1437 prev_pos = pos;
1438 prev_pos_byte = pos_byte;
1439 wide_column_end_hpos = 0;
1441 /* Consult the width run cache to see if we can avoid inspecting
1442 the text character-by-character. */
1443 if (current_buffer->width_run_cache && pos >= next_width_run)
1445 EMACS_INT run_end;
1446 int common_width
1447 = region_cache_forward (current_buffer,
1448 current_buffer->width_run_cache,
1449 pos, &run_end);
1451 /* A width of zero means the character's width varies (like
1452 a tab), is meaningless (like a newline), or we just don't
1453 want to skip over it for some other reason. */
1454 if (common_width != 0)
1456 EMACS_INT run_end_hpos;
1458 /* Don't go past the final buffer posn the user
1459 requested. */
1460 if (run_end > to)
1461 run_end = to;
1463 run_end_hpos = hpos + (run_end - pos) * common_width;
1465 /* Don't go past the final horizontal position the user
1466 requested. */
1467 if (vpos == tovpos && run_end_hpos > tohpos)
1469 run_end = pos + (tohpos - hpos) / common_width;
1470 run_end_hpos = hpos + (run_end - pos) * common_width;
1473 /* Don't go past the margin. */
1474 if (run_end_hpos >= width)
1476 run_end = pos + (width - hpos) / common_width;
1477 run_end_hpos = hpos + (run_end - pos) * common_width;
1480 hpos = run_end_hpos;
1481 if (run_end > pos)
1482 prev_hpos = hpos - common_width;
1483 if (pos != run_end)
1485 pos = run_end;
1486 pos_byte = CHAR_TO_BYTE (pos);
1490 next_width_run = run_end + 1;
1493 /* We have to scan the text character-by-character. */
1494 else
1496 EMACS_INT i, n;
1497 Lisp_Object charvec;
1499 /* Check composition sequence. */
1500 if (cmp_it.id >= 0
1501 || (pos == cmp_it.stop_pos
1502 && composition_reseat_it (&cmp_it, pos, pos_byte, to, win,
1503 NULL, Qnil)))
1504 composition_update_it (&cmp_it, pos, pos_byte, Qnil);
1505 if (cmp_it.id >= 0)
1507 pos += cmp_it.nchars;
1508 pos_byte += cmp_it.nbytes;
1509 hpos += cmp_it.width;
1510 if (cmp_it.to == cmp_it.nglyphs)
1512 cmp_it.id = -1;
1513 composition_compute_stop_pos (&cmp_it, pos, pos_byte, to,
1514 Qnil);
1516 else
1517 cmp_it.from = cmp_it.to;
1518 continue;
1521 c = FETCH_BYTE (pos_byte);
1522 pos++, pos_byte++;
1524 /* Perhaps add some info to the width_run_cache. */
1525 if (current_buffer->width_run_cache)
1527 /* Is this character part of the current run? If so, extend
1528 the run. */
1529 if (pos - 1 == width_run_end
1530 && XFASTINT (width_table[c]) == width_run_width)
1531 width_run_end = pos;
1533 /* The previous run is over, since this is a character at a
1534 different position, or a different width. */
1535 else
1537 /* Have we accumulated a run to put in the cache?
1538 (Currently, we only cache runs of width == 1). */
1539 if (width_run_start < width_run_end
1540 && width_run_width == 1)
1541 know_region_cache (current_buffer,
1542 current_buffer->width_run_cache,
1543 width_run_start, width_run_end);
1545 /* Start recording a new width run. */
1546 width_run_width = XFASTINT (width_table[c]);
1547 width_run_start = pos - 1;
1548 width_run_end = pos;
1552 if (dp != 0
1553 && ! (multibyte && LEADING_CODE_P (c))
1554 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
1556 charvec = DISP_CHAR_VECTOR (dp, c);
1557 n = ASIZE (charvec);
1559 else
1561 charvec = Qnil;
1562 n = 1;
1565 for (i = n - 1; i >= 0; --i)
1567 if (VECTORP (charvec))
1569 /* This should be handled the same as
1570 next_element_from_display_vector does it. */
1571 Lisp_Object entry = AREF (charvec, i);
1573 if (GLYPH_CODE_P (entry)
1574 && GLYPH_CODE_CHAR_VALID_P (entry))
1575 c = GLYPH_CODE_CHAR (entry);
1576 else
1577 c = ' ';
1580 if (c >= 040 && c < 0177)
1581 hpos++;
1582 else if (c == '\t')
1584 int tem = ((hpos + tab_offset + hscroll - (hscroll > 0))
1585 % tab_width);
1586 if (tem < 0)
1587 tem += tab_width;
1588 hpos += tab_width - tem;
1590 else if (c == '\n')
1592 if (selective > 0
1593 && indented_beyond_p (pos, pos_byte,
1594 (double) selective)) /* iftc */
1596 /* If (pos == to), we don't have to take care of
1597 selective display. */
1598 if (pos < to)
1600 /* Skip any number of invisible lines all at once */
1603 pos = find_before_next_newline (pos, to, 1);
1604 if (pos < to)
1605 pos++;
1606 pos_byte = CHAR_TO_BYTE (pos);
1608 while (pos < to
1609 && indented_beyond_p (pos, pos_byte,
1610 (double) selective)); /* iftc */
1611 /* Allow for the " ..." that is displayed for them. */
1612 if (selective_rlen)
1614 hpos += selective_rlen;
1615 if (hpos >= width)
1616 hpos = width;
1618 DEC_BOTH (pos, pos_byte);
1619 /* We have skipped the invis text, but not the
1620 newline after. */
1623 else
1625 /* A visible line. */
1626 vpos++;
1627 hpos = 0;
1628 hpos -= hscroll;
1629 /* Count the truncation glyph on column 0 */
1630 if (hscroll > 0)
1631 hpos += continuation_glyph_width;
1632 tab_offset = 0;
1634 contin_hpos = 0;
1636 else if (c == CR && selective < 0)
1638 /* In selective display mode,
1639 everything from a ^M to the end of the line is invisible.
1640 Stop *before* the real newline. */
1641 if (pos < to)
1643 pos = find_before_next_newline (pos, to, 1);
1644 pos_byte = CHAR_TO_BYTE (pos);
1646 /* If we just skipped next_boundary,
1647 loop around in the main while
1648 and handle it. */
1649 if (pos > next_boundary)
1650 next_boundary = pos;
1651 /* Allow for the " ..." that is displayed for them. */
1652 if (selective_rlen)
1654 hpos += selective_rlen;
1655 if (hpos >= width)
1656 hpos = width;
1659 else if (multibyte && LEADING_CODE_P (c))
1661 /* Start of multi-byte form. */
1662 unsigned char *ptr;
1663 int bytes, width, wide_column;
1665 pos_byte--; /* rewind POS_BYTE */
1666 ptr = BYTE_POS_ADDR (pos_byte);
1667 MULTIBYTE_BYTES_WIDTH (ptr, dp);
1668 pos_byte += bytes;
1669 if (wide_column)
1670 wide_column_end_hpos = hpos + wide_column;
1671 hpos += width;
1673 else if (VECTORP (charvec))
1674 ++hpos;
1675 else
1676 hpos += (ctl_arrow && c < 0200) ? 2 : 4;
1681 after_loop:
1683 /* Remember any final width run in the cache. */
1684 if (current_buffer->width_run_cache
1685 && width_run_width == 1
1686 && width_run_start < width_run_end)
1687 know_region_cache (current_buffer, current_buffer->width_run_cache,
1688 width_run_start, width_run_end);
1690 val_compute_motion.bufpos = pos;
1691 val_compute_motion.bytepos = pos_byte;
1692 val_compute_motion.hpos = hpos;
1693 val_compute_motion.vpos = vpos;
1694 if (contin_hpos && prev_hpos == 0)
1695 val_compute_motion.prevhpos = contin_hpos;
1696 else
1697 val_compute_motion.prevhpos = prev_hpos;
1698 /* We alalways handle all of them here; none of them remain to do. */
1699 val_compute_motion.ovstring_chars_done = 0;
1701 /* Nonzero if have just continued a line */
1702 val_compute_motion.contin = (contin_hpos && prev_hpos == 0);
1704 immediate_quit = 0;
1705 return &val_compute_motion;
1709 DEFUN ("compute-motion", Fcompute_motion, Scompute_motion, 7, 7, 0,
1710 doc: /* Scan through the current buffer, calculating screen position.
1711 Scan the current buffer forward from offset FROM,
1712 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--
1713 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--
1714 and return the ending buffer position and screen location.
1716 If TOPOS is nil, the actual width and height of the window's
1717 text area are used.
1719 There are three additional arguments:
1721 WIDTH is the number of columns available to display text;
1722 this affects handling of continuation lines. A value of nil
1723 corresponds to the actual number of available text columns.
1725 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).
1726 HSCROLL is the number of columns not being displayed at the left
1727 margin; this is usually taken from a window's hscroll member.
1728 TAB-OFFSET is the number of columns of the first tab that aren't
1729 being displayed, perhaps because the line was continued within it.
1730 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.
1732 WINDOW is the window to operate on. It is used to choose the display table;
1733 if it is showing the current buffer, it is used also for
1734 deciding which overlay properties apply.
1735 Note that `compute-motion' always operates on the current buffer.
1737 The value is a list of five elements:
1738 (POS HPOS VPOS PREVHPOS CONTIN)
1739 POS is the buffer position where the scan stopped.
1740 VPOS is the vertical position where the scan stopped.
1741 HPOS is the horizontal position where the scan stopped.
1743 PREVHPOS is the horizontal position one character back from POS.
1744 CONTIN is t if a line was continued after (or within) the previous character.
1746 For example, to find the buffer position of column COL of line LINE
1747 of a certain window, pass the window's starting location as FROM
1748 and the window's upper-left coordinates as FROMPOS.
1749 Pass the buffer's (point-max) as TO, to limit the scan to the end of the
1750 visible section of the buffer, and pass LINE and COL as TOPOS. */)
1751 (Lisp_Object from, Lisp_Object frompos, Lisp_Object to, Lisp_Object topos, Lisp_Object width, Lisp_Object offsets, Lisp_Object window)
1753 struct window *w;
1754 Lisp_Object bufpos, hpos, vpos, prevhpos;
1755 struct position *pos;
1756 int hscroll, tab_offset;
1758 CHECK_NUMBER_COERCE_MARKER (from);
1759 CHECK_CONS (frompos);
1760 CHECK_NUMBER_CAR (frompos);
1761 CHECK_NUMBER_CDR (frompos);
1762 CHECK_NUMBER_COERCE_MARKER (to);
1763 if (!NILP (topos))
1765 CHECK_CONS (topos);
1766 CHECK_NUMBER_CAR (topos);
1767 CHECK_NUMBER_CDR (topos);
1769 if (!NILP (width))
1770 CHECK_NUMBER (width);
1772 if (!NILP (offsets))
1774 CHECK_CONS (offsets);
1775 CHECK_NUMBER_CAR (offsets);
1776 CHECK_NUMBER_CDR (offsets);
1777 hscroll = XINT (XCAR (offsets));
1778 tab_offset = XINT (XCDR (offsets));
1780 else
1781 hscroll = tab_offset = 0;
1783 if (NILP (window))
1784 window = Fselected_window ();
1785 else
1786 CHECK_LIVE_WINDOW (window);
1787 w = XWINDOW (window);
1789 if (XINT (from) < BEGV || XINT (from) > ZV)
1790 args_out_of_range_3 (from, make_number (BEGV), make_number (ZV));
1791 if (XINT (to) < BEGV || XINT (to) > ZV)
1792 args_out_of_range_3 (to, make_number (BEGV), make_number (ZV));
1794 pos = compute_motion (XINT (from), XINT (XCDR (frompos)),
1795 XINT (XCAR (frompos)), 0,
1796 XINT (to),
1797 (NILP (topos)
1798 ? window_internal_height (w)
1799 : XINT (XCDR (topos))),
1800 (NILP (topos)
1801 ? (window_box_text_cols (w)
1803 #ifdef HAVE_WINDOW_SYSTEM
1804 FRAME_WINDOW_P (XFRAME (w->frame)) ? 0 :
1805 #endif
1807 : XINT (XCAR (topos))),
1808 (NILP (width) ? -1 : XINT (width)),
1809 hscroll, tab_offset,
1810 XWINDOW (window));
1812 XSETFASTINT (bufpos, pos->bufpos);
1813 XSETINT (hpos, pos->hpos);
1814 XSETINT (vpos, pos->vpos);
1815 XSETINT (prevhpos, pos->prevhpos);
1817 return Fcons (bufpos,
1818 Fcons (hpos,
1819 Fcons (vpos,
1820 Fcons (prevhpos,
1821 Fcons (pos->contin ? Qt : Qnil, Qnil)))));
1825 /* Fvertical_motion and vmotion */
1827 struct position val_vmotion;
1829 struct position *
1830 vmotion (register EMACS_INT from, register EMACS_INT vtarget, struct window *w)
1832 EMACS_INT hscroll = XINT (w->hscroll);
1833 struct position pos;
1834 /* vpos is cumulative vertical position, changed as from is changed */
1835 register int vpos = 0;
1836 EMACS_INT prevline;
1837 register EMACS_INT first;
1838 EMACS_INT from_byte;
1839 EMACS_INT lmargin = hscroll > 0 ? 1 - hscroll : 0;
1840 int selective
1841 = (INTEGERP (current_buffer->selective_display)
1842 ? XINT (current_buffer->selective_display)
1843 : !NILP (current_buffer->selective_display) ? -1 : 0);
1844 Lisp_Object window;
1845 EMACS_INT start_hpos = 0;
1846 int did_motion;
1847 /* This is the object we use for fetching character properties. */
1848 Lisp_Object text_prop_object;
1850 XSETWINDOW (window, w);
1852 /* If the window contains this buffer, use it for getting text properties.
1853 Otherwise use the current buffer as arg for doing that. */
1854 if (EQ (w->buffer, Fcurrent_buffer ()))
1855 text_prop_object = window;
1856 else
1857 text_prop_object = Fcurrent_buffer ();
1859 if (vpos >= vtarget)
1861 /* To move upward, go a line at a time until
1862 we have gone at least far enough. */
1864 first = 1;
1866 while ((vpos > vtarget || first) && from > BEGV)
1868 Lisp_Object propval;
1870 prevline = find_next_newline_no_quit (from - 1, -1);
1871 while (prevline > BEGV
1872 && ((selective > 0
1873 && indented_beyond_p (prevline,
1874 CHAR_TO_BYTE (prevline),
1875 (double) selective)) /* iftc */
1876 /* Watch out for newlines with `invisible' property.
1877 When moving upward, check the newline before. */
1878 || (propval = Fget_char_property (make_number (prevline - 1),
1879 Qinvisible,
1880 text_prop_object),
1881 TEXT_PROP_MEANS_INVISIBLE (propval))))
1882 prevline = find_next_newline_no_quit (prevline - 1, -1);
1883 pos = *compute_motion (prevline, 0,
1884 lmargin + (prevline == BEG ? start_hpos : 0),
1886 from,
1887 /* Don't care for VPOS... */
1888 1 << (BITS_PER_SHORT - 1),
1889 /* ... nor HPOS. */
1890 1 << (BITS_PER_SHORT - 1),
1891 -1, hscroll,
1892 /* This compensates for start_hpos
1893 so that a tab as first character
1894 still occupies 8 columns. */
1895 (prevline == BEG ? -start_hpos : 0),
1897 vpos -= pos.vpos;
1898 first = 0;
1899 from = prevline;
1902 /* If we made exactly the desired vertical distance,
1903 or if we hit beginning of buffer,
1904 return point found */
1905 if (vpos >= vtarget)
1907 val_vmotion.bufpos = from;
1908 val_vmotion.bytepos = CHAR_TO_BYTE (from);
1909 val_vmotion.vpos = vpos;
1910 val_vmotion.hpos = lmargin;
1911 val_vmotion.contin = 0;
1912 val_vmotion.prevhpos = 0;
1913 val_vmotion.ovstring_chars_done = 0;
1914 val_vmotion.tab_offset = 0; /* For accumulating tab offset. */
1915 return &val_vmotion;
1918 /* Otherwise find the correct spot by moving down */
1920 /* Moving downward is simple, but must calculate from beg of line
1921 to determine hpos of starting point */
1922 from_byte = CHAR_TO_BYTE (from);
1923 if (from > BEGV && FETCH_BYTE (from_byte - 1) != '\n')
1925 Lisp_Object propval;
1927 prevline = find_next_newline_no_quit (from, -1);
1928 while (prevline > BEGV
1929 && ((selective > 0
1930 && indented_beyond_p (prevline,
1931 CHAR_TO_BYTE (prevline),
1932 (double) selective)) /* iftc */
1933 /* Watch out for newlines with `invisible' property.
1934 When moving downward, check the newline after. */
1935 || (propval = Fget_char_property (make_number (prevline),
1936 Qinvisible,
1937 text_prop_object),
1938 TEXT_PROP_MEANS_INVISIBLE (propval))))
1939 prevline = find_next_newline_no_quit (prevline - 1, -1);
1940 pos = *compute_motion (prevline, 0,
1941 lmargin + (prevline == BEG
1942 ? start_hpos : 0),
1944 from,
1945 /* Don't care for VPOS... */
1946 1 << (BITS_PER_SHORT - 1),
1947 /* ... nor HPOS. */
1948 1 << (BITS_PER_SHORT - 1),
1949 -1, hscroll,
1950 (prevline == BEG ? -start_hpos : 0),
1952 did_motion = 1;
1954 else
1956 pos.hpos = lmargin + (from == BEG ? start_hpos : 0);
1957 pos.vpos = 0;
1958 pos.tab_offset = 0;
1959 did_motion = 0;
1961 return compute_motion (from, vpos, pos.hpos, did_motion,
1962 ZV, vtarget, - (1 << (BITS_PER_SHORT - 1)),
1963 -1, hscroll,
1964 pos.tab_offset - (from == BEG ? start_hpos : 0),
1968 DEFUN ("vertical-motion", Fvertical_motion, Svertical_motion, 1, 2, 0,
1969 doc: /* Move point to start of the screen line LINES lines down.
1970 If LINES is negative, this means moving up.
1972 This function is an ordinary cursor motion function
1973 which calculates the new position based on how text would be displayed.
1974 The new position may be the start of a line,
1975 or just the start of a continuation line.
1976 The function returns number of screen lines moved over;
1977 that usually equals LINES, but may be closer to zero
1978 if beginning or end of buffer was reached.
1980 The optional second argument WINDOW specifies the window to use for
1981 parameters such as width, horizontal scrolling, and so on.
1982 The default is to use the selected window's parameters.
1984 LINES can optionally take the form (COLS . LINES), in which case
1985 the motion will not stop at the start of a screen line but on
1986 its column COLS (if such exists on that line, that is).
1988 `vertical-motion' always uses the current buffer,
1989 regardless of which buffer is displayed in WINDOW.
1990 This is consistent with other cursor motion functions
1991 and makes it possible to use `vertical-motion' in any buffer,
1992 whether or not it is currently displayed in some window. */)
1993 (Lisp_Object lines, Lisp_Object window)
1995 struct it it;
1996 struct text_pos pt;
1997 struct window *w;
1998 Lisp_Object old_buffer;
1999 struct gcpro gcpro1;
2000 Lisp_Object lcols = Qnil;
2001 double cols;
2003 /* Allow LINES to be of the form (HPOS . VPOS) aka (COLUMNS . LINES). */
2004 if (CONSP (lines) && (NUMBERP (XCAR (lines))))
2006 lcols = XCAR (lines);
2007 cols = INTEGERP (lcols) ? (double) XINT (lcols) : XFLOAT_DATA (lcols);
2008 lines = XCDR (lines);
2011 CHECK_NUMBER (lines);
2012 if (! NILP (window))
2013 CHECK_WINDOW (window);
2014 else
2015 window = selected_window;
2016 w = XWINDOW (window);
2018 old_buffer = Qnil;
2019 GCPRO1 (old_buffer);
2020 if (XBUFFER (w->buffer) != current_buffer)
2022 /* Set the window's buffer temporarily to the current buffer. */
2023 old_buffer = w->buffer;
2024 XSETBUFFER (w->buffer, current_buffer);
2027 if (noninteractive)
2029 struct position pos;
2030 pos = *vmotion (PT, XINT (lines), w);
2031 SET_PT_BOTH (pos.bufpos, pos.bytepos);
2033 else
2035 int it_start, first_x, it_overshoot_expected;
2037 SET_TEXT_POS (pt, PT, PT_BYTE);
2038 start_display (&it, w, pt);
2039 first_x = it.first_visible_x;
2040 it_start = IT_CHARPOS (it);
2042 /* See comments below for why we calculate this. */
2043 if (XINT (lines) > 0)
2045 if (it.cmp_it.id >= 0)
2046 it_overshoot_expected = 1;
2047 else if (it.method == GET_FROM_STRING)
2049 const char *s = SSDATA (it.string);
2050 const char *e = s + SBYTES (it.string);
2051 while (s < e && *s != '\n')
2052 ++s;
2053 it_overshoot_expected = (s == e) ? -1 : 0;
2055 else
2056 it_overshoot_expected = (it.method == GET_FROM_IMAGE
2057 || it.method == GET_FROM_STRETCH);
2060 /* Scan from the start of the line containing PT. If we don't
2061 do this, we start moving with IT->current_x == 0, while PT is
2062 really at some x > 0. */
2063 reseat_at_previous_visible_line_start (&it);
2064 it.current_x = it.hpos = 0;
2065 if (IT_CHARPOS (it) != PT)
2066 /* We used to temporarily disable selective display here; the
2067 comment said this is "so we don't move too far" (2005-01-19
2068 checkin by kfs). But this does nothing useful that I can
2069 tell, and it causes Bug#2694 . -- cyd */
2070 move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
2072 if (XINT (lines) <= 0)
2074 it.vpos = 0;
2075 /* Do this even if LINES is 0, so that we move back to the
2076 beginning of the current line as we ought. */
2077 if (XINT (lines) == 0 || IT_CHARPOS (it) > 0)
2078 move_it_by_lines (&it, XINT (lines), 0);
2080 else
2082 if (IT_CHARPOS (it) > it_start)
2084 /* IT may move too far if truncate-lines is on and PT
2085 lies beyond the right margin. In that case,
2086 backtrack unless the starting point is on an image,
2087 stretch glyph, composition, or Lisp string. */
2088 if (!it_overshoot_expected
2089 /* Also, backtrack if the Lisp string contains no
2090 newline, but there is a newline right after it.
2091 In this case, IT overshoots if there is an
2092 after-string just before the newline. */
2093 || (it_overshoot_expected < 0
2094 && it.method == GET_FROM_BUFFER
2095 && it.c == '\n'))
2096 move_it_by_lines (&it, -1, 0);
2097 it.vpos = 0;
2098 move_it_by_lines (&it, XINT (lines), 0);
2100 else
2102 /* Otherwise, we are at the first row occupied by PT,
2103 which might span multiple screen lines (e.g., if it's
2104 on a multi-line display string). We want to start
2105 from the last line that it occupies. */
2106 if (it_start < ZV)
2108 while (IT_CHARPOS (it) <= it_start)
2110 it.vpos = 0;
2111 move_it_by_lines (&it, 1, 0);
2113 if (XINT (lines) > 1)
2114 move_it_by_lines (&it, XINT (lines) - 1, 0);
2116 else
2118 it.vpos = 0;
2119 move_it_by_lines (&it, XINT (lines), 0);
2124 /* Move to the goal column, if one was specified. */
2125 if (!NILP (lcols))
2127 /* If the window was originally hscrolled, move forward by
2128 the hscrolled amount first. */
2129 if (first_x > 0)
2131 move_it_in_display_line (&it, ZV, first_x, MOVE_TO_X);
2132 it.current_x = 0;
2134 move_it_in_display_line
2135 (&it, ZV,
2136 (int)(cols * FRAME_COLUMN_WIDTH (XFRAME (w->frame)) + 0.5),
2137 MOVE_TO_X);
2140 SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
2143 if (BUFFERP (old_buffer))
2144 w->buffer = old_buffer;
2146 RETURN_UNGCPRO (make_number (it.vpos));
2151 /* File's initialization. */
2153 void
2154 syms_of_indent (void)
2156 DEFVAR_BOOL ("indent-tabs-mode", indent_tabs_mode,
2157 doc: /* *Indentation can insert tabs if this is non-nil. */);
2158 indent_tabs_mode = 1;
2160 defsubr (&Scurrent_indentation);
2161 defsubr (&Sindent_to);
2162 defsubr (&Scurrent_column);
2163 defsubr (&Smove_to_column);
2164 defsubr (&Svertical_motion);
2165 defsubr (&Scompute_motion);