/* Lisp_Object Qlisp_mode, Vcheck_symbol; */
void
-nsberror (spec)
- Lisp_Object spec;
+nsberror (Lisp_Object spec)
{
if (STRINGP (spec))
error ("No buffer named %s", SDATA (spec));
and don't ever QUIT. */
static Lisp_Object
-assoc_ignore_text_properties (key, list)
- register Lisp_Object key;
- Lisp_Object list;
+assoc_ignore_text_properties (register Lisp_Object key, Lisp_Object list)
{
register Lisp_Object tail;
for (tail = list; CONSP (tail); tail = XCDR (tail))
}
Lisp_Object
-get_truename_buffer (filename)
- register Lisp_Object filename;
+get_truename_buffer (register Lisp_Object filename)
{
register Lisp_Object tail, buf, tem;
LIST, but for buffer B. */
static struct Lisp_Overlay *
-copy_overlays (b, list)
- struct buffer *b;
- struct Lisp_Overlay *list;
+copy_overlays (struct buffer *b, struct Lisp_Overlay *list)
{
Lisp_Object buffer;
struct Lisp_Overlay *result = NULL, *tail = NULL;
copied. */
static void
-clone_per_buffer_values (from, to)
- struct buffer *from, *to;
+clone_per_buffer_values (struct buffer *from, struct buffer *to)
{
Lisp_Object to_buffer;
int offset;
}
void
-delete_all_overlays (b)
- struct buffer *b;
+delete_all_overlays (struct buffer *b)
{
Lisp_Object overlay;
claims it doesn't belong to it. */
void
-reset_buffer (b)
- register struct buffer *b;
+reset_buffer (register struct buffer *b)
{
b->filename = Qnil;
b->file_truename = Qnil;
we preserve those. */
static void
-reset_buffer_local_variables (b, permanent_too)
- register struct buffer *b;
- int permanent_too;
+reset_buffer_local_variables (register struct buffer *b, int permanent_too)
{
register int offset;
int i;
in special slots in the buffer object. */
static Lisp_Object
-buffer_lisp_local_variables (buf)
- struct buffer *buf;
+buffer_lisp_local_variables (struct buffer *buf)
{
Lisp_Object result = Qnil;
register Lisp_Object tail;
(buffer, visible_ok, frame)
register Lisp_Object buffer, visible_ok, frame;
{
- Lisp_Object Fset_buffer_major_mode ();
+ Lisp_Object Fset_buffer_major_mode (Lisp_Object buffer);
register Lisp_Object tail, buf, notsogood, tem, pred, add_ons;
notsogood = Qnil;
means that other_buffer is more likely to choose a relevant buffer. */
void
-record_buffer (buf)
- Lisp_Object buf;
+record_buffer (Lisp_Object buf)
{
register Lisp_Object link, prev;
Lisp_Object frame;
If NORECORD is non-nil, don't call record_buffer. */
Lisp_Object
-switch_to_buffer_1 (buffer_or_name, norecord)
- Lisp_Object buffer_or_name, norecord;
+switch_to_buffer_1 (Lisp_Object buffer_or_name, Lisp_Object norecord)
{
register Lisp_Object buffer;
time, and that increments windows_or_buffers_changed. */
void
-set_buffer_internal (b)
- register struct buffer *b;
+set_buffer_internal (register struct buffer *b)
{
if (current_buffer != b)
set_buffer_internal_1 (b);
This is used by redisplay. */
void
-set_buffer_internal_1 (b)
- register struct buffer *b;
+set_buffer_internal_1 (register struct buffer *b)
{
register struct buffer *old_buf;
register Lisp_Object tail;
This avoids certain things that don't need to be done within redisplay. */
void
-set_buffer_temp (b)
- struct buffer *b;
+set_buffer_temp (struct buffer *b)
{
register struct buffer *old_buf;
/* Set the current buffer to BUFFER provided it is alive. */
Lisp_Object
-set_buffer_if_live (buffer)
- Lisp_Object buffer;
+set_buffer_if_live (Lisp_Object buffer)
{
if (! NILP (XBUFFER (buffer)->name))
Fset_buffer (buffer);
}
void
-validate_region (b, e)
- register Lisp_Object *b, *e;
+validate_region (register Lisp_Object *b, register Lisp_Object *e)
{
CHECK_NUMBER_COERCE_MARKER (*b);
CHECK_NUMBER_COERCE_MARKER (*e);
and return the adjusted position. */
static int
-advance_to_char_boundary (byte_pos)
- int byte_pos;
+advance_to_char_boundary (int byte_pos)
{
int c;
for their current values. */
static void
-swap_out_buffer_local_variables (b)
- struct buffer *b;
+swap_out_buffer_local_variables (struct buffer *b)
{
Lisp_Object oalist, alist, buffer;
default (BEGV or ZV). */
int
-overlays_at (pos, extend, vec_ptr, len_ptr, next_ptr, prev_ptr, change_req)
- EMACS_INT pos;
- int extend;
- Lisp_Object **vec_ptr;
- int *len_ptr;
- EMACS_INT *next_ptr;
- EMACS_INT *prev_ptr;
- int change_req;
+overlays_at (EMACS_INT pos, int extend, Lisp_Object **vec_ptr, int *len_ptr,
+ EMACS_INT *next_ptr, EMACS_INT *prev_ptr, int change_req)
{
Lisp_Object overlay, start, end;
struct Lisp_Overlay *tail;
But we still return the total number of overlays. */
static int
-overlays_in (beg, end, extend, vec_ptr, len_ptr, next_ptr, prev_ptr)
- int beg, end;
- int extend;
- Lisp_Object **vec_ptr;
- int *len_ptr;
- int *next_ptr;
- int *prev_ptr;
+overlays_in (int beg, int end, int extend, Lisp_Object **vec_ptr, int *len_ptr,
+ int *next_ptr, int *prev_ptr)
{
Lisp_Object overlay, ostart, oend;
struct Lisp_Overlay *tail;
`mouse-face' property overlapping OVERLAY. */
int
-mouse_face_overlay_overlaps (overlay)
- Lisp_Object overlay;
+mouse_face_overlay_overlaps (Lisp_Object overlay)
{
int start = OVERLAY_POSITION (OVERLAY_START (overlay));
int end = OVERLAY_POSITION (OVERLAY_END (overlay));
\f
/* Fast function to just test if we're at an overlay boundary. */
int
-overlay_touches_p (pos)
- int pos;
+overlay_touches_p (int pos)
{
Lisp_Object overlay;
struct Lisp_Overlay *tail;
};
static int
-compare_overlays (v1, v2)
- const void *v1, *v2;
+compare_overlays (const void *v1, const void *v2)
{
const struct sortvec *s1 = (const struct sortvec *) v1;
const struct sortvec *s2 = (const struct sortvec *) v2;
The return value is the new size; this may be smaller than the original
size if some of the overlays were invalid or were window-specific. */
int
-sort_overlays (overlay_vec, noverlays, w)
- Lisp_Object *overlay_vec;
- int noverlays;
- struct window *w;
+sort_overlays (Lisp_Object *overlay_vec, int noverlays, struct window *w)
{
int i, j;
struct sortvec *sortvec;
/* A comparison function suitable for passing to qsort. */
static int
-cmp_for_strings (as1, as2)
- char *as1, *as2;
+cmp_for_strings (const void *as1, const void *as2)
{
struct sortstr *s1 = (struct sortstr *)as1;
struct sortstr *s2 = (struct sortstr *)as2;
}
static void
-record_overlay_string (ssl, str, str2, pri, size)
- struct sortstrlist *ssl;
- Lisp_Object str, str2, pri;
- int size;
+record_overlay_string (struct sortstrlist *ssl, Lisp_Object str, Lisp_Object str2, Lisp_Object pri, int size)
{
int nbytes;
subsequent calls. */
int
-overlay_strings (pos, w, pstr)
- EMACS_INT pos;
- struct window *w;
- unsigned char **pstr;
+overlay_strings (EMACS_INT pos, struct window *w, unsigned char **pstr)
{
Lisp_Object overlay, window, str;
struct Lisp_Overlay *ov;
/* Shift overlays in BUF's overlay lists, to center the lists at POS. */
void
-recenter_overlay_lists (buf, pos)
- struct buffer *buf;
- EMACS_INT pos;
+recenter_overlay_lists (struct buffer *buf, EMACS_INT pos)
{
Lisp_Object overlay, beg, end;
struct Lisp_Overlay *prev, *tail, *next;
}
void
-adjust_overlays_for_insert (pos, length)
- EMACS_INT pos;
- EMACS_INT length;
+adjust_overlays_for_insert (EMACS_INT pos, EMACS_INT length)
{
/* After an insertion, the lists are still sorted properly,
but we may need to update the value of the overlay center. */
}
void
-adjust_overlays_for_delete (pos, length)
- EMACS_INT pos;
- EMACS_INT length;
+adjust_overlays_for_delete (EMACS_INT pos, EMACS_INT length)
{
if (current_buffer->overlay_center < pos)
/* The deletion was to our right. No change needed; the before- and
Such an overlay might even have negative size at this point.
If so, we'll make the overlay empty. */
void
-fix_start_end_in_overlays (start, end)
- register int start, end;
+fix_start_end_in_overlays (register int start, register int end)
{
Lisp_Object overlay;
struct Lisp_Overlay *before_list, *after_list;
was at PREV, and now is at POS. */
void
-fix_overlays_before (bp, prev, pos)
- struct buffer *bp;
- EMACS_INT prev, pos;
+fix_overlays_before (struct buffer *bp, EMACS_INT prev, EMACS_INT pos)
{
/* If parent is nil, replace overlays_before; otherwise, parent->next. */
struct Lisp_Overlay *tail = bp->overlays_before, *parent = NULL, *right_pair;
/* Mark a section of BUF as needing redisplay because of overlays changes. */
static void
-modify_overlay (buf, start, end)
- struct buffer *buf;
- EMACS_INT start, end;
+modify_overlay (struct buffer *buf, EMACS_INT start, EMACS_INT end)
{
if (start > end)
{
}
\f
-Lisp_Object Fdelete_overlay ();
+Lisp_Object Fdelete_overlay (Lisp_Object overlay);
static struct Lisp_Overlay *
-unchain_overlay (list, overlay)
- struct Lisp_Overlay *list, *overlay;
+unchain_overlay (struct Lisp_Overlay *list, struct Lisp_Overlay *overlay)
{
struct Lisp_Overlay *tmp, *prev;
for (tmp = list, prev = NULL; tmp; prev = tmp, tmp = tmp->next)
to the end of last_overlay_modification_hooks. */
static void
-add_overlay_mod_hooklist (functionlist, overlay)
- Lisp_Object functionlist, overlay;
+add_overlay_mod_hooklist (Lisp_Object functionlist, Lisp_Object overlay)
{
int oldsize = XVECTOR (last_overlay_modification_hooks)->size;
and the length of deleted or replaced old text. */
void
-report_overlay_modification (start, end, after, arg1, arg2, arg3)
- Lisp_Object start, end;
- int after;
- Lisp_Object arg1, arg2, arg3;
+report_overlay_modification (Lisp_Object start, Lisp_Object end, int after,
+ Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3)
{
Lisp_Object prop, overlay;
struct Lisp_Overlay *tail;
}
static void
-call_overlay_mod_hooks (list, overlay, after, arg1, arg2, arg3)
- Lisp_Object list, overlay;
- int after;
- Lisp_Object arg1, arg2, arg3;
+call_overlay_mod_hooks (Lisp_Object list, Lisp_Object overlay, int after,
+ Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3)
{
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
/* Delete any zero-sized overlays at position POS, if the `evaporate'
property is set. */
void
-evaporate_overlays (pos)
- EMACS_INT pos;
+evaporate_overlays (EMACS_INT pos)
{
Lisp_Object overlay, hit_list;
struct Lisp_Overlay *tail;
in the slot with offset OFFSET. */
void
-buffer_slot_type_mismatch (newval, type)
- Lisp_Object newval;
- int type;
+buffer_slot_type_mismatch (Lisp_Object newval, int type)
{
Lisp_Object predicate;
/* Allocate NBYTES bytes for buffer B's text buffer. */
static void
-alloc_buffer_text (b, nbytes)
- struct buffer *b;
- size_t nbytes;
+alloc_buffer_text (struct buffer *b, size_t nbytes)
{
POINTER_TYPE *p;
/* Free buffer B's text buffer. */
static void
-free_buffer_text (b)
- struct buffer *b;
+free_buffer_text (struct buffer *b)
{
BLOCK_INPUT;
***********************************************************************/
void
-init_buffer_once ()
+init_buffer_once (void)
{
int idx;
}
void
-init_buffer ()
+init_buffer (void)
{
char *pwd;
Lisp_Object temp;
} while (0)
static void
-defvar_per_buffer (bo_fwd, namestring, address, type, doc)
- struct Lisp_Buffer_Objfwd *bo_fwd;
- char *namestring;
- Lisp_Object *address;
- Lisp_Object type;
- char *doc;
+defvar_per_buffer (struct Lisp_Buffer_Objfwd *bo_fwd, char *namestring,
+ Lisp_Object *address, Lisp_Object type, char *doc)
{
struct Lisp_Symbol *sym;
int offset;
/* initialize the buffer routines */
void
-syms_of_buffer ()
+syms_of_buffer (void)
{
staticpro (&last_overlay_modification_hooks);
last_overlay_modification_hooks
}
void
-keys_of_buffer ()
+keys_of_buffer (void)
{
initial_define_key (control_x_map, 'b', "switch-to-buffer");
initial_define_key (control_x_map, 'k', "kill-buffer");
HCoop / bpt / emacs.git / blobdiff