]> code.delx.au - gnu-emacs/blob - src/indent.c
(compute_motion): Call strwidth only when necessary.
[gnu-emacs] / src / indent.c
1 /* Indentation functions.
2 Copyright (C) 1985,86,87,88,93,94,95,98 Free Software Foundation, Inc.
3
4 This file is part of GNU Emacs.
5
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)
9 any later version.
10
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.
15
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. */
20
21
22 #include <config.h>
23 #include "lisp.h"
24 #include "buffer.h"
25 #include "charset.h"
26 #include "category.h"
27 #include "indent.h"
28 #include "frame.h"
29 #include "window.h"
30 #include "termchar.h"
31 #include "termopts.h"
32 #include "disptab.h"
33 #include "intervals.h"
34 #include "region-cache.h"
35
36 /* Indentation can insert tabs if this is non-zero;
37 otherwise always uses spaces */
38 int indent_tabs_mode;
39
40 #define min(a, b) ((a) < (b) ? (a) : (b))
41 #define max(a, b) ((a) > (b) ? (a) : (b))
42
43 #define CR 015
44
45 /* These three values memoize the current column to avoid recalculation */
46 /* Some things in set last_known_column_point to -1
47 to mark the memoized value as invalid */
48 /* Last value returned by current_column */
49 int last_known_column;
50 /* Value of point when current_column was called */
51 int last_known_column_point;
52 /* Value of MODIFF when current_column was called */
53 int last_known_column_modified;
54
55 static int current_column_1 ();
56 static int position_indentation ();
57
58 /* Cache of beginning of line found by the last call of
59 current_column. */
60 int current_column_bol_cache;
61
62 /* Get the display table to use for the current buffer. */
63
64 struct Lisp_Char_Table *
65 buffer_display_table ()
66 {
67 Lisp_Object thisbuf;
68
69 thisbuf = current_buffer->display_table;
70 if (DISP_TABLE_P (thisbuf))
71 return XCHAR_TABLE (thisbuf);
72 if (DISP_TABLE_P (Vstandard_display_table))
73 return XCHAR_TABLE (Vstandard_display_table);
74 return 0;
75 }
76 \f
77 /* Width run cache considerations. */
78
79 /* Return the width of character C under display table DP. */
80
81 static int
82 character_width (c, dp)
83 int c;
84 struct Lisp_Char_Table *dp;
85 {
86 Lisp_Object elt;
87
88 /* These width computations were determined by examining the cases
89 in display_text_line. */
90
91 /* Everything can be handled by the display table, if it's
92 present and the element is right. */
93 if (dp && (elt = DISP_CHAR_VECTOR (dp, c), VECTORP (elt)))
94 return XVECTOR (elt)->size;
95
96 /* Some characters are special. */
97 if (c == '\n' || c == '\t' || c == '\015')
98 return 0;
99
100 /* Printing characters have width 1. */
101 else if (c >= 040 && c < 0177)
102 return 1;
103
104 /* Everybody else (control characters, metacharacters) has other
105 widths. We could return their actual widths here, but they
106 depend on things like ctl_arrow and crud like that, and they're
107 not very common at all. So we'll just claim we don't know their
108 widths. */
109 else
110 return 0;
111 }
112
113 /* Return true iff the display table DISPTAB specifies the same widths
114 for characters as WIDTHTAB. We use this to decide when to
115 invalidate the buffer's width_run_cache. */
116 int
117 disptab_matches_widthtab (disptab, widthtab)
118 struct Lisp_Char_Table *disptab;
119 struct Lisp_Vector *widthtab;
120 {
121 int i;
122
123 if (widthtab->size != 256)
124 abort ();
125
126 for (i = 0; i < 256; i++)
127 if (character_width (i, disptab)
128 != XFASTINT (widthtab->contents[i]))
129 return 0;
130
131 return 1;
132 }
133
134 /* Recompute BUF's width table, using the display table DISPTAB. */
135 void
136 recompute_width_table (buf, disptab)
137 struct buffer *buf;
138 struct Lisp_Char_Table *disptab;
139 {
140 int i;
141 struct Lisp_Vector *widthtab;
142
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 ();
148
149 for (i = 0; i < 256; i++)
150 XSETFASTINT (widthtab->contents[i], character_width (i, disptab));
151 }
152
153 /* Allocate or free the width run cache, as requested by the current
154 state of current_buffer's cache_long_line_scans variable. */
155 static void
156 width_run_cache_on_off ()
157 {
158 if (NILP (current_buffer->cache_long_line_scans)
159 /* And, for the moment, this feature doesn't work on multibyte
160 characters. */
161 || !NILP (current_buffer->enable_multibyte_characters))
162 {
163 /* It should be off. */
164 if (current_buffer->width_run_cache)
165 {
166 free_region_cache (current_buffer->width_run_cache);
167 current_buffer->width_run_cache = 0;
168 current_buffer->width_table = Qnil;
169 }
170 }
171 else
172 {
173 /* It should be on. */
174 if (current_buffer->width_run_cache == 0)
175 {
176 current_buffer->width_run_cache = new_region_cache ();
177 recompute_width_table (current_buffer, buffer_display_table ());
178 }
179 }
180 }
181
182 \f
183 /* Skip some invisible characters starting from POS.
184 This includes characters invisible because of text properties
185 and characters invisible because of overlays.
186
187 If position POS is followed by invisible characters,
188 skip some of them and return the position after them.
189 Otherwise return POS itself.
190
191 Set *NEXT_BOUNDARY_P to the next position at which
192 it will be necessary to call this function again.
193
194 Don't scan past TO, and don't set *NEXT_BOUNDARY_P
195 to a value greater than TO.
196
197 If WINDOW is non-nil, and this buffer is displayed in WINDOW,
198 take account of overlays that apply only in WINDOW.
199
200 We don't necessarily skip all the invisible characters after POS
201 because that could take a long time. We skip a reasonable number
202 which can be skipped quickly. If there might be more invisible
203 characters immediately following, then *NEXT_BOUNDARY_P
204 will equal the return value. */
205
206 static int
207 skip_invisible (pos, next_boundary_p, to, window)
208 int pos;
209 int *next_boundary_p;
210 int to;
211 Lisp_Object window;
212 {
213 Lisp_Object prop, position, overlay_limit, proplimit;
214 Lisp_Object buffer;
215 int end;
216
217 XSETFASTINT (position, pos);
218 XSETBUFFER (buffer, current_buffer);
219
220 /* Give faster response for overlay lookup near POS. */
221 recenter_overlay_lists (current_buffer, pos);
222
223 /* We must not advance farther than the next overlay change.
224 The overlay change might change the invisible property;
225 or there might be overlay strings to be displayed there. */
226 overlay_limit = Fnext_overlay_change (position);
227 /* As for text properties, this gives a lower bound
228 for where the invisible text property could change. */
229 proplimit = Fnext_property_change (position, buffer, Qt);
230 if (XFASTINT (overlay_limit) < XFASTINT (proplimit))
231 proplimit = overlay_limit;
232 /* PROPLIMIT is now a lower bound for the next change
233 in invisible status. If that is plenty far away,
234 use that lower bound. */
235 if (XFASTINT (proplimit) > pos + 100 || XFASTINT (proplimit) >= to)
236 *next_boundary_p = XFASTINT (proplimit);
237 /* Otherwise, scan for the next `invisible' property change. */
238 else
239 {
240 /* Don't scan terribly far. */
241 XSETFASTINT (proplimit, min (pos + 100, to));
242 /* No matter what. don't go past next overlay change. */
243 if (XFASTINT (overlay_limit) < XFASTINT (proplimit))
244 proplimit = overlay_limit;
245 end = XFASTINT (Fnext_single_property_change (position, Qinvisible,
246 buffer, proplimit));
247 #if 0
248 /* Don't put the boundary in the middle of multibyte form if
249 there is no actual property change. */
250 if (end == pos + 100
251 && !NILP (current_buffer->enable_multibyte_characters)
252 && end < ZV)
253 while (pos < end && !CHAR_HEAD_P (POS_ADDR (end)))
254 end--;
255 #endif
256 *next_boundary_p = end;
257 }
258 /* if the `invisible' property is set, we can skip to
259 the next property change */
260 if (!NILP (window) && EQ (XWINDOW (window)->buffer, buffer))
261 prop = Fget_char_property (position, Qinvisible, window);
262 else
263 prop = Fget_char_property (position, Qinvisible, buffer);
264 if (TEXT_PROP_MEANS_INVISIBLE (prop))
265 return *next_boundary_p;
266 return pos;
267 }
268 \f
269 /* Set variables WIDTH and BYTES for a multibyte sequence starting at P.
270
271 C is *P which should satisfy `BASE_LEADING_CODE_P (c)'.
272
273 DP is a display table or NULL.
274
275 This macro is used in current_column_1, Fmove_to_column, and
276 compute_motion. */
277
278 #define MULTIBYTE_BYTES_WIDTH(p, c, dp) \
279 do { \
280 unsigned char *pend = p + 1; \
281 \
282 wide_column = 0; \
283 while (! CHAR_HEAD_P (*pend)) pend++; \
284 \
285 if (c == LEADING_CODE_COMPOSITION) \
286 { \
287 int id = str_cmpchar_id (p, pend - p); \
288 int ch = MAKE_COMPOSITE_CHAR (id); \
289 \
290 if (id >= 0) \
291 { \
292 bytes = cmpchar_table[id]->len; \
293 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, ch))) \
294 width = XVECTOR (DISP_CHAR_VECTOR (dp, ch))->size; \
295 else \
296 width = cmpchar_table[id]->width; \
297 if (width > 1) \
298 wide_column = width; \
299 } \
300 else \
301 { \
302 bytes = 1; \
303 width = 4; \
304 } \
305 } \
306 else \
307 { \
308 bytes = BYTES_BY_CHAR_HEAD (c); \
309 if (bytes >= 2 && bytes <= pend - p) \
310 { \
311 int ch; \
312 \
313 if (dp && (ch = STRING_CHAR (p, bytes), \
314 VECTORP (DISP_CHAR_VECTOR (dp, ch)))) \
315 width = XVECTOR (DISP_CHAR_VECTOR (dp, ch))->size; \
316 else \
317 width = WIDTH_BY_CHAR_HEAD (c); \
318 if (width > 1) \
319 wide_column = width; \
320 } \
321 else \
322 { \
323 bytes = 1; \
324 width = 4; \
325 } \
326 } \
327 if (p + bytes < pend) \
328 { \
329 width += 4 * (pend - (p + bytes)); \
330 bytes = pend - p; \
331 } \
332 } while (0)
333
334 DEFUN ("current-column", Fcurrent_column, Scurrent_column, 0, 0, 0,
335 "Return the horizontal position of point. Beginning of line is column 0.\n\
336 This is calculated by adding together the widths of all the displayed\n\
337 representations of the character between the start of the previous line\n\
338 and point. (eg control characters will have a width of 2 or 4, tabs\n\
339 will have a variable width)\n\
340 Ignores finite width of frame, which means that this function may return\n\
341 values greater than (frame-width).\n\
342 Whether the line is visible (if `selective-display' is t) has no effect;\n\
343 however, ^M is treated as end of line when `selective-display' is t.")
344 ()
345 {
346 Lisp_Object temp;
347 XSETFASTINT (temp, current_column ());
348 return temp;
349 }
350
351 /* Cancel any recorded value of the horizontal position. */
352
353 void
354 invalidate_current_column ()
355 {
356 last_known_column_point = 0;
357 }
358
359 int
360 current_column ()
361 {
362 register int col;
363 register unsigned char *ptr, *stop;
364 register int tab_seen;
365 int post_tab;
366 register int c;
367 register int tab_width = XINT (current_buffer->tab_width);
368 int ctl_arrow = !NILP (current_buffer->ctl_arrow);
369 register struct Lisp_Char_Table *dp = buffer_display_table ();
370 int stopchar;
371
372 if (PT == last_known_column_point
373 && MODIFF == last_known_column_modified)
374 return last_known_column;
375
376 /* If the buffer has overlays, text properties,
377 or multibyte characters, use a more general algorithm. */
378 if (BUF_INTERVALS (current_buffer)
379 || !NILP (current_buffer->overlays_before)
380 || !NILP (current_buffer->overlays_after)
381 || Z != Z_BYTE)
382 return current_column_1 ();
383
384 /* Scan backwards from point to the previous newline,
385 counting width. Tab characters are the only complicated case. */
386
387 /* Make a pointer for decrementing through the chars before point. */
388 ptr = BYTE_POS_ADDR (PT_BYTE - 1) + 1;
389 /* Make a pointer to where consecutive chars leave off,
390 going backwards from point. */
391 if (PT == BEGV)
392 stop = ptr;
393 else if (PT <= GPT || BEGV > GPT)
394 stop = BEGV_ADDR;
395 else
396 stop = GAP_END_ADDR;
397
398 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
399
400 col = 0, tab_seen = 0, post_tab = 0;
401
402 while (1)
403 {
404 if (ptr == stop)
405 {
406 /* We stopped either for the beginning of the buffer
407 or for the gap. */
408 if (ptr == BEGV_ADDR)
409 break;
410 /* It was the gap. Jump back over it. */
411 stop = BEGV_ADDR;
412 ptr = GPT_ADDR;
413 /* Check whether that brings us to beginning of buffer. */
414 if (BEGV >= GPT) break;
415 }
416
417 c = *--ptr;
418 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
419 col += XVECTOR (DISP_CHAR_VECTOR (dp, c))->size;
420 else if (c >= 040 && c < 0177)
421 col++;
422 else if (c == '\n'
423 || (c == '\r' && EQ (current_buffer->selective_display, Qt)))
424 {
425 ptr++;
426 break;
427 }
428 else if (c == '\t')
429 {
430 if (tab_seen)
431 col = ((col + tab_width) / tab_width) * tab_width;
432
433 post_tab += col;
434 col = 0;
435 tab_seen = 1;
436 }
437 else
438 col += (ctl_arrow && c < 0200) ? 2 : 4;
439 }
440
441 if (tab_seen)
442 {
443 col = ((col + tab_width) / tab_width) * tab_width;
444 col += post_tab;
445 }
446
447 if (ptr == BEGV_ADDR)
448 current_column_bol_cache = BEGV;
449 else
450 current_column_bol_cache = BYTE_TO_CHAR (PTR_BYTE_POS (ptr));
451
452 last_known_column = col;
453 last_known_column_point = PT;
454 last_known_column_modified = MODIFF;
455
456 return col;
457 }
458 \f
459 /* Return the column number of position POS
460 by scanning forward from the beginning of the line.
461 This function handles characters that are invisible
462 due to text properties or overlays. */
463
464 static int
465 current_column_1 ()
466 {
467 register int tab_width = XINT (current_buffer->tab_width);
468 register int ctl_arrow = !NILP (current_buffer->ctl_arrow);
469 register struct Lisp_Char_Table *dp = buffer_display_table ();
470 int multibyte = !NILP (current_buffer->enable_multibyte_characters);
471
472 /* Start the scan at the beginning of this line with column number 0. */
473 register int col = 0;
474 int scan, scan_byte;
475 int next_boundary, next_boundary_byte;
476 int opoint = PT, opoint_byte = PT_BYTE;
477
478 scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -1, 1);
479 current_column_bol_cache = PT;
480 scan = PT, scan_byte = PT_BYTE;
481 SET_PT_BOTH (opoint, opoint_byte);
482 next_boundary = scan;
483 next_boundary_byte = scan_byte;
484
485 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
486
487 /* Scan forward to the target position. */
488 while (scan < opoint)
489 {
490 int c;
491
492 /* Occasionally we may need to skip invisible text. */
493 while (scan == next_boundary)
494 {
495 int old_scan = scan;
496 /* This updates NEXT_BOUNDARY to the next place
497 where we might need to skip more invisible text. */
498 scan = skip_invisible (scan, &next_boundary, opoint, Qnil);
499 if (scan >= opoint)
500 goto endloop;
501 if (scan != old_scan)
502 scan_byte = CHAR_TO_BYTE (scan);
503 next_boundary_byte = CHAR_TO_BYTE (next_boundary);
504 }
505
506 c = FETCH_BYTE (scan_byte);
507 if (dp != 0
508 && ! (multibyte && BASE_LEADING_CODE_P (c))
509 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
510 {
511 col += XVECTOR (DISP_CHAR_VECTOR (dp, c))->size;
512 scan++;
513 scan_byte++;
514 continue;
515 }
516 if (c == '\n')
517 break;
518 if (c == '\r' && EQ (current_buffer->selective_display, Qt))
519 break;
520 scan++;
521 scan_byte++;
522 if (c == '\t')
523 {
524 int prev_col = col;
525 col += tab_width;
526 col = col / tab_width * tab_width;
527 }
528 else if (multibyte && BASE_LEADING_CODE_P (c))
529 {
530 unsigned char *ptr;
531 int bytes, width, wide_column;
532
533 scan_byte--;
534 ptr = BYTE_POS_ADDR (scan_byte);
535 MULTIBYTE_BYTES_WIDTH (ptr, c, dp);
536 scan_byte += bytes;
537 col += width;
538 }
539 else if (ctl_arrow && (c < 040 || c == 0177))
540 col += 2;
541 else if (c < 040 || c >= 0177)
542 col += 4;
543 else
544 col++;
545 }
546 endloop:
547
548 last_known_column = col;
549 last_known_column_point = PT;
550 last_known_column_modified = MODIFF;
551
552 return col;
553 }
554 \f
555 /* Return the width in columns of the part of STRING from BEG to END.
556 If BEG is nil, that stands for the beginning of STRING.
557 If END is nil, that stands for the end of STRING. */
558
559 static int
560 string_display_width (string, beg, end)
561 Lisp_Object string, beg, end;
562 {
563 register int col;
564 register unsigned char *ptr, *stop;
565 register int tab_seen;
566 int post_tab;
567 register int c;
568 register int tab_width = XINT (current_buffer->tab_width);
569 int ctl_arrow = !NILP (current_buffer->ctl_arrow);
570 register struct Lisp_Char_Table *dp = buffer_display_table ();
571 int b, e;
572
573 if (NILP (end))
574 e = XSTRING (string)->size;
575 else
576 {
577 CHECK_NUMBER (end, 0);
578 e = XINT (end);
579 }
580
581 if (NILP (beg))
582 b = 0;
583 else
584 {
585 CHECK_NUMBER (beg, 0);
586 b = XINT (beg);
587 }
588
589 /* Make a pointer for decrementing through the chars before point. */
590 ptr = XSTRING (string)->data + e;
591 /* Make a pointer to where consecutive chars leave off,
592 going backwards from point. */
593 stop = XSTRING (string)->data + b;
594
595 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
596
597 col = 0, tab_seen = 0, post_tab = 0;
598
599 while (1)
600 {
601 if (ptr == stop)
602 break;
603
604 c = *--ptr;
605 if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
606 col += XVECTOR (DISP_CHAR_VECTOR (dp, c))->size;
607 else if (c >= 040 && c < 0177)
608 col++;
609 else if (c == '\n')
610 break;
611 else if (c == '\t')
612 {
613 if (tab_seen)
614 col = ((col + tab_width) / tab_width) * tab_width;
615
616 post_tab += col;
617 col = 0;
618 tab_seen = 1;
619 }
620 else
621 col += (ctl_arrow && c < 0200) ? 2 : 4;
622 }
623
624 if (tab_seen)
625 {
626 col = ((col + tab_width) / tab_width) * tab_width;
627 col += post_tab;
628 }
629
630 return col;
631 }
632 \f
633 DEFUN ("indent-to", Findent_to, Sindent_to, 1, 2, "NIndent to column: ",
634 "Indent from point with tabs and spaces until COLUMN is reached.\n\
635 Optional second argument MININUM says always do at least MININUM spaces\n\
636 even if that goes past COLUMN; by default, MININUM is zero.")
637 (column, minimum)
638 Lisp_Object column, minimum;
639 {
640 int mincol;
641 register int fromcol;
642 register int tab_width = XINT (current_buffer->tab_width);
643
644 CHECK_NUMBER (column, 0);
645 if (NILP (minimum))
646 XSETFASTINT (minimum, 0);
647 CHECK_NUMBER (minimum, 1);
648
649 fromcol = current_column ();
650 mincol = fromcol + XINT (minimum);
651 if (mincol < XINT (column)) mincol = XINT (column);
652
653 if (fromcol == mincol)
654 return make_number (mincol);
655
656 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
657
658 if (indent_tabs_mode)
659 {
660 Lisp_Object n;
661 XSETFASTINT (n, mincol / tab_width - fromcol / tab_width);
662 if (XFASTINT (n) != 0)
663 {
664 Finsert_char (make_number ('\t'), n, Qt);
665
666 fromcol = (mincol / tab_width) * tab_width;
667 }
668 }
669
670 XSETFASTINT (column, mincol - fromcol);
671 Finsert_char (make_number (' '), column, Qt);
672
673 last_known_column = mincol;
674 last_known_column_point = PT;
675 last_known_column_modified = MODIFF;
676
677 XSETINT (column, mincol);
678 return column;
679 }
680
681 \f
682 DEFUN ("current-indentation", Fcurrent_indentation, Scurrent_indentation,
683 0, 0, 0,
684 "Return the indentation of the current line.\n\
685 This is the horizontal position of the character\n\
686 following any initial whitespace.")
687 ()
688 {
689 Lisp_Object val;
690 int opoint = PT, opoint_byte = PT_BYTE;
691
692 scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -1, 1);
693
694 XSETFASTINT (val, position_indentation (PT_BYTE));
695 SET_PT_BOTH (opoint, opoint_byte);
696 return val;
697 }
698
699 static int
700 position_indentation (pos_byte)
701 register int pos_byte;
702 {
703 register int column = 0;
704 register int tab_width = XINT (current_buffer->tab_width);
705 register unsigned char *p;
706 register unsigned char *stop;
707 unsigned char *start;
708 int next_boundary_byte = pos_byte;
709 int ceiling = next_boundary_byte;
710
711 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
712
713 p = BYTE_POS_ADDR (pos_byte);
714 /* STOP records the value of P at which we will need
715 to think about the gap, or about invisible text,
716 or about the end of the buffer. */
717 stop = p;
718 /* START records the starting value of P. */
719 start = p;
720 while (1)
721 {
722 while (p == stop)
723 {
724 int stop_pos_byte;
725
726 /* If we have updated P, set POS_BYTE to match.
727 The first time we enter the loop, POS_BYTE is already right. */
728 if (p != start)
729 pos_byte = PTR_BYTE_POS (p);
730 /* Consider the various reasons STOP might have been set here. */
731 if (pos_byte == ZV_BYTE)
732 return column;
733 if (pos_byte == next_boundary_byte)
734 {
735 int next_boundary;
736 int pos = BYTE_TO_CHAR (pos_byte);
737 pos = skip_invisible (pos, &next_boundary, ZV, Qnil);
738 pos_byte = CHAR_TO_BYTE (pos);
739 next_boundary_byte = CHAR_TO_BYTE (next_boundary);
740 }
741 if (pos_byte >= ceiling)
742 ceiling = BUFFER_CEILING_OF (pos_byte) + 1;
743 /* Compute the next place we need to stop and think,
744 and set STOP accordingly. */
745 stop_pos_byte = min (ceiling, next_boundary_byte);
746 /* The -1 and +1 arrange to point at the first byte of gap
747 (if STOP_POS_BYTE is the position of the gap)
748 rather than at the data after the gap. */
749
750 stop = BYTE_POS_ADDR (stop_pos_byte - 1) + 1;
751 p = BYTE_POS_ADDR (pos_byte);
752 }
753 switch (*p++)
754 {
755 case 0240:
756 if (! NILP (current_buffer->enable_multibyte_characters))
757 return column;
758 case ' ':
759 column++;
760 break;
761 case '\t':
762 column += tab_width - column % tab_width;
763 break;
764 default:
765 if (ASCII_BYTE_P (p[-1])
766 || NILP (current_buffer->enable_multibyte_characters))
767 return column;
768 {
769 int c;
770 pos_byte = PTR_BYTE_POS (p - 1);
771 c = FETCH_MULTIBYTE_CHAR (pos_byte);
772 if (CHAR_HAS_CATEGORY (c, ' '))
773 {
774 column++;
775 INC_POS (pos_byte);
776 p = BYTE_POS_ADDR (pos_byte);
777 }
778 else
779 return column;
780 }
781 }
782 }
783 }
784
785 /* Test whether the line beginning at POS is indented beyond COLUMN.
786 Blank lines are treated as if they had the same indentation as the
787 preceding line. */
788
789 int
790 indented_beyond_p (pos, pos_byte, column)
791 int pos, pos_byte, column;
792 {
793 Lisp_Object val;
794 int opoint = PT, opoint_byte = PT_BYTE;
795
796 SET_PT_BOTH (pos, pos_byte);
797 while (PT > BEGV && FETCH_BYTE (PT_BYTE) == '\n')
798 scan_newline (PT - 1, PT_BYTE - 1, BEGV, BEGV_BYTE, -1, 0);
799
800 XSETFASTINT (val, position_indentation (PT_BYTE));
801 SET_PT_BOTH (opoint, opoint_byte);
802 return val;
803 }
804 \f
805 DEFUN ("move-to-column", Fmove_to_column, Smove_to_column, 1, 2, "p",
806 "Move point to column COLUMN in the current line.\n\
807 The column of a character is calculated by adding together the widths\n\
808 as displayed of the previous characters in the line.\n\
809 This function ignores line-continuation;\n\
810 there is no upper limit on the column number a character can have\n\
811 and horizontal scrolling has no effect.\n\
812 \n\
813 If specified column is within a character, point goes after that character.\n\
814 If it's past end of line, point goes to end of line.\n\n\
815 A non-nil second (optional) argument FORCE means, if the line\n\
816 is too short to reach column COLUMN then add spaces/tabs to get there,\n\
817 and if COLUMN is in the middle of a tab character, change it to spaces.\n\
818 \n\
819 The return value is the current column.")
820 (column, force)
821 Lisp_Object column, force;
822 {
823 register int pos;
824 register int col = current_column ();
825 register int goal;
826 register int end;
827 register int tab_width = XINT (current_buffer->tab_width);
828 register int ctl_arrow = !NILP (current_buffer->ctl_arrow);
829 register struct Lisp_Char_Table *dp = buffer_display_table ();
830 register int multibyte = !NILP (current_buffer->enable_multibyte_characters);
831
832 Lisp_Object val;
833 int prev_col;
834 int c;
835 int next_boundary;
836
837 int pos_byte, end_byte, next_boundary_byte;
838
839 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
840 CHECK_NATNUM (column, 0);
841 goal = XINT (column);
842
843 pos = PT;
844 pos_byte = PT_BYTE;
845 end = ZV;
846 end_byte = ZV_BYTE;
847 next_boundary = pos;
848 next_boundary_byte = PT_BYTE;
849
850 /* If we're starting past the desired column,
851 back up to beginning of line and scan from there. */
852 if (col > goal)
853 {
854 end = pos;
855 pos = current_column_bol_cache;
856 pos_byte = CHAR_TO_BYTE (pos);
857 col = 0;
858 }
859
860 while (pos < end)
861 {
862 while (pos == next_boundary)
863 {
864 int prev = pos;
865 pos = skip_invisible (pos, &next_boundary, end, Qnil);
866 if (pos != prev)
867 pos_byte = CHAR_TO_BYTE (pos);
868 next_boundary_byte = CHAR_TO_BYTE (next_boundary);
869 if (pos >= end)
870 goto endloop;
871 }
872
873 /* Test reaching the goal column. We do this after skipping
874 invisible characters, so that we put point before the
875 character on which the cursor will appear. */
876 if (col >= goal)
877 break;
878
879 c = FETCH_BYTE (pos_byte);
880 if (dp != 0
881 && ! (multibyte && BASE_LEADING_CODE_P (c))
882 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
883 {
884 col += XVECTOR (DISP_CHAR_VECTOR (dp, c))->size;
885 pos_byte++;
886 pos++;
887 continue;
888 }
889 if (c == '\n')
890 break;
891 if (c == '\r' && EQ (current_buffer->selective_display, Qt))
892 break;
893 pos++;
894 pos_byte++;
895 if (c == '\t')
896 {
897 prev_col = col;
898 col += tab_width;
899 col = col / tab_width * tab_width;
900 }
901 else if (ctl_arrow && (c < 040 || c == 0177))
902 col += 2;
903 else if (c < 040 || c == 0177)
904 col += 4;
905 else if (c < 0177)
906 col++;
907 else if (multibyte && BASE_LEADING_CODE_P (c))
908 {
909 /* Start of multi-byte form. */
910 unsigned char *ptr;
911 int bytes, width, wide_column;
912
913 pos_byte--;
914 ptr = BYTE_POS_ADDR (pos_byte);
915 MULTIBYTE_BYTES_WIDTH (ptr, c, dp);
916 pos_byte += bytes;
917 col += width;
918 }
919 else
920 col += 4;
921 }
922 endloop:
923
924 SET_PT_BOTH (pos, pos_byte);
925
926 /* If a tab char made us overshoot, change it to spaces
927 and scan through it again. */
928 if (!NILP (force) && col > goal && c == '\t' && prev_col < goal)
929 {
930 int old_point, old_point_byte;
931
932 del_range (PT - 1, PT);
933 Findent_to (make_number (goal), Qnil);
934 old_point = PT;
935 old_point_byte = PT_BYTE;
936 Findent_to (make_number (col), Qnil);
937 SET_PT_BOTH (old_point, old_point_byte);
938 /* Set the last_known... vars consistently. */
939 col = goal;
940 }
941
942 /* If line ends prematurely, add space to the end. */
943 if (col < goal && !NILP (force))
944 Findent_to (make_number (col = goal), Qnil);
945
946 last_known_column = col;
947 last_known_column_point = PT;
948 last_known_column_modified = MODIFF;
949
950 XSETFASTINT (val, col);
951 return val;
952 }
953 \f
954 /* compute_motion: compute buffer posn given screen posn and vice versa */
955
956 struct position val_compute_motion;
957
958 /* Scan the current buffer forward from offset FROM, pretending that
959 this is at line FROMVPOS, column FROMHPOS, until reaching buffer
960 offset TO or line TOVPOS, column TOHPOS (whichever comes first),
961 and return the ending buffer position and screen location. If we
962 can't hit the requested column exactly (because of a tab or other
963 multi-column character), overshoot.
964
965 DID_MOTION is 1 if FROMHPOS has already accounted for overlay strings
966 at FROM. This is the case if FROMVPOS and FROMVPOS came from an
967 earlier call to compute_motion. The other common case is that FROMHPOS
968 is zero and FROM is a position that "belongs" at column zero, but might
969 be shifted by overlay strings; in this case DID_MOTION should be 0.
970
971 WIDTH is the number of columns available to display text;
972 compute_motion uses this to handle continuation lines and such.
973 HSCROLL is the number of columns not being displayed at the left
974 margin; this is usually taken from a window's hscroll member.
975 TAB_OFFSET is the number of columns of the first tab that aren't
976 being displayed, perhaps because of a continuation line or
977 something.
978
979 compute_motion returns a pointer to a struct position. The bufpos
980 member gives the buffer position at the end of the scan, and hpos
981 and vpos give its cartesian location. prevhpos is the column at
982 which the character before bufpos started, and contin is non-zero
983 if we reached the current line by continuing the previous.
984
985 Note that FROMHPOS and TOHPOS should be expressed in real screen
986 columns, taking HSCROLL and the truncation glyph at the left margin
987 into account. That is, beginning-of-line moves you to the hpos
988 -HSCROLL + (HSCROLL > 0).
989
990 For example, to find the buffer position of column COL of line LINE
991 of a certain window, pass the window's starting location as FROM
992 and the window's upper-left coordinates as FROMVPOS and FROMHPOS.
993 Pass the buffer's ZV as TO, to limit the scan to the end of the
994 visible section of the buffer, and pass LINE and COL as TOVPOS and
995 TOHPOS.
996
997 When displaying in window w, a typical formula for WIDTH is:
998
999 window_width - 1
1000 - (has_vertical_scroll_bars
1001 ? FRAME_SCROLL_BAR_COLS (XFRAME (window->frame))
1002 : (window_width + window_left != frame_width))
1003
1004 where
1005 window_width is XFASTINT (w->width),
1006 window_left is XFASTINT (w->left),
1007 has_vertical_scroll_bars is
1008 FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (WINDOW_FRAME (window)))
1009 and frame_width = FRAME_WIDTH (XFRAME (window->frame))
1010
1011 Or you can let window_internal_width do this all for you, and write:
1012 window_internal_width (w) - 1
1013
1014 The `-1' accounts for the continuation-line backslashes; the rest
1015 accounts for window borders if the window is split horizontally, and
1016 the scroll bars if they are turned on. */
1017
1018 struct position *
1019 compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width, hscroll, tab_offset, win)
1020 int from, fromvpos, fromhpos, to, tovpos, tohpos;
1021 int did_motion;
1022 register int width;
1023 int hscroll, tab_offset;
1024 struct window *win;
1025 {
1026 register int hpos = fromhpos;
1027 register int vpos = fromvpos;
1028
1029 register int pos;
1030 int pos_byte;
1031 register int c;
1032 register int tab_width = XFASTINT (current_buffer->tab_width);
1033 register int ctl_arrow = !NILP (current_buffer->ctl_arrow);
1034 register struct Lisp_Char_Table *dp = window_display_table (win);
1035 int selective
1036 = (INTEGERP (current_buffer->selective_display)
1037 ? XINT (current_buffer->selective_display)
1038 : !NILP (current_buffer->selective_display) ? -1 : 0);
1039 int prev_hpos = 0;
1040 int selective_rlen
1041 = (selective && dp && VECTORP (DISP_INVIS_VECTOR (dp))
1042 ? XVECTOR (DISP_INVIS_VECTOR (dp))->size : 0);
1043 /* The next location where the `invisible' property changes, or an
1044 overlay starts or ends. */
1045 int next_boundary = from;
1046
1047 /* For computing runs of characters with similar widths.
1048 Invariant: width_run_width is zero, or all the characters
1049 from width_run_start to width_run_end have a fixed width of
1050 width_run_width. */
1051 int width_run_start = from;
1052 int width_run_end = from;
1053 int width_run_width = 0;
1054 Lisp_Object *width_table;
1055 Lisp_Object buffer;
1056
1057 /* The next buffer pos where we should consult the width run cache. */
1058 int next_width_run = from;
1059 Lisp_Object window;
1060
1061 int multibyte = !NILP (current_buffer->enable_multibyte_characters);
1062 int wide_column_end_hpos = 0; /* Horizontal position at the end of
1063 last wide-column character. */
1064 int prev_pos; /* Previous buffer position. */
1065 int prev_pos_byte; /* Previous buffer position. */
1066 int contin_hpos; /* HPOS of last column of continued line. */
1067 int prev_tab_offset; /* Previous tab offset. */
1068
1069 XSETBUFFER (buffer, current_buffer);
1070 XSETWINDOW (window, win);
1071
1072 width_run_cache_on_off ();
1073 if (dp == buffer_display_table ())
1074 width_table = (VECTORP (current_buffer->width_table)
1075 ? XVECTOR (current_buffer->width_table)->contents
1076 : 0);
1077 else
1078 /* If the window has its own display table, we can't use the width
1079 run cache, because that's based on the buffer's display table. */
1080 width_table = 0;
1081
1082 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
1083
1084 pos = prev_pos = from;
1085 pos_byte = prev_pos_byte = CHAR_TO_BYTE (from);
1086 contin_hpos = 0;
1087 prev_tab_offset = tab_offset;
1088 while (1)
1089 {
1090 while (pos == next_boundary)
1091 {
1092 int pos_here = pos;
1093 int newpos;
1094
1095 /* If the caller says that the screen position came from an earlier
1096 call to compute_motion, then we've already accounted for the
1097 overlay strings at point. This is only true the first time
1098 through, so clear the flag after testing it. */
1099 if (!did_motion)
1100 /* We need to skip past the overlay strings. Currently those
1101 strings must not contain TAB;
1102 if we want to relax that restriction, something will have
1103 to be changed here. */
1104 {
1105 unsigned char *ovstr;
1106 int ovlen = overlay_strings (pos, win, &ovstr);
1107 hpos += ((multibyte && ovlen > 0)
1108 ? strwidth (ovstr, ovlen) : ovlen);
1109 }
1110 did_motion = 0;
1111
1112 if (pos >= to)
1113 break;
1114
1115 /* Advance POS past invisible characters
1116 (but not necessarily all that there are here),
1117 and store in next_boundary the next position where
1118 we need to call skip_invisible. */
1119 newpos = skip_invisible (pos, &next_boundary, to, window);
1120
1121 if (newpos >= to)
1122 goto after_loop;
1123
1124 if (newpos != pos_here)
1125 {
1126 pos = newpos;
1127 pos_byte = CHAR_TO_BYTE (pos);
1128 }
1129 }
1130
1131 /* Handle right margin. */
1132 /* Note on a wide-column character.
1133
1134 Characters are classified into the following three categories
1135 according to the width (columns occupied on screen).
1136
1137 (1) single-column character: ex. `a'
1138 (2) multi-column character: ex. `^A', TAB, `\033'
1139 (3) wide-column character: ex. Japanese character, Chinese character
1140 (In the following example, `W_' stands for them.)
1141
1142 Multi-column characters can be divided around the right margin,
1143 but wide-column characters cannot.
1144
1145 NOTE:
1146
1147 (*) The cursor is placed on the next character after the point.
1148
1149 ----------
1150 abcdefghi\
1151 j ^---- next after the point
1152 ^--- next char. after the point.
1153 ----------
1154 In case of sigle-column character
1155
1156 ----------
1157 abcdefgh\\
1158 033 ^---- next after the point, next char. after the point.
1159 ----------
1160 In case of multi-column character
1161
1162 ----------
1163 abcdefgh\\
1164 W_ ^---- next after the point
1165 ^---- next char. after the point.
1166 ----------
1167 In case of wide-column character
1168
1169 The problem here is continuation at a wide-column character.
1170 In this case, the line may shorter less than WIDTH.
1171 And we find the continuation AFTER it occurs.
1172
1173 */
1174
1175 if (hpos > width)
1176 {
1177 if (hscroll
1178 || (truncate_partial_width_windows
1179 && width + 1 < FRAME_WIDTH (XFRAME (WINDOW_FRAME (win))))
1180 || !NILP (current_buffer->truncate_lines))
1181 {
1182 /* Truncating: skip to newline, unless we are already past
1183 TO (we need to go back below). */
1184 if (pos <= to)
1185 {
1186 pos = find_before_next_newline (pos, to, 1);
1187 pos_byte = CHAR_TO_BYTE (pos);
1188 hpos = width;
1189 /* If we just skipped next_boundary,
1190 loop around in the main while
1191 and handle it. */
1192 if (pos >= next_boundary)
1193 next_boundary = pos + 1;
1194 prev_hpos = width;
1195 prev_tab_offset = tab_offset;
1196 }
1197 }
1198 else
1199 {
1200 /* Continuing. */
1201 /* Remember the previous value. */
1202 prev_tab_offset = tab_offset;
1203
1204 if (wide_column_end_hpos > width)
1205 {
1206 hpos -= prev_hpos;
1207 tab_offset += prev_hpos;
1208 }
1209 else
1210 {
1211 tab_offset += width;
1212 hpos -= width;
1213 }
1214 vpos++;
1215 contin_hpos = prev_hpos;
1216 prev_hpos = 0;
1217 }
1218 }
1219
1220 /* Stop if past the target buffer position or screen position. */
1221 if (pos > to)
1222 {
1223 /* Go back to the previous position. */
1224 pos = prev_pos;
1225 pos_byte = prev_pos_byte;
1226 hpos = prev_hpos;
1227 tab_offset = prev_tab_offset;
1228
1229 /* NOTE on contin_hpos, hpos, and prev_hpos.
1230
1231 ----------
1232 abcdefgh\\
1233 W_ ^---- contin_hpos
1234 | ^----- hpos
1235 \---- prev_hpos
1236 ----------
1237 */
1238
1239 if (contin_hpos && prev_hpos == 0
1240 && contin_hpos < width && !wide_column_end_hpos)
1241 {
1242 /* Line breaking occurs in the middle of multi-column
1243 character. Go back to previous line. */
1244 hpos = contin_hpos;
1245 vpos = vpos - 1;
1246 }
1247 else if (c == '\n')
1248 /* If previous character is NEWLINE,
1249 set VPOS back to previous line */
1250 vpos = vpos - 1;
1251 break;
1252 }
1253
1254 if (vpos > tovpos || vpos == tovpos && hpos >= tohpos)
1255 {
1256 if (contin_hpos && prev_hpos == 0
1257 && ((hpos > tohpos && contin_hpos == width)
1258 || (wide_column_end_hpos > width)))
1259 { /* Line breaks because we can't put the character at the
1260 previous line any more. It is not the multi-column
1261 character continued in middle. Go back to previous
1262 buffer position, screen position, and set tab offset
1263 to previous value. It's the beginning of the
1264 line. */
1265 pos = prev_pos;
1266 pos_byte = prev_pos_byte;
1267 hpos = prev_hpos;
1268 tab_offset = prev_tab_offset;
1269 }
1270 break;
1271 }
1272 if (pos == ZV) /* We cannot go beyond ZV. Stop here. */
1273 break;
1274
1275 prev_hpos = hpos;
1276 prev_pos = pos;
1277 prev_pos_byte = pos_byte;
1278 wide_column_end_hpos = 0;
1279
1280 /* Consult the width run cache to see if we can avoid inspecting
1281 the text character-by-character. */
1282 if (current_buffer->width_run_cache && pos >= next_width_run)
1283 {
1284 int run_end;
1285 int common_width
1286 = region_cache_forward (current_buffer,
1287 current_buffer->width_run_cache,
1288 pos, &run_end);
1289
1290 /* A width of zero means the character's width varies (like
1291 a tab), is meaningless (like a newline), or we just don't
1292 want to skip over it for some other reason. */
1293 if (common_width != 0)
1294 {
1295 int run_end_hpos;
1296
1297 /* Don't go past the final buffer posn the user
1298 requested. */
1299 if (run_end > to)
1300 run_end = to;
1301
1302 run_end_hpos = hpos + (run_end - pos) * common_width;
1303
1304 /* Don't go past the final horizontal position the user
1305 requested. */
1306 if (vpos == tovpos && run_end_hpos > tohpos)
1307 {
1308 run_end = pos + (tohpos - hpos) / common_width;
1309 run_end_hpos = hpos + (run_end - pos) * common_width;
1310 }
1311
1312 /* Don't go past the margin. */
1313 if (run_end_hpos >= width)
1314 {
1315 run_end = pos + (width - hpos) / common_width;
1316 run_end_hpos = hpos + (run_end - pos) * common_width;
1317 }
1318
1319 hpos = run_end_hpos;
1320 if (run_end > pos)
1321 prev_hpos = hpos - common_width;
1322 if (pos != run_end)
1323 {
1324 pos = run_end;
1325 pos_byte = CHAR_TO_BYTE (pos);
1326 }
1327 }
1328
1329 next_width_run = run_end + 1;
1330 }
1331
1332 /* We have to scan the text character-by-character. */
1333 else
1334 {
1335 c = FETCH_BYTE (pos_byte);
1336 pos++, pos_byte++;
1337
1338 /* Perhaps add some info to the width_run_cache. */
1339 if (current_buffer->width_run_cache)
1340 {
1341 /* Is this character part of the current run? If so, extend
1342 the run. */
1343 if (pos - 1 == width_run_end
1344 && XFASTINT (width_table[c]) == width_run_width)
1345 width_run_end = pos;
1346
1347 /* The previous run is over, since this is a character at a
1348 different position, or a different width. */
1349 else
1350 {
1351 /* Have we accumulated a run to put in the cache?
1352 (Currently, we only cache runs of width == 1). */
1353 if (width_run_start < width_run_end
1354 && width_run_width == 1)
1355 know_region_cache (current_buffer,
1356 current_buffer->width_run_cache,
1357 width_run_start, width_run_end);
1358
1359 /* Start recording a new width run. */
1360 width_run_width = XFASTINT (width_table[c]);
1361 width_run_start = pos - 1;
1362 width_run_end = pos;
1363 }
1364 }
1365
1366 if (dp != 0
1367 && ! (multibyte && BASE_LEADING_CODE_P (c))
1368 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
1369 hpos += XVECTOR (DISP_CHAR_VECTOR (dp, c))->size;
1370 else if (c >= 040 && c < 0177)
1371 hpos++;
1372 else if (c == '\t')
1373 {
1374 int tem = (hpos + tab_offset + hscroll - (hscroll > 0)) % tab_width;
1375 if (tem < 0)
1376 tem += tab_width;
1377 hpos += tab_width - tem;
1378 }
1379 else if (c == '\n')
1380 {
1381 if (selective > 0
1382 && indented_beyond_p (pos, pos_byte, selective))
1383 {
1384 /* If (pos == to), we don't have to take care of
1385 selective display. */
1386 if (pos < to)
1387 {
1388 /* Skip any number of invisible lines all at once */
1389 do
1390 {
1391 pos = find_before_next_newline (pos, to, 1) + 1;
1392 pos_byte = CHAR_TO_BYTE (pos);
1393 }
1394 while (pos < to
1395 && indented_beyond_p (pos, pos_byte, selective));
1396 /* Allow for the " ..." that is displayed for them. */
1397 if (selective_rlen)
1398 {
1399 hpos += selective_rlen;
1400 if (hpos >= width)
1401 hpos = width;
1402 }
1403 DEC_BOTH (pos, pos_byte);
1404 /* We have skipped the invis text, but not the
1405 newline after. */
1406 }
1407 }
1408 else
1409 {
1410 /* A visible line. */
1411 vpos++;
1412 hpos = 0;
1413 hpos -= hscroll;
1414 /* Count the truncation glyph on column 0 */
1415 if (hscroll > 0)
1416 hpos++;
1417 tab_offset = 0;
1418 }
1419 contin_hpos = 0;
1420 }
1421 else if (c == CR && selective < 0)
1422 {
1423 /* In selective display mode,
1424 everything from a ^M to the end of the line is invisible.
1425 Stop *before* the real newline. */
1426 if (pos < to)
1427 {
1428 pos = find_before_next_newline (pos, to, 1);
1429 pos_byte = CHAR_TO_BYTE (pos);
1430 }
1431 /* If we just skipped next_boundary,
1432 loop around in the main while
1433 and handle it. */
1434 if (pos > next_boundary)
1435 next_boundary = pos;
1436 /* Allow for the " ..." that is displayed for them. */
1437 if (selective_rlen)
1438 {
1439 hpos += selective_rlen;
1440 if (hpos >= width)
1441 hpos = width;
1442 }
1443 }
1444 else if (multibyte && BASE_LEADING_CODE_P (c))
1445 {
1446 /* Start of multi-byte form. */
1447 unsigned char *ptr;
1448 int bytes, width, wide_column;
1449
1450 pos_byte--; /* rewind POS_BYTE */
1451 ptr = BYTE_POS_ADDR (pos_byte);
1452 MULTIBYTE_BYTES_WIDTH (ptr, c, dp);
1453 pos_byte += bytes;
1454 if (wide_column)
1455 wide_column_end_hpos = hpos + wide_column;
1456 hpos += width;
1457 }
1458 else
1459 hpos += (ctl_arrow && c < 0200) ? 2 : 4;
1460 }
1461 }
1462
1463 after_loop:
1464
1465 /* Remember any final width run in the cache. */
1466 if (current_buffer->width_run_cache
1467 && width_run_width == 1
1468 && width_run_start < width_run_end)
1469 know_region_cache (current_buffer, current_buffer->width_run_cache,
1470 width_run_start, width_run_end);
1471
1472 val_compute_motion.bufpos = pos;
1473 val_compute_motion.bytepos = pos_byte;
1474 val_compute_motion.hpos = hpos;
1475 val_compute_motion.vpos = vpos;
1476 if (contin_hpos && prev_hpos == 0)
1477 val_compute_motion.prevhpos = contin_hpos;
1478 else
1479 val_compute_motion.prevhpos = prev_hpos;
1480 /* We alalways handle all of them here; none of them remain to do. */
1481 val_compute_motion.ovstring_chars_done = 0;
1482
1483 /* Nonzero if have just continued a line */
1484 val_compute_motion.contin = (contin_hpos && prev_hpos == 0);
1485
1486 return &val_compute_motion;
1487 }
1488
1489 #if 0 /* The doc string is too long for some compilers,
1490 but make-docfile can find it in this comment. */
1491 DEFUN ("compute-motion", Ffoo, Sfoo, 7, 7, 0,
1492 "Scan through the current buffer, calculating screen position.\n\
1493 Scan the current buffer forward from offset FROM,\n\
1494 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--\n\
1495 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--\n\
1496 and return the ending buffer position and screen location.\n\
1497 \n\
1498 There are three additional arguments:\n\
1499 \n\
1500 WIDTH is the number of columns available to display text;\n\
1501 this affects handling of continuation lines.\n\
1502 This is usually the value returned by `window-width', less one (to allow\n\
1503 for the continuation glyph).\n\
1504 \n\
1505 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).\n\
1506 HSCROLL is the number of columns not being displayed at the left\n\
1507 margin; this is usually taken from a window's hscroll member.\n\
1508 TAB-OFFSET is the number of columns of the first tab that aren't\n\
1509 being displayed, perhaps because the line was continued within it.\n\
1510 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.\n\
1511 \n\
1512 WINDOW is the window to operate on. It is used to choose the display table;\n\
1513 if it is showing the current buffer, it is used also for\n\
1514 deciding which overlay properties apply.\n\
1515 Note that `compute-motion' always operates on the current buffer.\n\
1516 \n\
1517 The value is a list of five elements:\n\
1518 (POS HPOS VPOS PREVHPOS CONTIN)\n\
1519 POS is the buffer position where the scan stopped.\n\
1520 VPOS is the vertical position where the scan stopped.\n\
1521 HPOS is the horizontal position where the scan stopped.\n\
1522 \n\
1523 PREVHPOS is the horizontal position one character back from POS.\n\
1524 CONTIN is t if a line was continued after (or within) the previous character.\n\
1525 \n\
1526 For example, to find the buffer position of column COL of line LINE\n\
1527 of a certain window, pass the window's starting location as FROM\n\
1528 and the window's upper-left coordinates as FROMPOS.\n\
1529 Pass the buffer's (point-max) as TO, to limit the scan to the end of the\n\
1530 visible section of the buffer, and pass LINE and COL as TOPOS.")
1531 (from, frompos, to, topos, width, offsets, window)
1532 #endif
1533
1534 DEFUN ("compute-motion", Fcompute_motion, Scompute_motion, 7, 7, 0,
1535 0)
1536 (from, frompos, to, topos, width, offsets, window)
1537 Lisp_Object from, frompos, to, topos;
1538 Lisp_Object width, offsets, window;
1539 {
1540 Lisp_Object bufpos, hpos, vpos, prevhpos, contin;
1541 struct position *pos;
1542 int hscroll, tab_offset;
1543
1544 CHECK_NUMBER_COERCE_MARKER (from, 0);
1545 CHECK_CONS (frompos, 0);
1546 CHECK_NUMBER (XCONS (frompos)->car, 0);
1547 CHECK_NUMBER (XCONS (frompos)->cdr, 0);
1548 CHECK_NUMBER_COERCE_MARKER (to, 0);
1549 CHECK_CONS (topos, 0);
1550 CHECK_NUMBER (XCONS (topos)->car, 0);
1551 CHECK_NUMBER (XCONS (topos)->cdr, 0);
1552 CHECK_NUMBER (width, 0);
1553 if (!NILP (offsets))
1554 {
1555 CHECK_CONS (offsets, 0);
1556 CHECK_NUMBER (XCONS (offsets)->car, 0);
1557 CHECK_NUMBER (XCONS (offsets)->cdr, 0);
1558 hscroll = XINT (XCONS (offsets)->car);
1559 tab_offset = XINT (XCONS (offsets)->cdr);
1560 }
1561 else
1562 hscroll = tab_offset = 0;
1563
1564 if (NILP (window))
1565 window = Fselected_window ();
1566 else
1567 CHECK_LIVE_WINDOW (window, 0);
1568
1569 pos = compute_motion (XINT (from), XINT (XCONS (frompos)->cdr),
1570 XINT (XCONS (frompos)->car), 0,
1571 XINT (to), XINT (XCONS (topos)->cdr),
1572 XINT (XCONS (topos)->car),
1573 XINT (width), hscroll, tab_offset,
1574 XWINDOW (window));
1575
1576 XSETFASTINT (bufpos, pos->bufpos);
1577 XSETINT (hpos, pos->hpos);
1578 XSETINT (vpos, pos->vpos);
1579 XSETINT (prevhpos, pos->prevhpos);
1580
1581 return Fcons (bufpos,
1582 Fcons (hpos,
1583 Fcons (vpos,
1584 Fcons (prevhpos,
1585 Fcons (pos->contin ? Qt : Qnil, Qnil)))));
1586
1587 }
1588 \f
1589 /* Fvertical_motion and vmotion */
1590 struct position val_vmotion;
1591
1592 struct position *
1593 vmotion (from, vtarget, w)
1594 register int from, vtarget;
1595 struct window *w;
1596 {
1597 int width = window_internal_width (w) - 1;
1598 int hscroll = XINT (w->hscroll);
1599 struct position pos;
1600 /* vpos is cumulative vertical position, changed as from is changed */
1601 register int vpos = 0;
1602 Lisp_Object prevline;
1603 register int first;
1604 int from_byte;
1605 int lmargin = hscroll > 0 ? 1 - hscroll : 0;
1606 int selective
1607 = (INTEGERP (current_buffer->selective_display)
1608 ? XINT (current_buffer->selective_display)
1609 : !NILP (current_buffer->selective_display) ? -1 : 0);
1610 Lisp_Object window;
1611 int start_hpos = 0;
1612 int did_motion;
1613
1614 XSETWINDOW (window, w);
1615
1616 /* The omission of the clause
1617 && marker_position (w->start) == BEG
1618 here is deliberate; I think we want to measure from the prompt
1619 position even if the minibuffer window has scrolled. */
1620 if (EQ (window, minibuf_window))
1621 {
1622 if (minibuf_prompt_width == 0 && STRINGP (minibuf_prompt))
1623 minibuf_prompt_width
1624 = string_display_width (minibuf_prompt, Qnil, Qnil);
1625
1626 start_hpos = minibuf_prompt_width;
1627 }
1628
1629 if (vpos >= vtarget)
1630 {
1631 /* To move upward, go a line at a time until
1632 we have gone at least far enough. */
1633
1634 first = 1;
1635
1636 while ((vpos > vtarget || first) && from > BEGV)
1637 {
1638 Lisp_Object propval;
1639
1640 XSETFASTINT (prevline, find_next_newline_no_quit (from - 1, -1));
1641 while (XFASTINT (prevline) > BEGV
1642 && ((selective > 0
1643 && indented_beyond_p (XFASTINT (prevline),
1644 CHAR_TO_BYTE (XFASTINT (prevline)),
1645 selective))
1646 #ifdef USE_TEXT_PROPERTIES
1647 /* watch out for newlines with `invisible' property */
1648 || (propval = Fget_char_property (prevline,
1649 Qinvisible,
1650 window),
1651 TEXT_PROP_MEANS_INVISIBLE (propval))
1652 #endif
1653 ))
1654 XSETFASTINT (prevline,
1655 find_next_newline_no_quit (XFASTINT (prevline) - 1,
1656 -1));
1657 pos = *compute_motion (XFASTINT (prevline), 0,
1658 lmargin + (XFASTINT (prevline) == BEG
1659 ? start_hpos : 0),
1660 0,
1661 from,
1662 /* Don't care for VPOS... */
1663 1 << (BITS_PER_SHORT - 1),
1664 /* ... nor HPOS. */
1665 1 << (BITS_PER_SHORT - 1),
1666 width, hscroll,
1667 /* This compensates for start_hpos
1668 so that a tab as first character
1669 still occupies 8 columns. */
1670 (XFASTINT (prevline) == BEG
1671 ? -start_hpos : 0),
1672 w);
1673 vpos -= pos.vpos;
1674 first = 0;
1675 from = XFASTINT (prevline);
1676 }
1677
1678 /* If we made exactly the desired vertical distance,
1679 or if we hit beginning of buffer,
1680 return point found */
1681 if (vpos >= vtarget)
1682 {
1683 val_vmotion.bufpos = from;
1684 val_vmotion.bytepos = CHAR_TO_BYTE (from);
1685 val_vmotion.vpos = vpos;
1686 val_vmotion.hpos = lmargin;
1687 val_vmotion.contin = 0;
1688 val_vmotion.prevhpos = 0;
1689 val_vmotion.ovstring_chars_done = 0;
1690 val_vmotion.tab_offset = 0; /* For accumulating tab offset. */
1691 return &val_vmotion;
1692 }
1693
1694 /* Otherwise find the correct spot by moving down */
1695 }
1696 /* Moving downward is simple, but must calculate from beg of line
1697 to determine hpos of starting point */
1698 from_byte = CHAR_TO_BYTE (from);
1699 if (from > BEGV && FETCH_BYTE (from_byte - 1) != '\n')
1700 {
1701 Lisp_Object propval;
1702
1703 XSETFASTINT (prevline, find_next_newline_no_quit (from, -1));
1704 while (XFASTINT (prevline) > BEGV
1705 && ((selective > 0
1706 && indented_beyond_p (XFASTINT (prevline),
1707 CHAR_TO_BYTE (XFASTINT (prevline)),
1708 selective))
1709 #ifdef USE_TEXT_PROPERTIES
1710 /* watch out for newlines with `invisible' property */
1711 || (propval = Fget_char_property (prevline, Qinvisible,
1712 window),
1713 TEXT_PROP_MEANS_INVISIBLE (propval))
1714 #endif
1715 ))
1716 XSETFASTINT (prevline,
1717 find_next_newline_no_quit (XFASTINT (prevline) - 1,
1718 -1));
1719 pos = *compute_motion (XFASTINT (prevline), 0,
1720 lmargin + (XFASTINT (prevline) == BEG
1721 ? start_hpos : 0),
1722 0,
1723 from,
1724 /* Don't care for VPOS... */
1725 1 << (BITS_PER_SHORT - 1),
1726 /* ... nor HPOS. */
1727 1 << (BITS_PER_SHORT - 1),
1728 width, hscroll,
1729 (XFASTINT (prevline) == BEG ? -start_hpos : 0),
1730 w);
1731 did_motion = 1;
1732 }
1733 else
1734 {
1735 pos.hpos = lmargin + (from == BEG ? start_hpos : 0);
1736 pos.vpos = 0;
1737 pos.tab_offset = 0;
1738 did_motion = 0;
1739 }
1740 return compute_motion (from, vpos, pos.hpos, did_motion,
1741 ZV, vtarget, - (1 << (BITS_PER_SHORT - 1)),
1742 width, hscroll,
1743 pos.tab_offset - (from == BEG ? start_hpos : 0),
1744 w);
1745 }
1746
1747 DEFUN ("vertical-motion", Fvertical_motion, Svertical_motion, 1, 2, 0,
1748 "Move point to start of the screen line LINES lines down.\n\
1749 If LINES is negative, this means moving up.\n\
1750 \n\
1751 This function is an ordinary cursor motion function\n\
1752 which calculates the new position based on how text would be displayed.\n\
1753 The new position may be the start of a line,\n\
1754 or just the start of a continuation line.\n\
1755 The function returns number of screen lines moved over;\n\
1756 that usually equals LINES, but may be closer to zero\n\
1757 if beginning or end of buffer was reached.\n\
1758 \n\
1759 The optional second argument WINDOW specifies the window to use for\n\
1760 parameters such as width, horizontal scrolling, and so on.\n\
1761 The default is to use the selected window's parameters.\n\
1762 \n\
1763 `vertical-motion' always uses the current buffer,\n\
1764 regardless of which buffer is displayed in WINDOW.\n\
1765 This is consistent with other cursor motion functions\n\
1766 and makes it possible to use `vertical-motion' in any buffer,\n\
1767 whether or not it is currently displayed in some window.")
1768 (lines, window)
1769 Lisp_Object lines, window;
1770 {
1771 struct position pos;
1772
1773 CHECK_NUMBER (lines, 0);
1774 if (! NILP (window))
1775 CHECK_WINDOW (window, 0);
1776 else
1777 window = selected_window;
1778
1779 pos = *vmotion (PT, (int) XINT (lines), XWINDOW (window));
1780
1781 SET_PT (pos.bufpos);
1782 return make_number (pos.vpos);
1783 }
1784 \f
1785 /* file's initialization. */
1786
1787 syms_of_indent ()
1788 {
1789 DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode,
1790 "*Indentation can insert tabs if this is non-nil.\n\
1791 Setting this variable automatically makes it local to the current buffer.");
1792 indent_tabs_mode = 1;
1793
1794 defsubr (&Scurrent_indentation);
1795 defsubr (&Sindent_to);
1796 defsubr (&Scurrent_column);
1797 defsubr (&Smove_to_column);
1798 defsubr (&Svertical_motion);
1799 defsubr (&Scompute_motion);
1800 }