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.
3025
+ − 5 Copyright (C) 2002, 2005 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);
2506
+ − 74 value = Fprevious_single_char_property_change (make_int (pos), Qinvisible,
+ − 75 buffer, Qnil);
428
+ − 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
3025
+ − 395 A value of `coerce' for the second (optional) argument FORCE means if
428
+ − 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 }