|
428
|
1 /* Indentation functions.
|
|
|
2 Copyright (C) 1995 Board of Trustees, University of Illinois.
|
|
|
3 Copyright (C) 1985, 1986, 1987, 1988, 1992, 1993, 1994, 1995
|
|
826
|
4 Free Software Foundation, Inc.
|
|
793
|
5 Copyright (C) 2002 Ben Wing.
|
|
428
|
6
|
|
|
7 This file is part of XEmacs.
|
|
|
8
|
|
|
9 XEmacs is free software; you can redistribute it and/or modify it
|
|
|
10 under the terms of the GNU General Public License as published by the
|
|
|
11 Free Software Foundation; either version 2, or (at your option) any
|
|
|
12 later version.
|
|
|
13
|
|
|
14 XEmacs is distributed in the hope that it will be useful, but WITHOUT
|
|
|
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
17 for more details.
|
|
|
18
|
|
|
19 You should have received a copy of the GNU General Public License
|
|
|
20 along with XEmacs; see the file COPYING. If not, write to
|
|
|
21 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
22 Boston, MA 02111-1307, USA. */
|
|
|
23
|
|
|
24 /* This file has been Mule-ized. */
|
|
|
25
|
|
|
26 /* Synched up with: 19.30. Diverges significantly from FSF. */
|
|
|
27
|
|
|
28
|
|
|
29 #include <config.h>
|
|
|
30 #include "lisp.h"
|
|
|
31
|
|
|
32 #include "buffer.h"
|
|
|
33 #include "device.h"
|
|
|
34 #include "extents.h"
|
|
|
35 #include "faces.h"
|
|
|
36 #include "frame.h"
|
|
|
37 #include "glyphs.h"
|
|
|
38 #include "insdel.h"
|
|
|
39 #ifdef REGION_CACHE_NEEDS_WORK
|
|
|
40 #include "region-cache.h"
|
|
|
41 #endif
|
|
|
42 #include "window.h"
|
|
|
43
|
|
|
44 Lisp_Object Qcoerce;
|
|
|
45
|
|
|
46 /* Indentation can insert tabs if this is non-zero;
|
|
|
47 otherwise always uses spaces */
|
|
|
48 int indent_tabs_mode;
|
|
|
49
|
|
|
50 /* Avoid recalculation by remembering things in these variables. */
|
|
|
51
|
|
|
52 /* Last value returned by current_column.
|
|
|
53
|
|
|
54 Some things set last_known_column_point to -1
|
|
|
55 to mark the memoized value as invalid */
|
|
|
56 static int last_known_column;
|
|
|
57
|
|
|
58 /* Last buffer searched by current_column */
|
|
|
59 static struct buffer *last_known_column_buffer;
|
|
|
60
|
|
|
61 /* Value of point when current_column was called */
|
|
665
|
62 static Charbpos last_known_column_point;
|
|
428
|
63
|
|
|
64 /* Value of MODIFF when current_column was called */
|
|
|
65 static int last_known_column_modified;
|
|
|
66
|
|
665
|
67 static Charbpos
|
|
|
68 last_visible_position (Charbpos pos, struct buffer *buf)
|
|
428
|
69 {
|
|
|
70 Lisp_Object buffer;
|
|
|
71 Lisp_Object value;
|
|
|
72
|
|
793
|
73 buffer = wrap_buffer (buf);
|
|
428
|
74 value = Fprevious_single_property_change (make_int (pos), Qinvisible,
|
|
|
75 buffer, Qnil);
|
|
|
76 if (NILP (value))
|
|
|
77 return 0; /* no visible position found */
|
|
|
78 else
|
|
|
79 /* #### bug bug bug!!! This will return the position of the beginning
|
|
|
80 of an invisible extent; this extent is very likely to be start-closed,
|
|
|
81 and thus the spaces inserted in `indent-to' will go inside the
|
|
|
82 invisible extent.
|
|
|
83
|
|
|
84 Not sure what the correct solution is here. Rethink indent-to? */
|
|
|
85 return XINT (value);
|
|
|
86 }
|
|
|
87
|
|
|
88 #ifdef REGION_CACHE_NEEDS_WORK
|
|
|
89
|
|
|
90 /* Allocate or free the width run cache, as requested by the current
|
|
|
91 state of current_buffer's cache_long_line_scans variable. */
|
|
|
92 static void
|
|
|
93 width_run_cache_on_off (struct buffer *buf)
|
|
|
94 {
|
|
|
95 if (NILP (buf->cache_long_line_scans))
|
|
|
96 {
|
|
|
97 /* It should be off. */
|
|
|
98 if (buf->width_run_cache)
|
|
|
99 {
|
|
|
100 free_region_cache (buf->width_run_cache);
|
|
|
101 buf->width_run_cache = 0;
|
|
|
102 buf->width_table = Qnil;
|
|
|
103 }
|
|
|
104 }
|
|
|
105 else
|
|
|
106 {
|
|
|
107 /* It should be on. */
|
|
|
108 if (buf->width_run_cache == 0)
|
|
|
109 {
|
|
|
110 buf->width_run_cache = new_region_cache ();
|
|
|
111 recompute_width_table (buf, buffer_display_table ());
|
|
|
112 }
|
|
|
113 }
|
|
|
114 }
|
|
|
115
|
|
|
116 #endif /* REGION_CACHE_NEEDS_WORK */
|
|
|
117
|
|
|
118
|
|
|
119 /* Cancel any recorded value of the horizontal position. */
|
|
|
120
|
|
|
121 void
|
|
|
122 invalidate_current_column (void)
|
|
|
123 {
|
|
|
124 last_known_column_point = -1;
|
|
|
125 }
|
|
|
126
|
|
|
127 int
|
|
665
|
128 column_at_point (struct buffer *buf, Charbpos init_pos, int cur_col)
|
|
428
|
129 {
|
|
|
130 int col;
|
|
|
131 int tab_seen;
|
|
|
132 int tab_width = XINT (buf->tab_width);
|
|
|
133 int post_tab;
|
|
665
|
134 Charbpos pos = init_pos;
|
|
867
|
135 Ichar c;
|
|
428
|
136
|
|
|
137 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
|
|
|
138 col = tab_seen = post_tab = 0;
|
|
|
139
|
|
|
140 while (1)
|
|
|
141 {
|
|
|
142 if (pos <= BUF_BEGV (buf))
|
|
|
143 break;
|
|
|
144
|
|
|
145 pos--;
|
|
|
146 c = BUF_FETCH_CHAR (buf, pos);
|
|
|
147 if (c == '\t')
|
|
|
148 {
|
|
|
149 if (tab_seen)
|
|
|
150 col = ((col + tab_width) / tab_width) * tab_width;
|
|
|
151
|
|
|
152 post_tab += col;
|
|
|
153 col = 0;
|
|
|
154 tab_seen = 1;
|
|
|
155 }
|
|
|
156 else if (c == '\n' ||
|
|
|
157 (EQ (buf->selective_display, Qt) && c == '\r'))
|
|
|
158 break;
|
|
|
159 else
|
|
|
160 {
|
|
|
161 /* #### This needs updating to handle the new redisplay. */
|
|
|
162 /* #### FSFmacs looks at ctl_arrow, display tables.
|
|
|
163 We need to do similar. */
|
|
|
164 #if 0
|
|
665
|
165 displayed_glyphs = glyphs_from_charbpos (sel_frame, buf,
|
|
428
|
166 XWINDOW (selected_window),
|
|
|
167 pos, dp, 0, col, 0, 0, 0);
|
|
|
168 col += (displayed_glyphs->columns
|
|
|
169 - (displayed_glyphs->begin_columns
|
|
|
170 + displayed_glyphs->end_columns));
|
|
|
171 #else /* XEmacs */
|
|
|
172 #ifdef MULE
|
|
867
|
173 col += XCHARSET_COLUMNS (ichar_charset (c));
|
|
428
|
174 #else
|
|
|
175 col ++;
|
|
|
176 #endif /* MULE */
|
|
|
177 #endif /* XEmacs */
|
|
|
178 }
|
|
|
179 }
|
|
|
180
|
|
|
181 if (tab_seen)
|
|
|
182 {
|
|
|
183 col = ((col + tab_width) / tab_width) * tab_width;
|
|
|
184 col += post_tab;
|
|
|
185 }
|
|
|
186
|
|
|
187 if (cur_col)
|
|
|
188 {
|
|
|
189 last_known_column_buffer = buf;
|
|
|
190 last_known_column = col;
|
|
|
191 last_known_column_point = init_pos;
|
|
|
192 last_known_column_modified = BUF_MODIFF (buf);
|
|
|
193 }
|
|
|
194
|
|
|
195 return col;
|
|
|
196 }
|
|
|
197
|
|
|
198 int
|
|
793
|
199 string_column_at_point (Lisp_Object s, Charbpos init_pos, int tab_width)
|
|
428
|
200 {
|
|
|
201 int col;
|
|
|
202 int tab_seen;
|
|
|
203 int post_tab;
|
|
665
|
204 Charbpos pos = init_pos;
|
|
867
|
205 Ichar c;
|
|
428
|
206
|
|
|
207 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
|
|
|
208 col = tab_seen = post_tab = 0;
|
|
|
209
|
|
|
210 while (1)
|
|
|
211 {
|
|
|
212 if (pos <= 0)
|
|
|
213 break;
|
|
|
214
|
|
|
215 pos--;
|
|
867
|
216 c = string_ichar (s, pos);
|
|
428
|
217 if (c == '\t')
|
|
|
218 {
|
|
|
219 if (tab_seen)
|
|
|
220 col = ((col + tab_width) / tab_width) * tab_width;
|
|
|
221
|
|
|
222 post_tab += col;
|
|
|
223 col = 0;
|
|
|
224 tab_seen = 1;
|
|
|
225 }
|
|
|
226 else if (c == '\n')
|
|
|
227 break;
|
|
|
228 else
|
|
|
229 #ifdef MULE
|
|
867
|
230 col += XCHARSET_COLUMNS (ichar_charset (c));
|
|
428
|
231 #else
|
|
|
232 col ++;
|
|
|
233 #endif /* MULE */
|
|
|
234 }
|
|
|
235
|
|
|
236 if (tab_seen)
|
|
|
237 {
|
|
|
238 col = ((col + tab_width) / tab_width) * tab_width;
|
|
|
239 col += post_tab;
|
|
|
240 }
|
|
|
241
|
|
|
242 return col;
|
|
|
243 }
|
|
|
244
|
|
|
245 int
|
|
|
246 current_column (struct buffer *buf)
|
|
|
247 {
|
|
|
248 if (buf == last_known_column_buffer
|
|
|
249 && BUF_PT (buf) == last_known_column_point
|
|
|
250 && BUF_MODIFF (buf) == last_known_column_modified)
|
|
|
251 return last_known_column;
|
|
|
252
|
|
|
253 return column_at_point (buf, BUF_PT (buf), 1);
|
|
|
254 }
|
|
|
255
|
|
|
256 DEFUN ("current-column", Fcurrent_column, 0, 1, 0, /*
|
|
|
257 Return the horizontal position of point. Beginning of line is column 0.
|
|
|
258 This is calculated by adding together the widths of all the displayed
|
|
|
259 representations of the character between the start of the previous line
|
|
|
260 and point. (e.g. control characters will have a width of 2 or 4, tabs
|
|
|
261 will have a variable width.)
|
|
|
262 Ignores finite width of frame, which means that this function may return
|
|
|
263 values greater than (frame-width).
|
|
|
264 Whether the line is visible (if `selective-display' is t) has no effect;
|
|
|
265 however, ^M is treated as end of line when `selective-display' is t.
|
|
|
266 If BUFFER is nil, the current buffer is assumed.
|
|
|
267 */
|
|
|
268 (buffer))
|
|
|
269 {
|
|
|
270 return make_int (current_column (decode_buffer (buffer, 0)));
|
|
|
271 }
|
|
|
272
|
|
|
273
|
|
|
274 DEFUN ("indent-to", Findent_to, 1, 3, "NIndent to column: ", /*
|
|
|
275 Indent from point with tabs and spaces until COLUMN is reached.
|
|
444
|
276 Optional second argument MINIMUM says always do at least MINIMUM spaces
|
|
|
277 even if that goes past COLUMN; by default, MINIMUM is zero.
|
|
428
|
278 If BUFFER is nil, the current buffer is assumed.
|
|
|
279 */
|
|
444
|
280 (column, minimum, buffer))
|
|
428
|
281 {
|
|
|
282 /* This function can GC */
|
|
|
283 int mincol;
|
|
|
284 int fromcol;
|
|
|
285 struct buffer *buf = decode_buffer (buffer, 0);
|
|
|
286 int tab_width = XINT (buf->tab_width);
|
|
665
|
287 Charbpos opoint = 0;
|
|
428
|
288
|
|
444
|
289 CHECK_INT (column);
|
|
428
|
290 if (NILP (minimum))
|
|
|
291 minimum = Qzero;
|
|
|
292 else
|
|
|
293 CHECK_INT (minimum);
|
|
|
294
|
|
793
|
295 buffer = wrap_buffer (buf);
|
|
428
|
296
|
|
|
297 fromcol = current_column (buf);
|
|
|
298 mincol = fromcol + XINT (minimum);
|
|
444
|
299 if (mincol < XINT (column)) mincol = XINT (column);
|
|
428
|
300
|
|
|
301 if (fromcol == mincol)
|
|
|
302 return make_int (mincol);
|
|
|
303
|
|
|
304 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
|
|
|
305
|
|
|
306 if (!NILP (Fextent_at (make_int (BUF_PT (buf)), buffer, Qinvisible,
|
|
|
307 Qnil, Qnil)))
|
|
|
308 {
|
|
665
|
309 Charbpos last_visible = last_visible_position (BUF_PT (buf), buf);
|
|
428
|
310
|
|
|
311 opoint = BUF_PT (buf);
|
|
|
312 if (last_visible >= BUF_BEGV (buf))
|
|
|
313 BUF_SET_PT (buf, last_visible);
|
|
|
314 else
|
|
563
|
315 invalid_operation ("Visible portion of buffer not modifiable", Qunbound);
|
|
428
|
316 }
|
|
|
317
|
|
|
318 if (indent_tabs_mode)
|
|
|
319 {
|
|
|
320 int n = mincol / tab_width - fromcol / tab_width;
|
|
|
321 if (n != 0)
|
|
|
322 {
|
|
|
323 Finsert_char (make_char ('\t'), make_int (n), Qnil, buffer);
|
|
|
324
|
|
|
325 fromcol = (mincol / tab_width) * tab_width;
|
|
|
326 }
|
|
|
327 }
|
|
|
328
|
|
|
329 Finsert_char (make_char (' '), make_int (mincol - fromcol), Qnil, buffer);
|
|
|
330
|
|
|
331 last_known_column_buffer = buf;
|
|
|
332 last_known_column = mincol;
|
|
|
333 last_known_column_point = BUF_PT (buf);
|
|
|
334 last_known_column_modified = BUF_MODIFF (buf);
|
|
|
335
|
|
|
336 /* Not in FSF: */
|
|
|
337 if (opoint > 0)
|
|
|
338 BUF_SET_PT (buf, opoint);
|
|
|
339
|
|
|
340 return make_int (mincol);
|
|
|
341 }
|
|
|
342
|
|
|
343 int
|
|
826
|
344 byte_spaces_at_point (struct buffer *b, Bytebpos byte_pos)
|
|
428
|
345 {
|
|
826
|
346 Bytebpos byte_end = BYTE_BUF_ZV (b);
|
|
428
|
347 int col = 0;
|
|
867
|
348 Ichar c;
|
|
428
|
349 int tab_width = XINT (b->tab_width);
|
|
|
350
|
|
|
351 if (tab_width <= 0 || tab_width > 1000)
|
|
|
352 tab_width = 8;
|
|
|
353
|
|
826
|
354 while (byte_pos < byte_end &&
|
|
|
355 (c = BYTE_BUF_FETCH_CHAR (b, byte_pos),
|
|
428
|
356 (c == '\t'
|
|
|
357 ? (col += tab_width - col % tab_width)
|
|
|
358 : (c == ' ' ? ++col : 0))))
|
|
826
|
359 INC_BYTEBPOS (b, byte_pos);
|
|
428
|
360
|
|
|
361 return col;
|
|
|
362 }
|
|
|
363
|
|
|
364
|
|
|
365 DEFUN ("current-indentation", Fcurrent_indentation, 0, 1, 0, /*
|
|
|
366 Return the indentation of the current line.
|
|
|
367 This is the horizontal position of the character
|
|
|
368 following any initial whitespace.
|
|
|
369 */
|
|
|
370 (buffer))
|
|
|
371 {
|
|
|
372 struct buffer *buf = decode_buffer (buffer, 0);
|
|
665
|
373 Charbpos pos = find_next_newline (buf, BUF_PT (buf), -1);
|
|
428
|
374
|
|
793
|
375 buffer = wrap_buffer (buf);
|
|
428
|
376
|
|
|
377 if (!NILP (Fextent_at (make_int (pos), buffer, Qinvisible, Qnil, Qnil)))
|
|
|
378 return Qzero;
|
|
|
379
|
|
826
|
380 return make_int (byte_spaces_at_point (buf, charbpos_to_bytebpos (buf, pos)));
|
|
428
|
381 }
|
|
|
382
|
|
|
383
|
|
|
384 DEFUN ("move-to-column", Fmove_to_column, 1, 3, 0, /*
|
|
|
385 Move point to column COLUMN in the current line.
|
|
|
386 The column of a character is calculated by adding together the widths
|
|
|
387 as displayed of the previous characters in the line.
|
|
|
388 This function ignores line-continuation;
|
|
|
389 there is no upper limit on the column number a character can have
|
|
|
390 and horizontal scrolling has no effect.
|
|
|
391
|
|
|
392 If specified column is within a character, point goes after that character.
|
|
|
393 If it's past end of line, point goes to end of line.
|
|
|
394
|
|
|
395 A value of 'coerce for the second (optional) argument FORCE means if
|
|
|
396 COLUMN is in the middle of a tab character, change it to spaces.
|
|
|
397 Any other non-nil value means the same, plus if the line is too short to
|
|
|
398 reach column COLUMN, then add spaces/tabs to get there.
|
|
|
399
|
|
|
400 Returns the actual column that it moved to.
|
|
|
401 */
|
|
|
402 (column, force, buffer))
|
|
|
403 {
|
|
|
404 /* This function can GC */
|
|
665
|
405 Charbpos pos;
|
|
428
|
406 struct buffer *buf = decode_buffer (buffer, 0);
|
|
|
407 int col = current_column (buf);
|
|
|
408 int goal;
|
|
665
|
409 Charbpos end;
|
|
428
|
410 int tab_width = XINT (buf->tab_width);
|
|
|
411
|
|
|
412 int prev_col = 0;
|
|
867
|
413 Ichar c = 0;
|
|
428
|
414
|
|
793
|
415 buffer = wrap_buffer (buf);
|
|
428
|
416 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
|
|
|
417 CHECK_NATNUM (column);
|
|
|
418 goal = XINT (column);
|
|
|
419
|
|
|
420 retry:
|
|
|
421 pos = BUF_PT (buf);
|
|
|
422 end = BUF_ZV (buf);
|
|
|
423
|
|
|
424 /* If we're starting past the desired column,
|
|
|
425 back up to beginning of line and scan from there. */
|
|
|
426 if (col > goal)
|
|
|
427 {
|
|
|
428 pos = find_next_newline (buf, pos, -1);
|
|
|
429 col = 0;
|
|
|
430 }
|
|
|
431
|
|
|
432 while (col < goal && pos < end)
|
|
|
433 {
|
|
|
434 c = BUF_FETCH_CHAR (buf, pos);
|
|
|
435 if (c == '\n')
|
|
|
436 break;
|
|
|
437 if (c == '\r' && EQ (buf->selective_display, Qt))
|
|
|
438 break;
|
|
|
439 if (c == '\t')
|
|
|
440 {
|
|
|
441 prev_col = col;
|
|
|
442 col += tab_width;
|
|
|
443 col = col / tab_width * tab_width;
|
|
|
444 }
|
|
|
445 else
|
|
|
446 {
|
|
|
447 /* #### oh for the days of the complete new redisplay */
|
|
|
448 /* #### FSFmacs looks at ctl_arrow, display tables.
|
|
|
449 We need to do similar. */
|
|
|
450 #if 0
|
|
665
|
451 displayed_glyphs = glyphs_from_charbpos (selected_frame (),
|
|
428
|
452 buf,
|
|
|
453 XWINDOW (Fselected_window (Qnil)),
|
|
|
454 pos, dp, 0, col, 0, 0, 0);
|
|
|
455 col += (displayed_glyphs->columns
|
|
|
456 - (displayed_glyphs->begin_columns
|
|
|
457 + displayed_glyphs->end_columns));
|
|
|
458 #else /* XEmacs */
|
|
|
459 #ifdef MULE
|
|
867
|
460 col += XCHARSET_COLUMNS (ichar_charset (c));
|
|
428
|
461 #else
|
|
|
462 col ++;
|
|
|
463 #endif /* MULE */
|
|
|
464 #endif /* XEmacs */
|
|
|
465 }
|
|
|
466
|
|
|
467 pos++;
|
|
|
468 }
|
|
|
469
|
|
|
470 BUF_SET_PT (buf, pos);
|
|
|
471
|
|
|
472 /* If a tab char made us overshoot, change it to spaces
|
|
|
473 and scan through it again. */
|
|
|
474 if (!NILP (force) && col > goal && c == '\t' && prev_col < goal)
|
|
|
475 {
|
|
|
476 buffer_delete_range (buf, BUF_PT (buf) - 1, BUF_PT (buf), 0);
|
|
|
477 Findent_to (make_int (col - 1), Qzero, buffer);
|
|
|
478 buffer_insert_emacs_char (buf, ' ');
|
|
|
479 goto retry;
|
|
|
480 }
|
|
|
481
|
|
|
482 /* If line ends prematurely, add space to the end. */
|
|
|
483 if (col < goal && !NILP (force) && !EQ (force, Qcoerce))
|
|
|
484 {
|
|
|
485 col = goal;
|
|
|
486 Findent_to (make_int (col), Qzero, buffer);
|
|
|
487 }
|
|
|
488
|
|
|
489 last_known_column_buffer = buf;
|
|
|
490 last_known_column = col;
|
|
|
491 last_known_column_point = BUF_PT (buf);
|
|
|
492 last_known_column_modified = BUF_MODIFF (buf);
|
|
|
493
|
|
|
494 return make_int (col);
|
|
|
495 }
|
|
|
496
|
|
|
497 #if 0 /* #### OK boys, this function needs to be present, I think.
|
|
|
498 It was there before the 19.12 redisplay rewrite. */
|
|
|
499
|
|
826
|
500 DEFUN ("compute-motion", Fcompute_motion, 7, 7, 0, /*
|
|
428
|
501 "Scan through the current buffer, calculating screen position.
|
|
|
502 Scan the current buffer forward from offset FROM,
|
|
|
503 assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)--
|
|
|
504 to position TO or position TOPOS--another cons of the form (HPOS . VPOS)--
|
|
|
505 and return the ending buffer position and screen location.
|
|
|
506
|
|
|
507 There are three additional arguments:
|
|
|
508
|
|
|
509 WIDTH is the number of columns available to display text;
|
|
|
510 this affects handling of continuation lines.
|
|
|
511 This is usually the value returned by `window-width', less one (to allow
|
|
|
512 for the continuation glyph).
|
|
|
513
|
|
|
514 OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET).
|
|
|
515 HSCROLL is the number of columns not being displayed at the left
|
|
|
516 margin; this is usually taken from a window's hscroll member.
|
|
|
517 TAB-OFFSET is the number of columns of the first tab that aren't
|
|
|
518 being displayed, perhaps because the line was continued within it.
|
|
|
519 If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.
|
|
|
520
|
|
|
521 WINDOW is the window to operate on. Currently this is used only to
|
|
|
522 find the display table. It does not matter what buffer WINDOW displays;
|
|
|
523 `compute-motion' always operates on the current buffer.
|
|
|
524
|
|
|
525 The value is a list of five elements:
|
|
|
526 (POS HPOS VPOS PREVHPOS CONTIN)
|
|
|
527 POS is the buffer position where the scan stopped.
|
|
|
528 VPOS is the vertical position where the scan stopped.
|
|
|
529 HPOS is the horizontal position where the scan stopped.
|
|
|
530
|
|
|
531 PREVHPOS is the horizontal position one character back from POS.
|
|
|
532 CONTIN is t if a line was continued after (or within) the previous character.
|
|
|
533
|
|
|
534 For example, to find the buffer position of column COL of line LINE
|
|
|
535 of a certain window, pass the window's starting location as FROM
|
|
|
536 and the window's upper-left coordinates as FROMPOS.
|
|
|
537 Pass the buffer's (point-max) as TO, to limit the scan to the end of the
|
|
|
538 visible section of the buffer, and pass LINE and COL as TOPOS.
|
|
|
539 */
|
|
|
540 (from, frompos, to, topos, width, offsets, window))
|
|
|
541 {
|
|
665
|
542 Lisp_Object charbpos, hpos, vpos, prevhpos, contin;
|
|
428
|
543 struct position *pos;
|
|
|
544 int hscroll, tab_offset;
|
|
|
545 struct window *w = decode_window (window);
|
|
|
546
|
|
|
547 CHECK_INT_COERCE_MARKER (from);
|
|
|
548 CHECK_CONS (frompos);
|
|
|
549 CHECK_INT (XCAR (frompos));
|
|
|
550 CHECK_INT (XCDR (frompos));
|
|
|
551 CHECK_INT_COERCE_MARKER (to);
|
|
|
552 CHECK_CONS (topos);
|
|
|
553 CHECK_INT (XCAR (topos));
|
|
|
554 CHECK_INT (XCDR (topos));
|
|
|
555 CHECK_INT (width);
|
|
|
556 if (!NILP (offsets))
|
|
|
557 {
|
|
|
558 CHECK_CONS (offsets);
|
|
|
559 CHECK_INT (XCAR (offsets));
|
|
|
560 CHECK_INT (XCDR (offsets));
|
|
|
561 hscroll = XINT (XCAR (offsets));
|
|
|
562 tab_offset = XINT (XCDR (offsets));
|
|
|
563 }
|
|
|
564 else
|
|
|
565 hscroll = tab_offset = 0;
|
|
|
566
|
|
|
567 pos = compute_motion (XINT (from), XINT (XCDR (frompos)),
|
|
|
568 XINT (XCAR (frompos)),
|
|
|
569 XINT (to), XINT (XCDR (topos)),
|
|
|
570 XINT (XCAR (topos)),
|
|
|
571 XINT (width), hscroll, tab_offset, w);
|
|
|
572
|
|
793
|
573 charbpos = make_int (pos->charbpos);
|
|
|
574 hpos = make_int (pos->hpos);
|
|
|
575 vpos = make_int (pos->vpos);
|
|
|
576 prevhpos = make_int (pos->prevhpos);
|
|
428
|
577
|
|
665
|
578 return list5 (charbpos, hpos, vpos, prevhpos,
|
|
428
|
579 pos->contin ? Qt : Qnil);
|
|
|
580 }
|
|
|
581
|
|
|
582 #endif /* 0 */
|
|
|
583
|
|
|
584 /* Helper for vmotion_1 - compute vertical pixel motion between
|
|
|
585 START and END in the line start cache CACHE. This just sums
|
|
|
586 the line heights, including both the starting and ending lines.
|
|
|
587 */
|
|
|
588 static int
|
|
|
589 vpix_motion (line_start_cache_dynarr *cache, int start, int end)
|
|
|
590 {
|
|
|
591 int i, vpix;
|
|
|
592
|
|
|
593 assert (start <= end);
|
|
|
594 assert (start >= 0);
|
|
|
595 assert (end < Dynarr_length (cache));
|
|
|
596
|
|
|
597 vpix = 0;
|
|
|
598 for (i = start; i <= end; i++)
|
|
|
599 vpix += Dynarr_atp (cache, i)->height;
|
|
|
600
|
|
|
601 return vpix;
|
|
|
602 }
|
|
|
603
|
|
|
604 /*****************************************************************************
|
|
|
605 vmotion_1
|
|
|
606
|
|
|
607 Given a starting position ORIG, move point VTARGET lines in WINDOW.
|
|
|
608 Returns the new value for point. If the arg ret_vpos is not nil, it is
|
|
|
609 taken to be a pointer to an int and the number of lines actually moved is
|
|
|
610 returned in it. If the arg ret_vpix is not nil, it is taken to be a
|
|
|
611 pointer to an int and the vertical pixel height of the motion which
|
|
|
612 took place is returned in it.
|
|
|
613 ****************************************************************************/
|
|
665
|
614 static Charbpos
|
|
|
615 vmotion_1 (struct window *w, Charbpos orig, int vtarget,
|
|
428
|
616 int *ret_vpos, int *ret_vpix)
|
|
|
617 {
|
|
|
618 struct buffer *b = XBUFFER (w->buffer);
|
|
|
619 int elt;
|
|
|
620
|
|
|
621 elt = point_in_line_start_cache (w, orig, (vtarget < 0
|
|
|
622 ? -vtarget
|
|
|
623 : vtarget));
|
|
|
624
|
|
|
625 /* #### This assertion must be true before the if statements are hit
|
|
|
626 but may possibly be wrong after the call to
|
|
|
627 point_in_line_start_cache if orig is outside of the visible
|
|
|
628 region of the buffer. Handle this. */
|
|
|
629 assert (elt >= 0);
|
|
|
630
|
|
|
631 /* Moving downward. */
|
|
|
632 if (vtarget > 0)
|
|
|
633 {
|
|
|
634 int cur_line = Dynarr_length (w->line_start_cache) - 1 - elt;
|
|
665
|
635 Charbpos ret_pt;
|
|
428
|
636
|
|
|
637 if (cur_line > vtarget)
|
|
|
638 cur_line = vtarget;
|
|
|
639
|
|
|
640 /* The traditional FSF behavior is to return the end of buffer
|
|
|
641 position if we couldn't move far enough because we hit it. */
|
|
|
642 if (cur_line < vtarget)
|
|
|
643 ret_pt = BUF_ZV (b);
|
|
|
644 else
|
|
|
645 ret_pt = Dynarr_atp (w->line_start_cache, cur_line + elt)->start;
|
|
|
646
|
|
|
647 while (ret_pt > BUF_ZV (b) && cur_line > 0)
|
|
|
648 {
|
|
|
649 cur_line--;
|
|
|
650 ret_pt = Dynarr_atp (w->line_start_cache, cur_line + elt)->start;
|
|
|
651 }
|
|
|
652
|
|
|
653 if (ret_vpos) *ret_vpos = cur_line;
|
|
|
654 if (ret_vpix)
|
|
|
655 *ret_vpix = vpix_motion (w->line_start_cache, elt, cur_line + elt);
|
|
|
656 return ret_pt;
|
|
|
657 }
|
|
|
658 else if (vtarget < 0)
|
|
|
659 {
|
|
|
660 if (elt < -vtarget)
|
|
|
661 {
|
|
|
662 if (ret_vpos) *ret_vpos = -elt;
|
|
|
663 if (ret_vpix)
|
|
|
664 *ret_vpix = vpix_motion (w->line_start_cache, 0, elt);
|
|
|
665 /* #### This should be BUF_BEGV (b), right? */
|
|
|
666 return Dynarr_atp (w->line_start_cache, 0)->start;
|
|
|
667 }
|
|
|
668 else
|
|
|
669 {
|
|
|
670 if (ret_vpos) *ret_vpos = vtarget;
|
|
|
671 if (ret_vpix)
|
|
|
672 *ret_vpix = vpix_motion (w->line_start_cache, elt + vtarget, elt);
|
|
|
673 return Dynarr_atp (w->line_start_cache, elt + vtarget)->start;
|
|
|
674 }
|
|
|
675 }
|
|
|
676 else
|
|
|
677 {
|
|
|
678 /* No vertical motion requested so we just return the position
|
|
|
679 of the beginning of the current line. */
|
|
|
680 if (ret_vpos) *ret_vpos = 0;
|
|
|
681 if (ret_vpix)
|
|
|
682 *ret_vpix = vpix_motion (w->line_start_cache, elt, elt);
|
|
|
683
|
|
|
684 return Dynarr_atp (w->line_start_cache, elt)->start;
|
|
|
685 }
|
|
|
686
|
|
1204
|
687 RETURN_NOT_REACHED(0); /* shut up compiler */
|
|
428
|
688 }
|
|
|
689
|
|
|
690 /*****************************************************************************
|
|
|
691 vmotion
|
|
|
692
|
|
|
693 Given a starting position ORIG, move point VTARGET lines in WINDOW.
|
|
|
694 Returns the new value for point. If the arg ret_vpos is not nil, it is
|
|
|
695 taken to be a pointer to an int and the number of lines actually moved is
|
|
|
696 returned in it.
|
|
|
697 ****************************************************************************/
|
|
665
|
698 Charbpos
|
|
|
699 vmotion (struct window *w, Charbpos orig, int vtarget, int *ret_vpos)
|
|
428
|
700 {
|
|
|
701 return vmotion_1 (w, orig, vtarget, ret_vpos, NULL);
|
|
|
702 }
|
|
|
703
|
|
|
704 /* Helper for Fvertical_motion.
|
|
|
705 */
|
|
|
706 static
|
|
|
707 Lisp_Object vertical_motion_1 (Lisp_Object lines, Lisp_Object window,
|
|
|
708 int pixels)
|
|
|
709 {
|
|
665
|
710 Charbpos charbpos;
|
|
|
711 Charbpos orig;
|
|
428
|
712 int selected;
|
|
|
713 int *vpos, *vpix;
|
|
|
714 int value=0;
|
|
|
715 struct window *w;
|
|
|
716
|
|
|
717 if (NILP (window))
|
|
|
718 window = Fselected_window (Qnil);
|
|
|
719
|
|
|
720 CHECK_LIVE_WINDOW (window);
|
|
|
721 CHECK_INT (lines);
|
|
|
722
|
|
|
723 selected = (EQ (window, Fselected_window (Qnil)));
|
|
|
724
|
|
|
725 w = XWINDOW (window);
|
|
|
726
|
|
|
727 orig = selected ? BUF_PT (XBUFFER (w->buffer))
|
|
|
728 : marker_position (w->pointm[CURRENT_DISP]);
|
|
|
729
|
|
|
730 vpos = pixels ? NULL : &value;
|
|
|
731 vpix = pixels ? &value : NULL;
|
|
|
732
|
|
665
|
733 charbpos = vmotion_1 (w, orig, XINT (lines), vpos, vpix);
|
|
428
|
734
|
|
|
735 /* Note that the buffer's point is set, not the window's point. */
|
|
|
736 if (selected)
|
|
665
|
737 BUF_SET_PT (XBUFFER (w->buffer), charbpos);
|
|
428
|
738 else
|
|
|
739 set_marker_restricted (w->pointm[CURRENT_DISP],
|
|
665
|
740 make_int(charbpos),
|
|
428
|
741 w->buffer);
|
|
|
742
|
|
|
743 return make_int (value);
|
|
|
744 }
|
|
|
745
|
|
|
746 DEFUN ("vertical-motion", Fvertical_motion, 1, 3, 0, /*
|
|
|
747 Move to start of frame line LINES lines down.
|
|
|
748 If LINES is negative, this is moving up.
|
|
|
749 Optional second argument is WINDOW to move in,
|
|
|
750 the default is the selected window.
|
|
|
751
|
|
|
752 Sets point to position found; this may be start of line
|
|
|
753 or just the start of a continuation line.
|
|
|
754 If optional third argument PIXELS is nil, returns number
|
|
|
755 of lines moved; may be closer to zero than LINES if beginning
|
|
|
756 or end of buffer was reached. If PIXELS is non-nil, the
|
|
|
757 vertical pixel height of the motion which took place is
|
|
|
758 returned instead of the actual number of lines moved. A
|
|
|
759 motion of zero lines returns the height of the current line.
|
|
|
760
|
|
1268
|
761 NOTE NOTE NOTE: GNU Emacs/XEmacs difference.
|
|
|
762
|
|
|
763 What `vertical-motion' actually does is set WINDOW's buffer's point
|
|
|
764 if WINDOW is the selected window; else, it sets WINDOW's point.
|
|
|
765 This is unfortunately somewhat tricky to work with, and different
|
|
|
766 from GNU Emacs, which always uses the current buffer, not WINDOW's
|
|
|
767 buffer, always sets current buffer's point, and, from the
|
|
|
768 perspective of this function, temporarily makes WINDOW display
|
|
|
769 the current buffer if it wasn't already.
|
|
428
|
770 */
|
|
|
771 (lines, window, pixels))
|
|
|
772 {
|
|
|
773 return vertical_motion_1 (lines, window, !NILP (pixels));
|
|
|
774 }
|
|
|
775
|
|
|
776 /*
|
|
|
777 * Like vmotion() but requested and returned movement is in pixels.
|
|
|
778 * HOW specifies the stopping condition. Positive means move at least
|
|
|
779 * PIXELS. Negative means at most. Zero means as close as possible.
|
|
|
780 */
|
|
665
|
781 Charbpos
|
|
|
782 vmotion_pixels (Lisp_Object window, Charbpos start, int pixels, int how,
|
|
428
|
783 int *motion)
|
|
|
784 {
|
|
|
785 struct window *w;
|
|
665
|
786 Charbpos eobuf, bobuf;
|
|
428
|
787 int defheight;
|
|
|
788 int needed;
|
|
|
789 int line, next;
|
|
|
790 int remain, abspix, dirn;
|
|
|
791 int elt, nelt;
|
|
|
792 int i;
|
|
|
793 line_start_cache_dynarr *cache;
|
|
|
794 int previous = -1;
|
|
|
795 int lines;
|
|
|
796
|
|
|
797 if (NILP (window))
|
|
|
798 window = Fselected_window (Qnil);
|
|
|
799
|
|
|
800 CHECK_LIVE_WINDOW (window);
|
|
|
801 w = XWINDOW (window);
|
|
|
802
|
|
|
803 eobuf = BUF_ZV (XBUFFER (w->buffer));
|
|
|
804 bobuf = BUF_BEGV (XBUFFER (w->buffer));
|
|
|
805
|
|
|
806 default_face_height_and_width (window, &defheight, NULL);
|
|
|
807
|
|
|
808 /* guess num lines needed in line start cache + a few extra */
|
|
|
809 abspix = abs (pixels);
|
|
|
810 needed = (abspix + defheight-1)/defheight + 3;
|
|
|
811
|
|
|
812 dirn = (pixels >= 0) ? 1 : -1;
|
|
|
813
|
|
|
814 while (1)
|
|
|
815 {
|
|
|
816 elt = point_in_line_start_cache (w, start, needed);
|
|
|
817 assert (elt >= 0); /* in the cache */
|
|
|
818
|
|
|
819 cache = w->line_start_cache;
|
|
|
820 nelt = Dynarr_length (cache);
|
|
|
821
|
|
|
822 *motion = 0;
|
|
|
823
|
|
|
824 if (pixels == 0)
|
|
|
825 /* No vertical motion requested so we just return the position
|
|
|
826 of the beginning of the current display line. */
|
|
|
827 return Dynarr_atp (cache, elt)->start;
|
|
|
828
|
|
|
829 if ((dirn < 0 && elt == 0 &&
|
|
|
830 Dynarr_atp (cache, elt)->start <= bobuf) ||
|
|
|
831 (dirn > 0 && elt == nelt-1 &&
|
|
|
832 Dynarr_atp (cache, elt)->end >= eobuf))
|
|
|
833 return Dynarr_atp (cache, elt)->start;
|
|
|
834
|
|
|
835 remain = abspix;
|
|
|
836 for (i = elt; (dirn > 0) ? (i < nelt) : (i > 0); i += dirn)
|
|
|
837 {
|
|
|
838 /* cache line we're considering moving over */
|
|
|
839 int ii = (dirn > 0) ? i : i-1;
|
|
|
840
|
|
|
841 if (remain < 0)
|
|
|
842 return Dynarr_atp (cache, i)->start;
|
|
|
843
|
|
|
844 line = Dynarr_atp (cache, ii)->height;
|
|
|
845 next = remain - line;
|
|
|
846
|
|
|
847 /* is stopping condition satisfied? */
|
|
|
848 if ((how > 0 && remain <= 0) || /* at least */
|
|
|
849 (how < 0 && next < 0) || /* at most */
|
|
|
850 (how == 0 && remain <= abs (next))) /* closest */
|
|
|
851 return Dynarr_atp (cache, i)->start;
|
|
|
852
|
|
|
853 /* moving down and nowhere left to go? */
|
|
|
854 if (dirn > 0 && Dynarr_atp (cache, ii)->end >= eobuf)
|
|
|
855 return Dynarr_atp (cache, ii)->start;
|
|
|
856
|
|
|
857 /* take the step */
|
|
|
858 remain = next;
|
|
|
859 *motion += dirn * line;
|
|
|
860
|
|
|
861 /* moving up and nowhere left to go? */
|
|
|
862 if (dirn < 0 && Dynarr_atp (cache, ii)->start <= bobuf)
|
|
|
863 return Dynarr_atp (cache, ii)->start;
|
|
|
864 }
|
|
|
865
|
|
|
866 /* get here => need more cache lines. try again. */
|
|
|
867 assert (abs (*motion) > previous); /* progress? */
|
|
|
868 previous = abs (*motion);
|
|
|
869
|
|
|
870 lines = (pixels < 0) ? elt : (nelt - elt);
|
|
|
871 needed += (remain*lines + abspix-1)/abspix + 3;
|
|
|
872 }
|
|
|
873
|
|
1204
|
874 RETURN_NOT_REACHED(0); /* shut up compiler */
|
|
428
|
875 }
|
|
|
876
|
|
|
877 DEFUN ("vertical-motion-pixels", Fvertical_motion_pixels, 1, 3, 0, /*
|
|
|
878 Move to start of frame line PIXELS vertical pixels down.
|
|
|
879 If PIXELS is negative, this is moving up.
|
|
|
880 The actual vertical motion in pixels is returned.
|
|
|
881
|
|
|
882 Optional second argument is WINDOW to move in,
|
|
|
883 the default is the selected window.
|
|
|
884
|
|
|
885 Optional third argument HOW specifies when to stop. A value
|
|
|
886 less than zero indicates that the motion should be no more
|
|
|
887 than PIXELS. A value greater than zero indicates that the
|
|
|
888 motion should be at least PIXELS. Any other value indicates
|
|
|
889 that the motion should be as close as possible to PIXELS.
|
|
|
890 */
|
|
|
891 (pixels, window, how))
|
|
|
892 {
|
|
665
|
893 Charbpos charbpos;
|
|
|
894 Charbpos orig;
|
|
428
|
895 int selected;
|
|
|
896 int motion;
|
|
|
897 int howto;
|
|
|
898 struct window *w;
|
|
|
899
|
|
|
900 if (NILP (window))
|
|
|
901 window = Fselected_window (Qnil);
|
|
|
902
|
|
|
903 CHECK_LIVE_WINDOW (window);
|
|
|
904 CHECK_INT (pixels);
|
|
|
905
|
|
|
906 selected = (EQ (window, Fselected_window (Qnil)));
|
|
|
907
|
|
|
908 w = XWINDOW (window);
|
|
|
909
|
|
|
910 orig = selected ? BUF_PT (XBUFFER (w->buffer))
|
|
|
911 : marker_position (w->pointm[CURRENT_DISP]);
|
|
|
912
|
|
|
913 howto = INTP (how) ? XINT (how) : 0;
|
|
|
914
|
|
665
|
915 charbpos = vmotion_pixels (window, orig, XINT (pixels), howto, &motion);
|
|
428
|
916
|
|
|
917 if (selected)
|
|
665
|
918 BUF_SET_PT (XBUFFER (w->buffer), charbpos);
|
|
428
|
919 else
|
|
|
920 set_marker_restricted (w->pointm[CURRENT_DISP],
|
|
665
|
921 make_int(charbpos),
|
|
428
|
922 w->buffer);
|
|
|
923
|
|
|
924 return make_int (motion);
|
|
|
925 }
|
|
|
926
|
|
|
927
|
|
|
928 void
|
|
|
929 syms_of_indent (void)
|
|
|
930 {
|
|
|
931 DEFSUBR (Fcurrent_indentation);
|
|
|
932 DEFSUBR (Findent_to);
|
|
|
933 DEFSUBR (Fcurrent_column);
|
|
|
934 DEFSUBR (Fmove_to_column);
|
|
|
935 #if 0 /* #### */
|
|
|
936 DEFSUBR (Fcompute_motion);
|
|
|
937 #endif
|
|
|
938 DEFSUBR (Fvertical_motion);
|
|
|
939 DEFSUBR (Fvertical_motion_pixels);
|
|
|
940
|
|
563
|
941 DEFSYMBOL (Qcoerce);
|
|
428
|
942 }
|
|
|
943
|
|
|
944 void
|
|
|
945 vars_of_indent (void)
|
|
|
946 {
|
|
|
947 DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode /*
|
|
|
948 *Indentation can insert tabs if this is non-nil.
|
|
|
949 Setting this variable automatically makes it local to the current buffer.
|
|
|
950 */ );
|
|
|
951 indent_tabs_mode = 1;
|
|
|
952 }
|
