don't re-kill them. */
if (other->base_buffer == b && !NILP (BVAR (other, name)))
{
- Lisp_Object buffer;
- XSETBUFFER (buffer, other);
- Fkill_buffer (buffer);
+ Lisp_Object buf;
+ XSETBUFFER (buf, other);
+ Fkill_buffer (buf);
}
UNGCPRO;
&& BUF_SAVE_MODIFF (b) < BUF_MODIFF (b)
&& NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
{
- Lisp_Object tem;
- tem = Fsymbol_value (intern ("delete-auto-save-files"));
- if (! NILP (tem))
+ Lisp_Object delete;
+ delete = Fsymbol_value (intern ("delete-auto-save-files"));
+ if (! NILP (delete))
internal_delete_file (BVAR (b, auto_save_file_name));
}
void
record_buffer (Lisp_Object buf)
{
- register Lisp_Object link, prev;
+ register Lisp_Object list, prev;
Lisp_Object frame;
frame = selected_frame;
prev = Qnil;
- for (link = Vbuffer_alist; CONSP (link); link = XCDR (link))
+ for (list = Vbuffer_alist; CONSP (list); list = XCDR (list))
{
- if (EQ (XCDR (XCAR (link)), buf))
+ if (EQ (XCDR (XCAR (list)), buf))
break;
- prev = link;
+ prev = list;
}
- /* Effectively do Vbuffer_alist = Fdelq (link, Vbuffer_alist);
+ /* Effectively do Vbuffer_alist = Fdelq (list, Vbuffer_alist);
we cannot use Fdelq itself here because it allows quitting. */
if (NILP (prev))
else
XSETCDR (prev, XCDR (XCDR (prev)));
- XSETCDR (link, Vbuffer_alist);
- Vbuffer_alist = link;
+ XSETCDR (list, Vbuffer_alist);
+ Vbuffer_alist = list;
/* Effectively do a delq on buried_buffer_list. */
prev = Qnil;
- for (link = XFRAME (frame)->buried_buffer_list; CONSP (link);
- link = XCDR (link))
+ for (list = XFRAME (frame)->buried_buffer_list; CONSP (list);
+ list = XCDR (list))
{
- if (EQ (XCAR (link), buf))
+ if (EQ (XCAR (list), buf))
{
if (NILP (prev))
- XFRAME (frame)->buried_buffer_list = XCDR (link);
+ XFRAME (frame)->buried_buffer_list = XCDR (list);
else
XSETCDR (prev, XCDR (XCDR (prev)));
break;
}
- prev = link;
+ prev = list;
}
/* Now move this buffer to the front of frame_buffer_list also. */
prev = Qnil;
- for (link = frame_buffer_list (frame); CONSP (link);
- link = XCDR (link))
+ for (list = frame_buffer_list (frame); CONSP (list);
+ list = XCDR (list))
{
- if (EQ (XCAR (link), buf))
+ if (EQ (XCAR (list), buf))
break;
- prev = link;
+ prev = list;
}
/* Effectively do delq. */
- if (CONSP (link))
+ if (CONSP (list))
{
if (NILP (prev))
set_frame_buffer_list (frame,
else
XSETCDR (prev, XCDR (XCDR (prev)));
- XSETCDR (link, frame_buffer_list (frame));
- set_frame_buffer_list (frame, link);
+ XSETCDR (list, frame_buffer_list (frame));
+ set_frame_buffer_list (frame, list);
}
else
set_frame_buffer_list (frame, Fcons (buf, frame_buffer_list (frame)));
/* Switch to buffer BUFFER in the selected window.
If NORECORD is non-nil, don't call record_buffer. */
-Lisp_Object
+static Lisp_Object
switch_to_buffer_1 (Lisp_Object buffer_or_name, Lisp_Object norecord)
{
register Lisp_Object buffer;
buffer is killed. */
if (!NILP (BVAR (XBUFFER (buffer), name)))
{
- Lisp_Object aelt, link;
+ Lisp_Object aelt, list;
aelt = Frassq (buffer, Vbuffer_alist);
- link = Fmemq (aelt, Vbuffer_alist);
+ list = Fmemq (aelt, Vbuffer_alist);
Vbuffer_alist = Fdelq (aelt, Vbuffer_alist);
- XSETCDR (link, Qnil);
- Vbuffer_alist = nconc2 (Vbuffer_alist, link);
+ XSETCDR (list, Qnil);
+ Vbuffer_alist = nconc2 (Vbuffer_alist, list);
XFRAME (selected_frame)->buffer_list
= Fdelq (buffer, XFRAME (selected_frame)->buffer_list);
&& GPT_BYTE > 1 && GPT_BYTE < Z_BYTE
&& ! CHAR_HEAD_P (*(GAP_END_ADDR)))
{
- unsigned char *p = GPT_ADDR - 1;
+ unsigned char *q = GPT_ADDR - 1;
- while (! CHAR_HEAD_P (*p) && p > BEG_ADDR) p--;
- if (LEADING_CODE_P (*p))
+ while (! CHAR_HEAD_P (*q) && q > BEG_ADDR) q--;
+ if (LEADING_CODE_P (*q))
{
- EMACS_INT new_gpt = GPT_BYTE - (GPT_ADDR - p);
+ EMACS_INT new_gpt = GPT_BYTE - (GPT_ADDR - q);
move_gap_both (new_gpt, new_gpt);
}
ZV = chars_in_text (BEG_ADDR, ZV_BYTE - BEG_BYTE) + BEG;
{
- EMACS_INT pt_byte = advance_to_char_boundary (PT_BYTE);
- EMACS_INT pt;
+ EMACS_INT byte = advance_to_char_boundary (PT_BYTE);
+ EMACS_INT position;
- if (pt_byte > GPT_BYTE)
- pt = chars_in_text (GAP_END_ADDR, pt_byte - GPT_BYTE) + GPT;
+ if (byte > GPT_BYTE)
+ position = chars_in_text (GAP_END_ADDR, byte - GPT_BYTE) + GPT;
else
- pt = chars_in_text (BEG_ADDR, pt_byte - BEG_BYTE) + BEG;
- TEMP_SET_PT_BOTH (pt, pt_byte);
+ position = chars_in_text (BEG_ADDR, byte - BEG_BYTE) + BEG;
+ TEMP_SET_PT_BOTH (position, byte);
}
tail = markers = BUF_MARKERS (current_buffer);
the normal hook `change-major-mode-hook'. */)
(void)
{
- if (!NILP (Vrun_hooks))
- call1 (Vrun_hooks, Qchange_major_mode_hook);
+ Frun_hooks (1, &Qchange_major_mode_hook);
/* Make sure none of the bindings in local_var_alist
remain swapped in, in their symbols. */
fix_start_end_in_overlays (register EMACS_INT start, register EMACS_INT end)
{
Lisp_Object overlay;
- struct Lisp_Overlay *before_list, *after_list;
+ struct Lisp_Overlay *before_list IF_LINT (= NULL);
+ struct Lisp_Overlay *after_list IF_LINT (= NULL);
/* These are either nil, indicating that before_list or after_list
should be assigned, or the cons cell the cdr of which should be
assigned. */
/* If parent is nil, replace overlays_before; otherwise, parent->next. */
struct Lisp_Overlay *tail = bp->overlays_before, *parent = NULL, *right_pair;
Lisp_Object tem;
- EMACS_INT end;
+ EMACS_INT end IF_LINT (= 0);
/* After the insertion, the several overlays may be in incorrect
order. The possibility is that, in the list `overlays_before',
the value is (point-min). */)
(Lisp_Object pos)
{
- int noverlays;
EMACS_INT prevpos;
Lisp_Object *overlay_vec;
int len;
/* Put all the overlays we want in a vector in overlay_vec.
Store the length in len.
prevpos gets the position of the previous change. */
- noverlays = overlays_at (XINT (pos), 1, &overlay_vec, &len,
- (EMACS_INT *) 0, &prevpos, 1);
+ overlays_at (XINT (pos), 1, &overlay_vec, &len,
+ (EMACS_INT *) 0, &prevpos, 1);
xfree (overlay_vec);
return make_number (prevpos);
for (i = 0; i < size;)
{
- Lisp_Object prop, overlay;
- prop = copy[i++];
- overlay = copy[i++];
- call_overlay_mod_hooks (prop, overlay, after, arg1, arg2, arg3);
+ Lisp_Object prop_i, overlay_i;
+ prop_i = copy[i++];
+ overlay_i = copy[i++];
+ call_overlay_mod_hooks (prop_i, overlay_i, after, arg1, arg2, arg3);
}
}
UNGCPRO;
#define DEFVAR_PER_BUFFER(lname, vname, type, doc) \
do { \
static struct Lisp_Buffer_Objfwd bo_fwd; \
- defvar_per_buffer (&bo_fwd, lname, vname, type, 0); \
+ defvar_per_buffer (&bo_fwd, lname, vname, type); \
} while (0)
static void
defvar_per_buffer (struct Lisp_Buffer_Objfwd *bo_fwd, const char *namestring,
- Lisp_Object *address, Lisp_Object type, char *doc)
+ Lisp_Object *address, Lisp_Object type)
{
struct Lisp_Symbol *sym;
int offset;
bo_fwd->type = Lisp_Fwd_Buffer_Obj;
bo_fwd->offset = offset;
bo_fwd->slottype = type;
+ sym->declared_special = 1;
sym->redirect = SYMBOL_FORWARDED;
{
/* I tried to do the job without a cast, but it seems impossible.
HCoop / bpt / emacs.git / blobdiff