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