int last_per_buffer_idx;
+INFUN (Fset_buffer_major_mode, 1);
+INFUN (Fdelete_overlay, 1);
static void call_overlay_mod_hooks (Lisp_Object list, Lisp_Object overlay,
int after, Lisp_Object arg1,
Lisp_Object arg2, Lisp_Object arg3);
to prevent lossage due to user rplac'ing this alist or its elements. */
Lisp_Object Vbuffer_alist;
-Lisp_Object Qkill_buffer_query_functions;
+static Lisp_Object Qkill_buffer_query_functions;
/* Hook run before changing a major mode. */
-Lisp_Object Qchange_major_mode_hook;
+static Lisp_Object Qchange_major_mode_hook;
Lisp_Object Qfirst_change_hook;
Lisp_Object Qbefore_change_functions;
Lisp_Object Qafter_change_functions;
-Lisp_Object Qucs_set_table_for_input;
+static Lisp_Object Qucs_set_table_for_input;
-Lisp_Object Qfundamental_mode, Qmode_class, Qpermanent_local;
-Lisp_Object Qpermanent_local_hook;
+static Lisp_Object Qfundamental_mode, Qmode_class, Qpermanent_local;
+static Lisp_Object Qpermanent_local_hook;
-Lisp_Object Qprotected_field;
+static Lisp_Object Qprotected_field;
-Lisp_Object QSFundamental; /* A string "Fundamental" */
+static Lisp_Object QSFundamental; /* A string "Fundamental" */
-Lisp_Object Qkill_buffer_hook;
+static Lisp_Object Qkill_buffer_hook;
-Lisp_Object Qget_file_buffer;
+static Lisp_Object Qget_file_buffer;
-Lisp_Object Qoverlayp;
+static Lisp_Object Qoverlayp;
-Lisp_Object Qpriority, Qevaporate, Qbefore_string, Qafter_string;
+Lisp_Object Qpriority, Qbefore_string, Qafter_string;
+static Lisp_Object Qevaporate;
Lisp_Object Qmodification_hooks;
Lisp_Object Qinsert_in_front_hooks;
error ("Invalid buffer argument");
}
\f
-DEFUN ("buffer-live-p", Fbuffer_live_p, Sbuffer_live_p, 1, 1, 0,
+DEFUE ("buffer-live-p", Fbuffer_live_p, Sbuffer_live_p, 1, 1, 0,
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. */)
(Lisp_Object object)
return Qnil;
}
-DEFUN ("get-buffer", Fget_buffer, Sget_buffer, 1, 1, 0,
+DEFUE ("get-buffer", Fget_buffer, Sget_buffer, 1, 1, 0,
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
/* 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,
+DEFUE ("get-buffer-create", Fget_buffer_create, Sget_buffer_create, 1, 1, 0,
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
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,
- 1, 2, 0,
+DEFUE ("generate-new-buffer-name", Fgenerate_new_buffer_name,
+ Sgenerate_new_buffer_name, 1, 2, 0,
doc: /* Return a string that is the name of no existing buffer based on NAME.
If there is no live buffer named NAME, then return NAME.
Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
}
\f
-DEFUN ("buffer-name", Fbuffer_name, Sbuffer_name, 0, 1, 0,
+DEFUE ("buffer-name", Fbuffer_name, Sbuffer_name, 0, 1, 0,
doc: /* Return the name of BUFFER, as a string.
BUFFER defaults to the current buffer.
Return nil if BUFFER has been killed. */)
return BVAR (XBUFFER (buffer), name);
}
-DEFUN ("buffer-file-name", Fbuffer_file_name, Sbuffer_file_name, 0, 1, 0,
+DEFUE ("buffer-file-name", Fbuffer_file_name, Sbuffer_file_name, 0, 1, 0,
doc: /* Return name of file BUFFER is visiting, or nil if none.
No argument or nil as argument means use the current buffer. */)
(register Lisp_Object buffer)
return base_buffer;
}
-DEFUN ("buffer-local-value", Fbuffer_local_value,
+DEFUE ("buffer-local-value", Fbuffer_local_value,
Sbuffer_local_value, 2, 2, 0,
doc: /* Return the value of VARIABLE in BUFFER.
If VARIABLE does not have a buffer-local binding in BUFFER, the value
return result;
}
\f
-DEFUN ("buffer-modified-p", Fbuffer_modified_p, Sbuffer_modified_p,
+DEFUE ("buffer-modified-p", Fbuffer_modified_p, Sbuffer_modified_p,
0, 1, 0,
doc: /* Return t if BUFFER was modified since its file was last read or saved.
No argument or nil as argument means use current buffer as BUFFER. */)
return BUF_SAVE_MODIFF (buf) < BUF_MODIFF (buf) ? Qt : Qnil;
}
-DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p, Sset_buffer_modified_p,
+DEFUE ("set-buffer-modified-p", Fset_buffer_modified_p, Sset_buffer_modified_p,
1, 1, 0,
doc: /* Mark current buffer as modified or unmodified according to FLAG.
A non-nil FLAG means mark the buffer modified. */)
return BVAR (current_buffer, name);
}
-DEFUN ("other-buffer", Fother_buffer, Sother_buffer, 0, 3, 0,
+DEFUE ("other-buffer", Fother_buffer, Sother_buffer, 0, 3, 0,
doc: /* Return most recently selected buffer other than BUFFER.
Buffers not visible in windows are preferred to visible buffers,
unless optional second argument VISIBLE-OK is non-nil.
If BUFFER is omitted or nil, some interesting buffer is returned. */)
(register Lisp_Object buffer, Lisp_Object visible_ok, Lisp_Object frame)
{
- Lisp_Object Fset_buffer_major_mode (Lisp_Object buffer);
register Lisp_Object tail, buf, notsogood, tem, pred, add_ons;
notsogood = Qnil;
return buf;
}
\f
-DEFUN ("buffer-enable-undo", Fbuffer_enable_undo, Sbuffer_enable_undo,
+DEFUE ("buffer-enable-undo", Fbuffer_enable_undo, Sbuffer_enable_undo,
0, 1, "",
doc: /* Start keeping undo information for buffer BUFFER.
No argument or nil as argument means do this for the current buffer. */)
The buffer being killed will be current while the hook is running.\n\
See `kill-buffer'."
*/
-DEFUN ("kill-buffer", Fkill_buffer, Skill_buffer, 0, 1, "bKill buffer: ",
+DEFUE ("kill-buffer", Fkill_buffer, Skill_buffer, 0, 1, "bKill buffer: ",
doc: /* Kill buffer BUFFER-OR-NAME.
The argument may be a buffer or the name of an existing buffer.
Argument nil or omitted means kill the current buffer. Return t if the
return switch_to_buffer_1 (buffer_or_name, norecord);
}
-DEFUN ("current-buffer", Fcurrent_buffer, Scurrent_buffer, 0, 0, 0,
+DEFUE ("current-buffer", Fcurrent_buffer, Scurrent_buffer, 0, 0, 0,
doc: /* Return the current buffer as a Lisp object. */)
(void)
{
fetch_buffer_markers (b);
}
-DEFUN ("set-buffer", Fset_buffer, Sset_buffer, 1, 1, 0,
+DEFUE ("set-buffer", Fset_buffer, Sset_buffer, 1, 1, 0,
doc: /* Make buffer BUFFER-OR-NAME current for editing operations.
BUFFER-OR-NAME may be a buffer or the name of an existing buffer. See
also `save-excursion' when you want to make a buffer current
return Qnil;
}
\f
-DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only,
+DEFUE ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only,
Sbarf_if_buffer_read_only, 0, 0, 0,
doc: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
(void)
return Qnil;
}
\f
-DEFUN ("erase-buffer", Ferase_buffer, Serase_buffer, 0, 0, "*",
+DEFUE ("erase-buffer", Ferase_buffer, Serase_buffer, 0, 0, "*",
doc: /* Delete the entire contents of the current buffer.
Any narrowing restriction in effect (see `narrow-to-region') is removed,
so the buffer is truly empty after this. */)
return Qnil;
}
-DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte, Sset_buffer_multibyte,
+DEFUE ("set-buffer-multibyte", Fset_buffer_multibyte, Sset_buffer_multibyte,
1, 1, 0,
doc: /* Set the multibyte flag of the current buffer to FLAG.
If FLAG is t, this makes the buffer a multibyte buffer.
return flag;
}
\f
-DEFUN ("kill-all-local-variables", Fkill_all_local_variables, Skill_all_local_variables,
- 0, 0, 0,
+DEFUE ("kill-all-local-variables", Fkill_all_local_variables,
+ Skill_all_local_variables, 0, 0, 0,
doc: /* Switch to Fundamental mode by killing current buffer's local variables.
Most local variable bindings are eliminated so that the default values
become effective once more. Also, the syntax table is set from
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. */
\f
/* Overlay dissection functions. */
-DEFUN ("overlay-start", Foverlay_start, Soverlay_start, 1, 1, 0,
+DEFUE ("overlay-start", Foverlay_start, Soverlay_start, 1, 1, 0,
doc: /* Return the position at which OVERLAY starts. */)
(Lisp_Object overlay)
{
return (Fmarker_position (OVERLAY_START (overlay)));
}
-DEFUN ("overlay-end", Foverlay_end, Soverlay_end, 1, 1, 0,
+DEFUE ("overlay-end", Foverlay_end, Soverlay_end, 1, 1, 0,
doc: /* Return the position at which OVERLAY ends. */)
(Lisp_Object overlay)
{
return result;
}
-DEFUN ("next-overlay-change", Fnext_overlay_change, Snext_overlay_change,
+DEFUE ("next-overlay-change", Fnext_overlay_change, Snext_overlay_change,
1, 1, 0,
doc: /* Return the next position after POS where an overlay starts or ends.
If there are no overlay boundaries from POS to (point-max),
return make_number (endpos);
}
-DEFUN ("previous-overlay-change", Fprevious_overlay_change,
+DEFUE ("previous-overlay-change", Fprevious_overlay_change,
Sprevious_overlay_change, 1, 1, 0,
doc: /* Return the previous position before POS where an overlay starts or ends.
If there are no overlay boundaries from (point-min) to POS,
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);
return Qnil;
}
\f
-DEFUN ("overlay-get", Foverlay_get, Soverlay_get, 2, 2, 0,
+DEFUE ("overlay-get", Foverlay_get, Soverlay_get, 2, 2, 0,
doc: /* Get the property of overlay OVERLAY with property name PROP. */)
(Lisp_Object overlay, Lisp_Object prop)
{
#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