buffer.c 199 KB
Newer Older
Roland McGrath's avatar
Roland McGrath committed
1
/* Buffer manipulation primitives for GNU Emacs.
2 3
   Copyright (C) 1985, 1986, 1987, 1988, 1989, 1993, 1994,
                 1995, 1997, 1998, 1999, 2000, 2001, 2002,
4
                 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
Glenn Morris's avatar
Glenn Morris committed
5
                 Free Software Foundation, Inc.
Roland McGrath's avatar
Roland McGrath committed
6 7 8

This file is part of GNU Emacs.

9
GNU Emacs is free software: you can redistribute it and/or modify
Roland McGrath's avatar
Roland McGrath committed
10
it under the terms of the GNU General Public License as published by
11 12
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Roland McGrath's avatar
Roland McGrath committed
13 14 15 16 17 18 19

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
20
along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
Roland McGrath's avatar
Roland McGrath committed
21

22
#include <config.h>
Roland McGrath's avatar
Roland McGrath committed
23

24 25
#include <sys/types.h>
#include <sys/stat.h>
Roland McGrath's avatar
Roland McGrath committed
26
#include <sys/param.h>
Richard M. Stallman's avatar
Richard M. Stallman committed
27
#include <errno.h>
Dave Love's avatar
Dave Love committed
28
#include <stdio.h>
29
#include <setjmp.h>
Richard M. Stallman's avatar
Richard M. Stallman committed
30

Andreas Schwab's avatar
Andreas Schwab committed
31 32 33
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
34

Roland McGrath's avatar
Roland McGrath committed
35
#include "lisp.h"
36
#include "intervals.h"
Roland McGrath's avatar
Roland McGrath committed
37 38 39
#include "window.h"
#include "commands.h"
#include "buffer.h"
40
#include "character.h"
41
#include "region-cache.h"
Roland McGrath's avatar
Roland McGrath committed
42
#include "indent.h"
Richard M. Stallman's avatar
Richard M. Stallman committed
43
#include "blockinput.h"
44
#include "keyboard.h"
Stefan Monnier's avatar
Stefan Monnier committed
45
#include "keymap.h"
46
#include "frame.h"
Roland McGrath's avatar
Roland McGrath committed
47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

struct buffer *current_buffer;		/* the current buffer */

/* First buffer in chain of all buffers (in reverse order of creation).
   Threaded through ->next.  */

struct buffer *all_buffers;

/* This structure holds the default values of the buffer-local variables
   defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
   The default value occupies the same slot in this structure
   as an individual buffer's value occupies in that buffer.
   Setting the default value also goes through the alist of buffers
   and stores into each buffer that does not say it has a local value.  */

Kenichi Handa's avatar
Kenichi Handa committed
62
DECL_ALIGN (struct buffer, buffer_defaults);
Roland McGrath's avatar
Roland McGrath committed
63 64 65 66 67 68 69 70 71 72 73

/* A Lisp_Object pointer to the above, used for staticpro */

static Lisp_Object Vbuffer_defaults;

/* This structure marks which slots in a buffer have corresponding
   default values in buffer_defaults.
   Each such slot has a nonzero value in this structure.
   The value has only one nonzero bit.

   When a buffer has its own local value for a slot,
74 75
   the entry for that slot (found in the same slot in this structure)
   is turned on in the buffer's local_flags array.
Roland McGrath's avatar
Roland McGrath committed
76 77 78 79 80 81 82 83 84 85 86 87 88

   If a slot in this structure is -1, then even though there may
   be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
   and the corresponding slot in buffer_defaults is not used.

   If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
   zero, that is a bug */

struct buffer buffer_local_flags;

/* This structure holds the names of symbols whose values may be
   buffer-local.  It is indexed and accessed in the same way as the above. */

Kenichi Handa's avatar
Kenichi Handa committed
89 90
DECL_ALIGN (struct buffer, buffer_local_symbols);

Roland McGrath's avatar
Roland McGrath committed
91 92 93
/* A Lisp_Object pointer to the above, used for staticpro */
static Lisp_Object Vbuffer_local_symbols;

94 95 96 97 98 99
/* Return the symbol of the per-buffer variable at offset OFFSET in
   the buffer structure.  */

#define PER_BUFFER_SYMBOL(OFFSET) \
      (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_symbols))

100 101
/* Flags indicating which built-in buffer-local variables
   are permanent locals.  */
102
static char buffer_permanent_local_flags[MAX_PER_BUFFER_VARS];
103 104 105

/* Number of per-buffer variables used.  */

106
int last_per_buffer_idx;
107

108
EXFUN (Fset_buffer, 1);
109 110 111 112 113
static void call_overlay_mod_hooks (Lisp_Object list, Lisp_Object overlay,
                                    int after, Lisp_Object arg1,
                                    Lisp_Object arg2, Lisp_Object arg3);
static void swap_out_buffer_local_variables (struct buffer *b);
static void reset_buffer_local_variables (struct buffer *b, int permanent_too);
Roland McGrath's avatar
Roland McGrath committed
114 115 116 117 118 119 120

/* Alist of all buffer names vs the buffers. */
/* This used to be a variable, but is no longer,
 to prevent lossage due to user rplac'ing this alist or its elements.  */
Lisp_Object Vbuffer_alist;

/* Functions to call before and after each text change. */
121 122
Lisp_Object Vbefore_change_functions;
Lisp_Object Vafter_change_functions;
Roland McGrath's avatar
Roland McGrath committed
123

124 125
Lisp_Object Vtransient_mark_mode;

126 127 128 129 130
/* t means ignore all read-only text properties.
   A list means ignore such a property if its value is a member of the list.
   Any non-nil value means ignore buffer-read-only.  */
Lisp_Object Vinhibit_read_only;

131 132 133
/* List of functions to call that can query about killing a buffer.
   If any of these functions returns nil, we don't kill it.  */
Lisp_Object Vkill_buffer_query_functions;
134
Lisp_Object Qkill_buffer_query_functions;
135

136 137 138
/* Hook run before changing a major mode.  */
Lisp_Object Vchange_major_mode_hook, Qchange_major_mode_hook;

Jim Blandy's avatar
Jim Blandy committed
139 140
/* List of functions to call before changing an unmodified buffer.  */
Lisp_Object Vfirst_change_hook;
141

Jim Blandy's avatar
Jim Blandy committed
142
Lisp_Object Qfirst_change_hook;
143 144
Lisp_Object Qbefore_change_functions;
Lisp_Object Qafter_change_functions;
Dave Love's avatar
Dave Love committed
145
Lisp_Object Qucs_set_table_for_input;
Roland McGrath's avatar
Roland McGrath committed
146

147 148 149
/* If nonzero, all modification hooks are suppressed.  */
int inhibit_modification_hooks;

Roland McGrath's avatar
Roland McGrath committed
150
Lisp_Object Qfundamental_mode, Qmode_class, Qpermanent_local;
151
Lisp_Object Qpermanent_local_hook;
Roland McGrath's avatar
Roland McGrath committed
152 153 154 155 156 157 158

Lisp_Object Qprotected_field;

Lisp_Object QSFundamental;	/* A string "Fundamental" */

Lisp_Object Qkill_buffer_hook;

Richard M. Stallman's avatar
Richard M. Stallman committed
159 160
Lisp_Object Qget_file_buffer;

Jim Blandy's avatar
Jim Blandy committed
161 162
Lisp_Object Qoverlayp;

163
Lisp_Object Qpriority, Qevaporate, Qbefore_string, Qafter_string;
164

165 166 167 168
Lisp_Object Qmodification_hooks;
Lisp_Object Qinsert_in_front_hooks;
Lisp_Object Qinsert_behind_hooks;

169 170 171 172 173
static void alloc_buffer_text (struct buffer *, size_t);
static void free_buffer_text (struct buffer *b);
static struct Lisp_Overlay * copy_overlays (struct buffer *, struct Lisp_Overlay *);
static void modify_overlay (struct buffer *, EMACS_INT, EMACS_INT);
static Lisp_Object buffer_lisp_local_variables (struct buffer *);
174

Roland McGrath's avatar
Roland McGrath committed
175 176 177
/* For debugging; temporary.  See set_buffer_internal.  */
/* Lisp_Object Qlisp_mode, Vcheck_symbol; */

178
void
179
nsberror (Lisp_Object spec)
Roland McGrath's avatar
Roland McGrath committed
180
{
181
  if (STRINGP (spec))
182
    error ("No buffer named %s", SDATA (spec));
Roland McGrath's avatar
Roland McGrath committed
183 184 185
  error ("Invalid buffer argument");
}

186
DEFUN ("buffer-live-p", Fbuffer_live_p, Sbuffer_live_p, 1, 1, 0,
187 188
       doc: /* Return non-nil if OBJECT is a buffer which has not been killed.
Value is nil if OBJECT is not a buffer or if it has been killed.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
189
  (Lisp_Object object)
190 191 192 193 194
{
  return ((BUFFERP (object) && ! NILP (XBUFFER (object)->name))
	  ? Qt : Qnil);
}

195
DEFUN ("buffer-list", Fbuffer_list, Sbuffer_list, 0, 1, 0,
196
       doc: /* Return a list of all existing live buffers.
Richard M. Stallman's avatar
Richard M. Stallman committed
197 198 199
If the optional arg FRAME is a frame, we return the buffer list
in the proper order for that frame: the buffers in FRAME's `buffer-list'
frame parameter come first, followed by the rest of the buffers.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
200
  (Lisp_Object frame)
Roland McGrath's avatar
Roland McGrath committed
201
{
202
  Lisp_Object general;
203 204 205 206
  general = Fmapcar (Qcdr, Vbuffer_alist);

  if (FRAMEP (frame))
    {
207 208
      Lisp_Object framelist, prevlist, tail;
      Lisp_Object args[3];
209

210
      CHECK_FRAME (frame);
211 212

      framelist = Fcopy_sequence (XFRAME (frame)->buffer_list);
213
      prevlist = Fnreverse (Fcopy_sequence (XFRAME (frame)->buried_buffer_list));
214

215 216
      /* Remove from GENERAL any buffer that duplicates one in
         FRAMELIST or PREVLIST.  */
217
      tail = framelist;
218
      while (CONSP (tail))
219
	{
220 221
	  general = Fdelq (XCAR (tail), general);
	  tail = XCDR (tail);
222
	}
223 224 225 226 227 228 229 230 231 232 233
      tail = prevlist;
      while (CONSP (tail))
	{
	  general = Fdelq (XCAR (tail), general);
	  tail = XCDR (tail);
	}

      args[0] = framelist;
      args[1] = general;
      args[2] = prevlist;
      return Fnconc (3, args);
234 235 236
    }

  return general;
Roland McGrath's avatar
Roland McGrath committed
237 238
}

239 240 241 242 243
/* Like Fassoc, but use Fstring_equal to compare
   (which ignores text properties),
   and don't ever QUIT.  */

static Lisp_Object
244
assoc_ignore_text_properties (register Lisp_Object key, Lisp_Object list)
245 246
{
  register Lisp_Object tail;
247
  for (tail = list; CONSP (tail); tail = XCDR (tail))
248 249
    {
      register Lisp_Object elt, tem;
250
      elt = XCAR (tail);
251 252 253 254 255 256 257
      tem = Fstring_equal (Fcar (elt), key);
      if (!NILP (tem))
	return elt;
    }
  return Qnil;
}

Roland McGrath's avatar
Roland McGrath committed
258
DEFUN ("get-buffer", Fget_buffer, Sget_buffer, 1, 1, 0,
259 260 261 262
       doc: /* Return the buffer named BUFFER-OR-NAME.
BUFFER-OR-NAME must be either a string or a buffer.  If BUFFER-OR-NAME
is a string and there is no buffer with that name, return nil.  If
BUFFER-OR-NAME is a buffer, return it as given.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
263
  (register Lisp_Object buffer_or_name)
Roland McGrath's avatar
Roland McGrath committed
264
{
265 266 267
  if (BUFFERP (buffer_or_name))
    return buffer_or_name;
  CHECK_STRING (buffer_or_name);
Roland McGrath's avatar
Roland McGrath committed
268

269
  return Fcdr (assoc_ignore_text_properties (buffer_or_name, Vbuffer_alist));
Roland McGrath's avatar
Roland McGrath committed
270 271 272
}

DEFUN ("get-file-buffer", Fget_file_buffer, Sget_file_buffer, 1, 1, 0,
273
       doc: /* Return the buffer visiting file FILENAME (a string).
Pavel Janík's avatar
Pavel Janík committed
274 275
The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
If there is no such live buffer, return nil.
276
See also `find-buffer-visiting'.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
277
  (register Lisp_Object filename)
Roland McGrath's avatar
Roland McGrath committed
278 279
{
  register Lisp_Object tail, buf, tem;
Richard M. Stallman's avatar
Richard M. Stallman committed
280 281
  Lisp_Object handler;

282
  CHECK_STRING (filename);
Roland McGrath's avatar
Roland McGrath committed
283 284
  filename = Fexpand_file_name (filename, Qnil);

Richard M. Stallman's avatar
Richard M. Stallman committed
285 286
  /* If the file name has special constructs in it,
     call the corresponding file handler.  */
287
  handler = Ffind_file_name_handler (filename, Qget_file_buffer);
Richard M. Stallman's avatar
Richard M. Stallman committed
288 289 290
  if (!NILP (handler))
    return call2 (handler, Qget_file_buffer, filename);

291
  for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
Roland McGrath's avatar
Roland McGrath committed
292
    {
293
      buf = Fcdr (XCAR (tail));
294 295
      if (!BUFFERP (buf)) continue;
      if (!STRINGP (XBUFFER (buf)->filename)) continue;
Roland McGrath's avatar
Roland McGrath committed
296
      tem = Fstring_equal (XBUFFER (buf)->filename, filename);
Jim Blandy's avatar
Jim Blandy committed
297
      if (!NILP (tem))
Roland McGrath's avatar
Roland McGrath committed
298 299 300 301 302
	return buf;
    }
  return Qnil;
}

303
Lisp_Object
304
get_truename_buffer (register Lisp_Object filename)
305 306 307
{
  register Lisp_Object tail, buf, tem;

308
  for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
309
    {
310
      buf = Fcdr (XCAR (tail));
311 312 313 314 315 316 317 318 319
      if (!BUFFERP (buf)) continue;
      if (!STRINGP (XBUFFER (buf)->file_truename)) continue;
      tem = Fstring_equal (XBUFFER (buf)->file_truename, filename);
      if (!NILP (tem))
	return buf;
    }
  return Qnil;
}

Roland McGrath's avatar
Roland McGrath committed
320 321 322 323
/* Incremented for each buffer created, to assign the buffer number. */
int buffer_count;

DEFUN ("get-buffer-create", Fget_buffer_create, Sget_buffer_create, 1, 1, 0,
324 325 326 327 328 329 330 331
       doc: /* Return the buffer specified by BUFFER-OR-NAME, creating a new one if needed.
If BUFFER-OR-NAME is a string and a live buffer with that name exists,
return that buffer.  If no such buffer exists, create a new buffer with
that name and return it.  If BUFFER-OR-NAME starts with a space, the new
buffer does not keep undo information.

If BUFFER-OR-NAME is a buffer instead of a string, return it as given,
even if it is dead.  The return value is never nil.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
332
  (register Lisp_Object buffer_or_name)
Roland McGrath's avatar
Roland McGrath committed
333
{
334
  register Lisp_Object buffer, name;
Roland McGrath's avatar
Roland McGrath committed
335 336
  register struct buffer *b;

337 338 339
  buffer = Fget_buffer (buffer_or_name);
  if (!NILP (buffer))
    return buffer;
Roland McGrath's avatar
Roland McGrath committed
340

341
  if (SCHARS (buffer_or_name) == 0)
342 343
    error ("Empty string for buffer name is not allowed");

344
  b = allocate_buffer ();
Roland McGrath's avatar
Roland McGrath committed
345

346 347 348 349
  /* An ordinary buffer uses its own struct buffer_text.  */
  b->text = &b->own_text;
  b->base_buffer = 0;

Roland McGrath's avatar
Roland McGrath committed
350
  BUF_GAP_SIZE (b) = 20;
351
  BLOCK_INPUT;
Karl Heuer's avatar
Karl Heuer committed
352 353
  /* We allocate extra 1-byte at the tail and keep it always '\0' for
     anchoring a search.  */
354
  alloc_buffer_text (b, BUF_GAP_SIZE (b) + 1);
355
  UNBLOCK_INPUT;
Roland McGrath's avatar
Roland McGrath committed
356
  if (! BUF_BEG_ADDR (b))
357
    buffer_memory_full ();
Roland McGrath's avatar
Roland McGrath committed
358

359 360 361 362 363 364 365 366 367 368
  BUF_PT (b) = BEG;
  BUF_GPT (b) = BEG;
  BUF_BEGV (b) = BEG;
  BUF_ZV (b) = BEG;
  BUF_Z (b) = BEG;
  BUF_PT_BYTE (b) = BEG_BYTE;
  BUF_GPT_BYTE (b) = BEG_BYTE;
  BUF_BEGV_BYTE (b) = BEG_BYTE;
  BUF_ZV_BYTE (b) = BEG_BYTE;
  BUF_Z_BYTE (b) = BEG_BYTE;
Roland McGrath's avatar
Roland McGrath committed
369
  BUF_MODIFF (b) = 1;
370
  BUF_CHARS_MODIFF (b) = 1;
371
  BUF_OVERLAY_MODIFF (b) = 1;
372 373
  BUF_SAVE_MODIFF (b) = 1;
  BUF_INTERVALS (b) = 0;
374 375 376 377
  BUF_UNCHANGED_MODIFIED (b) = 1;
  BUF_OVERLAY_UNCHANGED_MODIFIED (b) = 1;
  BUF_END_UNCHANGED (b) = 0;
  BUF_BEG_UNCHANGED (b) = 0;
Karl Heuer's avatar
Karl Heuer committed
378
  *(BUF_GPT_ADDR (b)) = *(BUF_Z_ADDR (b)) = 0; /* Put an anchor '\0'.  */
Roland McGrath's avatar
Roland McGrath committed
379

380 381 382
  b->newline_cache = 0;
  b->width_run_cache = 0;
  b->width_table = Qnil;
383
  b->prevent_redisplay_optimizations_p = 1;
384

Roland McGrath's avatar
Roland McGrath committed
385 386 387 388
  /* Put this on the chain of all buffers including killed ones.  */
  b->next = all_buffers;
  all_buffers = b;

389 390 391 392 393
  /* An ordinary buffer normally doesn't need markers
     to handle BEGV and ZV.  */
  b->pt_marker = Qnil;
  b->begv_marker = Qnil;
  b->zv_marker = Qnil;
394

395
  name = Fcopy_sequence (buffer_or_name);
396
  STRING_SET_INTERVALS (name, NULL_INTERVAL);
Roland McGrath's avatar
Roland McGrath committed
397
  b->name = name;
398

399
  b->undo_list = (SREF (name, 0) != ' ') ? Qnil : Qt;
Roland McGrath's avatar
Roland McGrath committed
400 401

  reset_buffer (b);
402
  reset_buffer_local_variables (b, 1);
Roland McGrath's avatar
Roland McGrath committed
403

404
  b->mark = Fmake_marker ();
405
  BUF_MARKERS (b) = NULL;
406 407
  b->name = name;

Roland McGrath's avatar
Roland McGrath committed
408
  /* Put this in the alist of all live buffers.  */
409 410
  XSETBUFFER (buffer, b);
  Vbuffer_alist = nconc2 (Vbuffer_alist, Fcons (Fcons (name, buffer), Qnil));
Roland McGrath's avatar
Roland McGrath committed
411

Juanma Barranquero's avatar
Juanma Barranquero committed
412
  /* An error in calling the function here (should someone redefine it)
Dave Love's avatar
Dave Love committed
413 414
     can lead to infinite regress until you run out of stack.  rms
     says that's not worth protecting against.  */
Dave Love's avatar
Dave Love committed
415
  if (!NILP (Ffboundp (Qucs_set_table_for_input)))
416 417
    /* buffer is on buffer-alist, so no gcpro.  */
    call1 (Qucs_set_table_for_input, buffer);
Dave Love's avatar
Dave Love committed
418

419
  return buffer;
420 421
}

422

423 424 425
/* Return a list of overlays which is a copy of the overlay list
   LIST, but for buffer B.  */

426
static struct Lisp_Overlay *
427
copy_overlays (struct buffer *b, struct Lisp_Overlay *list)
428
{
429 430
  Lisp_Object buffer;
  struct Lisp_Overlay *result = NULL, *tail = NULL;
431 432 433

  XSETBUFFER (buffer, b);

434
  for (; list; list = list->next)
435 436
    {
      Lisp_Object overlay, start, end, old_overlay;
437
      EMACS_INT charpos;
438

439
      XSETMISC (old_overlay, list);
440 441
      charpos = marker_position (OVERLAY_START (old_overlay));
      start = Fmake_marker ();
442
      Fset_marker (start, make_number (charpos), buffer);
443 444 445 446 447
      XMARKER (start)->insertion_type
	= XMARKER (OVERLAY_START (old_overlay))->insertion_type;

      charpos = marker_position (OVERLAY_END (old_overlay));
      end = Fmake_marker ();
448
      Fset_marker (end, make_number (charpos), buffer);
449 450 451 452 453 454 455 456
      XMARKER (end)->insertion_type
	= XMARKER (OVERLAY_END (old_overlay))->insertion_type;

      overlay = allocate_misc ();
      XMISCTYPE (overlay) = Lisp_Misc_Overlay;
      OVERLAY_START (overlay) = start;
      OVERLAY_END (overlay) = end;
      OVERLAY_PLIST (overlay) = Fcopy_sequence (OVERLAY_PLIST (old_overlay));
457
      XOVERLAY (overlay)->next = NULL;
458

459 460 461 462
      if (tail)
	tail = tail->next = XOVERLAY (overlay);
      else
	result = tail = XOVERLAY (overlay);
463 464
    }

465
  return result;
466
}
467

468

469 470 471 472 473 474 475 476
/* Clone per-buffer values of buffer FROM.

   Buffer TO gets the same per-buffer values as FROM, with the
   following exceptions: (1) TO's name is left untouched, (2) markers
   are copied and made to refer to TO, and (3) overlay lists are
   copied.  */

static void
477
clone_per_buffer_values (struct buffer *from, struct buffer *to)
478
{
479
  Lisp_Object to_buffer;
480 481 482
  int offset;

  XSETBUFFER (to_buffer, to);
483

484 485
  /* buffer-local Lisp variables start at `undo_list',
     tho only the ones from `name' on are GC'd normally.  */
486
  for (offset = PER_BUFFER_VAR_OFFSET (undo_list);
487 488 489 490 491
       offset < sizeof *to;
       offset += sizeof (Lisp_Object))
    {
      Lisp_Object obj;

492 493 494 495
      /* Don't touch the `name' which should be unique for every buffer.  */
      if (offset == PER_BUFFER_VAR_OFFSET (name))
	continue;

496
      obj = PER_BUFFER_VALUE (from, offset);
497
      if (MARKERP (obj) && XMARKER (obj)->buffer == from)
498 499 500 501 502 503 504 505 506 507
	{
	  struct Lisp_Marker *m = XMARKER (obj);
	  obj = Fmake_marker ();
	  XMARKER (obj)->insertion_type = m->insertion_type;
	  set_marker_both (obj, to_buffer, m->charpos, m->bytepos);
	}

      PER_BUFFER_VALUE (to, offset) = obj;
    }

508
  memcpy (to->local_flags, from->local_flags, sizeof to->local_flags);
509

510 511
  to->overlays_before = copy_overlays (to, from->overlays_before);
  to->overlays_after = copy_overlays (to, from->overlays_after);
512

513 514 515
  /* Get (a copy of) the alist of Lisp-level local variables of FROM
     and install that in TO.  */
  to->local_var_alist = buffer_lisp_local_variables (from);
516 517 518 519
}

DEFUN ("make-indirect-buffer", Fmake_indirect_buffer, Smake_indirect_buffer,
       2, 3,
520
       "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
521
       doc: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
Kenichi Handa's avatar
Kenichi Handa committed
522
BASE-BUFFER should be a live buffer, or the name of an existing buffer.
Pavel Janík's avatar
Pavel Janík committed
523 524 525
NAME should be a string which is not the name of an existing buffer.
Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
such as major and minor modes, in the indirect buffer.
526
CLONE nil means the indirect buffer's state is reset to default values.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
527
  (Lisp_Object base_buffer, Lisp_Object name, Lisp_Object clone)
528
{
Kenichi Handa's avatar
Kenichi Handa committed
529
  Lisp_Object buf, tem;
530
  struct buffer *b;
531

Kenichi Handa's avatar
Kenichi Handa committed
532
  CHECK_STRING (name);
533 534
  buf = Fget_buffer (name);
  if (!NILP (buf))
535
    error ("Buffer name `%s' is in use", SDATA (name));
536

Kenichi Handa's avatar
Kenichi Handa committed
537
  tem = base_buffer;
538 539
  base_buffer = Fget_buffer (base_buffer);
  if (NILP (base_buffer))
Kenichi Handa's avatar
Kenichi Handa committed
540 541 542
    error ("No such buffer: `%s'", SDATA (tem));
  if (NILP (XBUFFER (base_buffer)->name))
    error ("Base buffer has been killed");
543

544
  if (SCHARS (name) == 0)
545 546
    error ("Empty string for buffer name is not allowed");

547
  b = allocate_buffer ();
548

549 550 551
  b->base_buffer = (XBUFFER (base_buffer)->base_buffer
		    ? XBUFFER (base_buffer)->base_buffer
		    : XBUFFER (base_buffer));
552 553 554 555 556 557 558

  /* Use the base buffer's text object.  */
  b->text = b->base_buffer->text;

  BUF_BEGV (b) = BUF_BEGV (b->base_buffer);
  BUF_ZV (b) = BUF_ZV (b->base_buffer);
  BUF_PT (b) = BUF_PT (b->base_buffer);
559 560 561
  BUF_BEGV_BYTE (b) = BUF_BEGV_BYTE (b->base_buffer);
  BUF_ZV_BYTE (b) = BUF_ZV_BYTE (b->base_buffer);
  BUF_PT_BYTE (b) = BUF_PT_BYTE (b->base_buffer);
562 563 564 565 566 567 568 569 570 571

  b->newline_cache = 0;
  b->width_run_cache = 0;
  b->width_table = Qnil;

  /* Put this on the chain of all buffers including killed ones.  */
  b->next = all_buffers;
  all_buffers = b;

  name = Fcopy_sequence (name);
572
  STRING_SET_INTERVALS (name, NULL_INTERVAL);
573 574 575
  b->name = name;

  reset_buffer (b);
576
  reset_buffer_local_variables (b, 1);
577 578 579 580 581 582

  /* Put this in the alist of all live buffers.  */
  XSETBUFFER (buf, b);
  Vbuffer_alist = nconc2 (Vbuffer_alist, Fcons (Fcons (name, buf), Qnil));

  b->mark = Fmake_marker ();
Roland McGrath's avatar
Roland McGrath committed
583
  b->name = name;
584

585 586 587
  /* The multibyte status belongs to the base buffer.  */
  b->enable_multibyte_characters = b->base_buffer->enable_multibyte_characters;

588 589 590 591
  /* Make sure the base buffer has markers for its narrowing.  */
  if (NILP (b->base_buffer->pt_marker))
    {
      b->base_buffer->pt_marker = Fmake_marker ();
592 593 594
      set_marker_both (b->base_buffer->pt_marker, base_buffer,
		       BUF_PT (b->base_buffer),
		       BUF_PT_BYTE (b->base_buffer));
595 596 597 598
    }
  if (NILP (b->base_buffer->begv_marker))
    {
      b->base_buffer->begv_marker = Fmake_marker ();
599 600 601
      set_marker_both (b->base_buffer->begv_marker, base_buffer,
		       BUF_BEGV (b->base_buffer),
		       BUF_BEGV_BYTE (b->base_buffer));
602 603 604 605
    }
  if (NILP (b->base_buffer->zv_marker))
    {
      b->base_buffer->zv_marker = Fmake_marker ();
606 607 608
      set_marker_both (b->base_buffer->zv_marker, base_buffer,
		       BUF_ZV (b->base_buffer),
		       BUF_ZV_BYTE (b->base_buffer));
609
      XMARKER (b->base_buffer->zv_marker)->insertion_type = 1;
610 611
    }

612 613 614 615 616 617 618 619 620 621 622 623
  if (NILP (clone))
    {
      /* Give the indirect buffer markers for its narrowing.  */
      b->pt_marker = Fmake_marker ();
      set_marker_both (b->pt_marker, buf, BUF_PT (b), BUF_PT_BYTE (b));
      b->begv_marker = Fmake_marker ();
      set_marker_both (b->begv_marker, buf, BUF_BEGV (b), BUF_BEGV_BYTE (b));
      b->zv_marker = Fmake_marker ();
      set_marker_both (b->zv_marker, buf, BUF_ZV (b), BUF_ZV_BYTE (b));
      XMARKER (b->zv_marker)->insertion_type = 1;
    }
  else
624 625 626 627 628 629 630 631 632 633 634 635 636 637 638
    {
      struct buffer *old_b = current_buffer;

      clone_per_buffer_values (b->base_buffer, b);
      b->filename = Qnil;
      b->file_truename = Qnil;
      b->display_count = make_number (0);
      b->backed_up = Qnil;
      b->auto_save_file_name = Qnil;
      set_buffer_internal_1 (b);
      Fset (intern ("buffer-save-without-query"), Qnil);
      Fset (intern ("buffer-file-number"), Qnil);
      Fset (intern ("buffer-stale-function"), Qnil);
      set_buffer_internal_1 (old_b);
    }
639

640
  return buf;
Roland McGrath's avatar
Roland McGrath committed
641 642
}

643
void
644
delete_all_overlays (struct buffer *b)
645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665
{
  Lisp_Object overlay;

  /* `reset_buffer' blindly sets the list of overlays to NULL, so we
     have to empty the list, otherwise we end up with overlays that
     think they belong to this buffer while the buffer doesn't know about
     them any more.  */
  while (b->overlays_before)
    {
      XSETMISC (overlay, b->overlays_before);
      Fdelete_overlay (overlay);
    }
  while (b->overlays_after)
    {
      XSETMISC (overlay, b->overlays_after);
      Fdelete_overlay (overlay);
    }
  eassert (b->overlays_before == NULL);
  eassert (b->overlays_after == NULL);
}

666
/* Reinitialize everything about a buffer except its name and contents
Kenichi Handa's avatar
Kenichi Handa committed
667
   and local variables.
668 669 670 671
   If called on an already-initialized buffer, the list of overlays
   should be deleted before calling this function, otherwise we end up
   with overlays that claim to belong to the buffer but the buffer
   claims it doesn't belong to it.  */
Roland McGrath's avatar
Roland McGrath committed
672 673

void
674
reset_buffer (register struct buffer *b)
Roland McGrath's avatar
Roland McGrath committed
675 676
{
  b->filename = Qnil;
677
  b->file_truename = Qnil;
Roland McGrath's avatar
Roland McGrath committed
678 679
  b->directory = (current_buffer) ? current_buffer->directory : Qnil;
  b->modtime = 0;
680
  b->modtime_size = -1;
681
  XSETFASTINT (b->save_length, 0);
Roland McGrath's avatar
Roland McGrath committed
682
  b->last_window_start = 1;
683
  /* It is more conservative to start out "changed" than "unchanged".  */
684 685
  b->clip_changed = 0;
  b->prevent_redisplay_optimizations_p = 1;
Roland McGrath's avatar
Roland McGrath committed
686
  b->backed_up = Qnil;
687
  BUF_AUTOSAVE_MODIFF (b) = 0;
688
  b->auto_save_failure_time = -1;
Roland McGrath's avatar
Roland McGrath committed
689 690
  b->auto_save_file_name = Qnil;
  b->read_only = Qnil;
691 692
  b->overlays_before = NULL;
  b->overlays_after = NULL;
693
  b->overlay_center = BEG;
694
  b->mark_active = Qnil;
695
  b->point_before_scroll = Qnil;
696
  b->file_format = Qnil;
697
  b->auto_save_file_format = Qt;
698
  b->last_selected_window = Qnil;
699
  XSETINT (b->display_count, 0);
700
  b->display_time = Qnil;
701
  b->enable_multibyte_characters = buffer_defaults.enable_multibyte_characters;
702
  b->cursor_type = buffer_defaults.cursor_type;
703
  b->extra_line_spacing = buffer_defaults.extra_line_spacing;
704 705

  b->display_error_modiff = 0;
Roland McGrath's avatar
Roland McGrath committed
706 707
}

708 709 710
/* Reset buffer B's local variables info.
   Don't use this on a buffer that has already been in use;
   it does not treat permanent locals consistently.
711 712
   Instead, use Fkill_all_local_variables.

713
   If PERMANENT_TOO is 1, then we reset permanent
714 715
   buffer-local variables.  If PERMANENT_TOO is 0,
   we preserve those.  */
716

717
static void
718
reset_buffer_local_variables (register struct buffer *b, int permanent_too)
Roland McGrath's avatar
Roland McGrath committed
719 720
{
  register int offset;
721
  int i;
Roland McGrath's avatar
Roland McGrath committed
722 723 724 725 726 727 728 729 730

  /* Reset the major mode to Fundamental, together with all the
     things that depend on the major mode.
     default-major-mode is handled at a higher level.
     We ignore it here.  */
  b->major_mode = Qfundamental_mode;
  b->keymap = Qnil;
  b->mode_name = QSFundamental;
  b->minor_modes = Qnil;
731 732 733 734 735 736 737 738

  /* If the standard case table has been altered and invalidated,
     fix up its insides first.  */
  if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table)->extras[0])
	 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table)->extras[1])
	 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table)->extras[2])))
    Fset_standard_case_table (Vascii_downcase_table);

Roland McGrath's avatar
Roland McGrath committed
739
  b->downcase_table = Vascii_downcase_table;
740 741 742
  b->upcase_table = XCHAR_TABLE (Vascii_downcase_table)->extras[0];
  b->case_canon_table = XCHAR_TABLE (Vascii_downcase_table)->extras[1];
  b->case_eqv_table = XCHAR_TABLE (Vascii_downcase_table)->extras[2];
743
  b->invisibility_spec = Qt;
744 745 746
#ifndef DOS_NT
  b->buffer_file_type = Qnil;
#endif
747

748
  /* Reset all (or most) per-buffer variables to their defaults.  */
749 750 751 752
  if (permanent_too)
    b->local_var_alist = Qnil;
  else
    {
753
      Lisp_Object tmp, prop, last = Qnil;
754
      for (tmp = b->local_var_alist; CONSP (tmp); tmp = XCDR (tmp))
755
	if (!NILP (prop = Fget (XCAR (XCAR (tmp)), Qpermanent_local)))
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782
	  {
	    /* If permanent-local, keep it.  */
	    last = tmp;
	    if (EQ (prop, Qpermanent_local_hook))
	      {
		/* This is a partially permanent hook variable.
		   Preserve only the elements that want to be preserved.  */
		Lisp_Object list, newlist;
		list = XCDR (XCAR (tmp));
		if (!CONSP (list))
		  newlist = list;
		else
		  for (newlist = Qnil; CONSP (list); list = XCDR (list))
		    {
		      Lisp_Object elt = XCAR (list);
		      /* Preserve element ELT if it's t,
			 if it is a function with a `permanent-local-hook' property,
			 or if it's not a symbol.  */
		      if (! SYMBOLP (elt)
			  || EQ (elt, Qt)
			  || !NILP (Fget (elt, Qpermanent_local_hook)))
			newlist = Fcons (elt, newlist);
		    }
		XSETCDR (XCAR (tmp), Fnreverse (newlist));
	      }
	  }
	/* Delete this local variable.  */
783 784 785 786 787 788
	else if (NILP (last))
	  b->local_var_alist = XCDR (tmp);
	else
	  XSETCDR (last, XCDR (tmp));
    }

789
  for (i = 0; i < last_per_buffer_idx; ++i)
790
    if (permanent_too || buffer_permanent_local_flags[i] == 0)
791
      SET_PER_BUFFER_VALUE_P (b, i, 0);
Roland McGrath's avatar
Roland McGrath committed
792 793 794 795

  /* For each slot that has a default value,
     copy that into the slot.  */

796 797 798
  /* buffer-local Lisp variables start at `undo_list',
     tho only the ones from `name' on are GC'd normally.  */
  for (offset = PER_BUFFER_VAR_OFFSET (undo_list);
799 800
       offset < sizeof *b;
       offset += sizeof (Lisp_Object))
801
    {
802
      int idx = PER_BUFFER_IDX (offset);
803 804
      if ((idx > 0
	   && (permanent_too
805
	       || buffer_permanent_local_flags[idx] == 0)))
806
	PER_BUFFER_VALUE (b, offset) = PER_BUFFER_DEFAULT (offset);
807
    }
Roland McGrath's avatar
Roland McGrath committed
808 809
}

Roland McGrath's avatar
Roland McGrath committed
810 811 812 813 814
/* We split this away from generate-new-buffer, because rename-buffer
   and set-visited-file-name ought to be able to use this to really
   rename the buffer properly.  */

DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name, Sgenerate_new_buffer_name,
815
       1, 2, 0,
816
       doc: /* Return a string that is the name of no existing buffer based on NAME.
Pavel Janík's avatar
Pavel Janík committed
817 818
If there is no live buffer named NAME, then return NAME.
Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
Kenichi Handa's avatar
Kenichi Handa committed
819
\(starting at 2) until an unused name is found, and then return that name.
Juanma Barranquero's avatar
Juanma Barranquero committed
820 821
Optional second argument IGNORE specifies a name that is okay to use (if
it is in the sequence to be tried) even if a buffer with that name exists.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
822
  (register Lisp_Object name, Lisp_Object ignore)
Roland McGrath's avatar
Roland McGrath committed
823 824 825 826 827
{
  register Lisp_Object gentemp, tem;
  int count;
  char number[10];

828
  CHECK_STRING (name);
Roland McGrath's avatar
Roland McGrath committed
829

Kenichi Handa's avatar
Kenichi Handa committed
830 831 832
  tem = Fstring_equal (name, ignore);
  if (!NILP (tem))
    return name;
Roland McGrath's avatar
Roland McGrath committed
833
  tem = Fget_buffer (name);
Jim Blandy's avatar
Jim Blandy committed
834
  if (NILP (tem))
Roland McGrath's avatar
Roland McGrath committed
835
    return name;
Roland McGrath's avatar
Roland McGrath committed
836 837 838 839 840 841

  count = 1;
  while (1)
    {
      sprintf (number, "<%d>", ++count);
      gentemp = concat2 (name, build_string (number));
842
      tem = Fstring_equal (gentemp, ignore);
843 844
      if (!NILP (tem))
	return gentemp;
Roland McGrath's avatar
Roland McGrath committed
845
      tem = Fget_buffer (gentemp);
Jim Blandy's avatar
Jim Blandy committed
846
      if (NILP (tem))
Roland McGrath's avatar
Roland McGrath committed
847
	return gentemp;
Roland McGrath's avatar
Roland McGrath committed
848 849 850 851 852
    }
}


DEFUN ("buffer-name", Fbuffer_name, Sbuffer_name, 0, 1, 0,
853
       doc: /* Return the name of BUFFER, as a string.
854 855
BUFFER defaults to the current buffer.
Return nil if BUFFER has been killed.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
856
  (register Lisp_Object buffer)
Roland McGrath's avatar
Roland McGrath committed
857
{
Jim Blandy's avatar
Jim Blandy committed
858
  if (NILP (buffer))
Roland McGrath's avatar
Roland McGrath committed
859
    return current_buffer->name;
860
  CHECK_BUFFER (buffer);
Roland McGrath's avatar
Roland McGrath committed
861 862 863 864
  return XBUFFER (buffer)->name;
}

DEFUN ("buffer-file-name", Fbuffer_file_name, Sbuffer_file_name, 0, 1, 0,
865 866
       doc: /* Return name of file BUFFER is visiting, or nil if none.
No argument or nil as argument means use the current buffer.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
867
  (register Lisp_Object buffer)
Roland McGrath's avatar
Roland McGrath committed
868
{
Jim Blandy's avatar
Jim Blandy committed
869
  if (NILP (buffer))
Roland McGrath's avatar
Roland McGrath committed
870
    return current_buffer->filename;
871
  CHECK_BUFFER (buffer);
Roland McGrath's avatar
Roland McGrath committed
872 873 874
  return XBUFFER (buffer)->filename;
}

875