* src/alloc.c: Convert function definitions to standard C.
* src/atimer.c:
* src/bidi.c:
* src/bytecode.c:
* src/callint.c:
* src/callproc.c:
* src/casefiddle.c:
* src/casetab.c:
* src/category.c:
* src/ccl.c:
* src/character.c:
* src/charset.c:
* src/chartab.c:
* src/cmds.c:
* src/coding.c:
* src/composite.c:
* src/data.c:
* src/dbusbind.c:
* src/dired.c:
* src/dispnew.c:
* src/doc.c:
* src/doprnt.c:
* src/ecrt0.c:
* src/editfns.c:
* src/fileio.c:
* src/filelock.c:
* src/filemode.c:
* src/fns.c:
* src/font.c:
* src/fontset.c:
* src/frame.c:
* src/fringe.c:
* src/ftfont.c:
* src/ftxfont.c:
* src/gtkutil.c:
* src/indent.c:
* src/insdel.c:
* src/intervals.c:
* src/keymap.c:
* src/lread.c:
* src/macros.c:
* src/marker.c:
* src/md5.c:
* src/menu.c:
* src/minibuf.c:
* src/prefix-args.c:
* src/print.c:
* src/ralloc.c:
* src/regex.c:
* src/region-cache.c:
* src/scroll.c:
* src/search.c:
* src/sound.c:
* src/strftime.c:
* src/syntax.c:
* src/sysdep.c:
* src/termcap.c:
* src/terminal.c:
* src/terminfo.c:
* src/textprop.c:
* src/tparam.c:
* src/undo.c:
* src/unexelf.c:
* src/window.c:
* src/xfaces.c:
* src/xfns.c:
* src/xfont.c:
* src/xftfont.c:
* src/xgselect.c:
* src/xmenu.c:
* src/xrdb.c:
* src/xselect.c:
* src/xsettings.c:
* src/xsmfns.c:
* src/xterm.c: Likewise.
+2010-07-04 Dan Nicolaescu <dann@ics.uci.edu>
+
+ * alloc.c: Convert function definitions to standard C.
+ * atimer.c:
+ * bidi.c:
+ * bytecode.c:
+ * callint.c:
+ * callproc.c:
+ * casefiddle.c:
+ * casetab.c:
+ * category.c:
+ * ccl.c:
+ * character.c:
+ * charset.c:
+ * chartab.c:
+ * cmds.c:
+ * coding.c:
+ * composite.c:
+ * data.c:
+ * dbusbind.c:
+ * dired.c:
+ * dispnew.c:
+ * doc.c:
+ * doprnt.c:
+ * ecrt0.c:
+ * editfns.c:
+ * fileio.c:
+ * filelock.c:
+ * filemode.c:
+ * fns.c:
+ * font.c:
+ * fontset.c:
+ * frame.c:
+ * fringe.c:
+ * ftfont.c:
+ * ftxfont.c:
+ * gtkutil.c:
+ * indent.c:
+ * insdel.c:
+ * intervals.c:
+ * keymap.c:
+ * lread.c:
+ * macros.c:
+ * marker.c:
+ * md5.c:
+ * menu.c:
+ * minibuf.c:
+ * prefix-args.c:
+ * print.c:
+ * ralloc.c:
+ * regex.c:
+ * region-cache.c:
+ * scroll.c:
+ * search.c:
+ * sound.c:
+ * strftime.c:
+ * syntax.c:
+ * sysdep.c:
+ * termcap.c:
+ * terminal.c:
+ * terminfo.c:
+ * textprop.c:
+ * tparam.c:
+ * undo.c:
+ * unexelf.c:
+ * window.c:
+ * xfaces.c:
+ * xfns.c:
+ * xfont.c:
+ * xftfont.c:
+ * xgselect.c:
+ * xmenu.c:
+ * xrdb.c:
+ * xselect.c:
+ * xsettings.c:
+ * xsmfns.c:
+ * xterm.c: Likewise.
+
2010-07-03 Eli Zaretskii <eliz@gnu.org>
* msdos.c (IT_set_frame_parameters): Fix setting of colors in
static POINTER_TYPE *lisp_align_malloc (size_t, enum mem_type);
static POINTER_TYPE *lisp_malloc (size_t, enum mem_type);
-void refill_memory_reserve ();
+void refill_memory_reserve (void);
#if GC_MARK_STACK || defined GC_MALLOC_CHECK
/* Function malloc calls this if it finds we are near exhausting storage. */
void
-malloc_warning (str)
- char *str;
+malloc_warning (char *str)
{
pending_malloc_warning = str;
}
/* Display an already-pending malloc warning. */
void
-display_malloc_warning ()
+display_malloc_warning (void)
{
call3 (intern ("display-warning"),
intern ("alloc"),
/* Called if we can't allocate relocatable space for a buffer. */
void
-buffer_memory_full ()
+buffer_memory_full (void)
{
/* If buffers use the relocating allocator, no need to free
spare_memory, because we may have plenty of malloc space left
/* Like malloc but check for no memory and block interrupt input.. */
POINTER_TYPE *
-xmalloc (size)
- size_t size;
+xmalloc (size_t size)
{
register POINTER_TYPE *val;
/* Like realloc but check for no memory and block interrupt input.. */
POINTER_TYPE *
-xrealloc (block, size)
- POINTER_TYPE *block;
- size_t size;
+xrealloc (POINTER_TYPE *block, size_t size)
{
register POINTER_TYPE *val;
/* Like free but block interrupt input. */
void
-xfree (block)
- POINTER_TYPE *block;
+xfree (POINTER_TYPE *block)
{
if (!block)
return;
/* Like strdup, but uses xmalloc. */
char *
-xstrdup (s)
- const char *s;
+xstrdup (const char *s)
{
size_t len = strlen (s) + 1;
char *p = (char *) xmalloc (len);
/* Unwind for SAFE_ALLOCA */
Lisp_Object
-safe_alloca_unwind (arg)
- Lisp_Object arg;
+safe_alloca_unwind (Lisp_Object arg)
{
register struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
#endif
static POINTER_TYPE *
-lisp_malloc (nbytes, type)
- size_t nbytes;
- enum mem_type type;
+lisp_malloc (size_t nbytes, enum mem_type type)
{
register void *val;
call to lisp_malloc. */
static void
-lisp_free (block)
- POINTER_TYPE *block;
+lisp_free (POINTER_TYPE *block)
{
MALLOC_BLOCK_INPUT;
free (block);
Alignment is on a multiple of BLOCK_ALIGN and `nbytes' has to be
smaller or equal to BLOCK_BYTES. */
static POINTER_TYPE *
-lisp_align_malloc (nbytes, type)
- size_t nbytes;
- enum mem_type type;
+lisp_align_malloc (size_t nbytes, enum mem_type type)
{
void *base, *val;
struct ablocks *abase;
}
static void
-lisp_align_free (block)
- POINTER_TYPE *block;
+lisp_align_free (POINTER_TYPE *block)
{
struct ablock *ablock = block;
struct ablocks *abase = ABLOCK_ABASE (ablock);
a call to lisp_malloc. */
struct buffer *
-allocate_buffer ()
+allocate_buffer (void)
{
struct buffer *b
= (struct buffer *) lisp_malloc (sizeof (struct buffer),
/* Initialize interval allocation. */
static void
-init_intervals ()
+init_intervals (void)
{
interval_block = NULL;
interval_block_index = INTERVAL_BLOCK_SIZE;
/* Return a new interval. */
INTERVAL
-make_interval ()
+make_interval (void)
{
INTERVAL val;
/* Mark Lisp objects in interval I. */
static void
-mark_interval (i, dummy)
- register INTERVAL i;
- Lisp_Object dummy;
+mark_interval (register INTERVAL i, Lisp_Object dummy)
{
eassert (!i->gcmarkbit); /* Intervals are never shared. */
i->gcmarkbit = 1;
use the macro MARK_INTERVAL_TREE instead. */
static void
-mark_interval_tree (tree)
- register INTERVAL tree;
+mark_interval_tree (register INTERVAL tree)
{
/* No need to test if this tree has been marked already; this
function is always called through the MARK_INTERVAL_TREE macro,
/* Initialize string allocation. Called from init_alloc_once. */
static void
-init_strings ()
+init_strings (void)
{
total_strings = total_free_strings = total_string_size = 0;
oldest_sblock = current_sblock = large_sblocks = NULL;
/* Return a new Lisp_String. */
static struct Lisp_String *
-allocate_string ()
+allocate_string (void)
{
struct Lisp_String *s;
S->data if it was initially non-null. */
void
-allocate_string_data (s, nchars, nbytes)
- struct Lisp_String *s;
- int nchars, nbytes;
+allocate_string_data (struct Lisp_String *s, int nchars, int nbytes)
{
struct sdata *data, *old_data;
struct sblock *b;
/* Sweep and compact strings. */
static void
-sweep_strings ()
+sweep_strings (void)
{
struct string_block *b, *next;
struct string_block *live_blocks = NULL;
/* Free dead large strings. */
static void
-free_large_strings ()
+free_large_strings (void)
{
struct sblock *b, *next;
struct sblock *live_blocks = NULL;
data of live strings after compaction. */
static void
-compact_small_strings ()
+compact_small_strings (void)
{
struct sblock *b, *tb, *next;
struct sdata *from, *to, *end, *tb_end;
multibyte, depending on the contents. */
Lisp_Object
-make_string (contents, nbytes)
- const char *contents;
- int nbytes;
+make_string (const char *contents, int nbytes)
{
register Lisp_Object val;
int nchars, multibyte_nbytes;
/* Make an unibyte string from LENGTH bytes at CONTENTS. */
Lisp_Object
-make_unibyte_string (contents, length)
- const char *contents;
- int length;
+make_unibyte_string (const char *contents, int length)
{
register Lisp_Object val;
val = make_uninit_string (length);
bytes at CONTENTS. */
Lisp_Object
-make_multibyte_string (contents, nchars, nbytes)
- const char *contents;
- int nchars, nbytes;
+make_multibyte_string (const char *contents, int nchars, int nbytes)
{
register Lisp_Object val;
val = make_uninit_multibyte_string (nchars, nbytes);
CONTENTS. It is a multibyte string if NBYTES != NCHARS. */
Lisp_Object
-make_string_from_bytes (contents, nchars, nbytes)
- const char *contents;
- int nchars, nbytes;
+make_string_from_bytes (const char *contents, int nchars, int nbytes)
{
register Lisp_Object val;
val = make_uninit_multibyte_string (nchars, nbytes);
characters by itself. */
Lisp_Object
-make_specified_string (contents, nchars, nbytes, multibyte)
- const char *contents;
- int nchars, nbytes;
- int multibyte;
+make_specified_string (const char *contents, int nchars, int nbytes, int multibyte)
{
register Lisp_Object val;
data warrants. */
Lisp_Object
-build_string (str)
- const char *str;
+build_string (const char *str)
{
return make_string (str, strlen (str));
}
occupying LENGTH bytes. */
Lisp_Object
-make_uninit_string (length)
- int length;
+make_uninit_string (int length)
{
Lisp_Object val;
which occupy NBYTES bytes. */
Lisp_Object
-make_uninit_multibyte_string (nchars, nbytes)
- int nchars, nbytes;
+make_uninit_multibyte_string (int nchars, int nbytes)
{
Lisp_Object string;
struct Lisp_String *s;
/* Initialize float allocation. */
static void
-init_float ()
+init_float (void)
{
float_block = NULL;
float_block_index = FLOAT_BLOCK_SIZE; /* Force alloc of new float_block. */
/* Explicitly free a float cell by putting it on the free-list. */
static void
-free_float (ptr)
- struct Lisp_Float *ptr;
+free_float (struct Lisp_Float *ptr)
{
ptr->u.chain = float_free_list;
float_free_list = ptr;
/* Return a new float object with value FLOAT_VALUE. */
Lisp_Object
-make_float (float_value)
- double float_value;
+make_float (double float_value)
{
register Lisp_Object val;
/* Initialize cons allocation. */
static void
-init_cons ()
+init_cons (void)
{
cons_block = NULL;
cons_block_index = CONS_BLOCK_SIZE; /* Force alloc of new cons_block. */
/* Explicitly free a cons cell by putting it on the free-list. */
void
-free_cons (ptr)
- struct Lisp_Cons *ptr;
+free_cons (struct Lisp_Cons *ptr)
{
ptr->u.chain = cons_free_list;
#if GC_MARK_STACK
/* Get an error now if there's any junk in the cons free list. */
void
-check_cons_list ()
+check_cons_list (void)
{
#ifdef GC_CHECK_CONS_LIST
struct Lisp_Cons *tail = cons_free_list;
/* Make a list of 1, 2, 3, 4 or 5 specified objects. */
Lisp_Object
-list1 (arg1)
- Lisp_Object arg1;
+list1 (Lisp_Object arg1)
{
return Fcons (arg1, Qnil);
}
Lisp_Object
-list2 (arg1, arg2)
- Lisp_Object arg1, arg2;
+list2 (Lisp_Object arg1, Lisp_Object arg2)
{
return Fcons (arg1, Fcons (arg2, Qnil));
}
Lisp_Object
-list3 (arg1, arg2, arg3)
- Lisp_Object arg1, arg2, arg3;
+list3 (Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3)
{
return Fcons (arg1, Fcons (arg2, Fcons (arg3, Qnil)));
}
Lisp_Object
-list4 (arg1, arg2, arg3, arg4)
- Lisp_Object arg1, arg2, arg3, arg4;
+list4 (Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3, Lisp_Object arg4)
{
return Fcons (arg1, Fcons (arg2, Fcons (arg3, Fcons (arg4, Qnil))));
}
Lisp_Object
-list5 (arg1, arg2, arg3, arg4, arg5)
- Lisp_Object arg1, arg2, arg3, arg4, arg5;
+list5 (Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3, Lisp_Object arg4, Lisp_Object arg5)
{
return Fcons (arg1, Fcons (arg2, Fcons (arg3, Fcons (arg4,
Fcons (arg5, Qnil)))));
with room for LEN Lisp_Objects. */
static struct Lisp_Vector *
-allocate_vectorlike (len)
- EMACS_INT len;
+allocate_vectorlike (EMACS_INT len)
{
struct Lisp_Vector *p;
size_t nbytes;
/* Allocate a vector with NSLOTS slots. */
struct Lisp_Vector *
-allocate_vector (nslots)
- EMACS_INT nslots;
+allocate_vector (EMACS_INT nslots)
{
struct Lisp_Vector *v = allocate_vectorlike (nslots);
v->size = nslots;
/* Allocate other vector-like structures. */
struct Lisp_Vector *
-allocate_pseudovector (memlen, lisplen, tag)
- int memlen, lisplen;
- EMACS_INT tag;
+allocate_pseudovector (int memlen, int lisplen, EMACS_INT tag)
{
struct Lisp_Vector *v = allocate_vectorlike (memlen);
EMACS_INT i;
struct window *
-allocate_window ()
+allocate_window (void)
{
return ALLOCATE_PSEUDOVECTOR(struct window, current_matrix, PVEC_WINDOW);
}
struct terminal *
-allocate_terminal ()
+allocate_terminal (void)
{
struct terminal *t = ALLOCATE_PSEUDOVECTOR (struct terminal,
next_terminal, PVEC_TERMINAL);
}
struct frame *
-allocate_frame ()
+allocate_frame (void)
{
struct frame *f = ALLOCATE_PSEUDOVECTOR (struct frame,
face_cache, PVEC_FRAME);
struct Lisp_Process *
-allocate_process ()
+allocate_process (void)
{
return ALLOCATE_PSEUDOVECTOR (struct Lisp_Process, pid, PVEC_PROCESS);
}
/* Initialize symbol allocation. */
static void
-init_symbol ()
+init_symbol (void)
{
symbol_block = NULL;
symbol_block_index = SYMBOL_BLOCK_SIZE;
static int n_marker_blocks;
static void
-init_marker ()
+init_marker (void)
{
marker_block = NULL;
marker_block_index = MARKER_BLOCK_SIZE;
/* Return a newly allocated Lisp_Misc object, with no substructure. */
Lisp_Object
-allocate_misc ()
+allocate_misc (void)
{
Lisp_Object val;
/* Free a Lisp_Misc object */
void
-free_misc (misc)
- Lisp_Object misc;
+free_misc (Lisp_Object misc)
{
XMISCTYPE (misc) = Lisp_Misc_Free;
XMISC (misc)->u_free.chain = marker_free_list;
The unwind function can get the C values back using XSAVE_VALUE. */
Lisp_Object
-make_save_value (pointer, integer)
- void *pointer;
- int integer;
+make_save_value (void *pointer, int integer)
{
register Lisp_Object val;
register struct Lisp_Save_Value *p;
/* Put MARKER back on the free list after using it temporarily. */
void
-free_marker (marker)
- Lisp_Object marker;
+free_marker (Lisp_Object marker)
{
unchain_marker (XMARKER (marker));
free_misc (marker);
Any number of arguments, even zero arguments, are allowed. */
Lisp_Object
-make_event_array (nargs, args)
- register int nargs;
- Lisp_Object *args;
+make_event_array (register int nargs, Lisp_Object *args)
{
int i;
/* Called if malloc returns zero. */
void
-memory_full ()
+memory_full (void)
{
int i;
and also directly from this file, in case we're not using ralloc.c. */
void
-refill_memory_reserve ()
+refill_memory_reserve (void)
{
#ifndef SYSTEM_MALLOC
if (spare_memory[0] == 0)
/* Initialize this part of alloc.c. */
static void
-mem_init ()
+mem_init (void)
{
mem_z.left = mem_z.right = MEM_NIL;
mem_z.parent = NULL;
MEM_NIL if there is no node in the tree containing START. */
static INLINE struct mem_node *
-mem_find (start)
- void *start;
+mem_find (void *start)
{
struct mem_node *p;
pointer to the node that was inserted. */
static struct mem_node *
-mem_insert (start, end, type)
- void *start, *end;
- enum mem_type type;
+mem_insert (void *start, void *end, enum mem_type type)
{
struct mem_node *c, *parent, *x;
balance the tree, after node X has been inserted; X is always red. */
static void
-mem_insert_fixup (x)
- struct mem_node *x;
+mem_insert_fixup (struct mem_node *x)
{
while (x != mem_root && x->parent->color == MEM_RED)
{
b c a b */
static void
-mem_rotate_left (x)
- struct mem_node *x;
+mem_rotate_left (struct mem_node *x)
{
struct mem_node *y;
a b b c */
static void
-mem_rotate_right (x)
- struct mem_node *x;
+mem_rotate_right (struct mem_node *x)
{
struct mem_node *y = x->left;
/* Delete node Z from the tree. If Z is null or MEM_NIL, do nothing. */
static void
-mem_delete (z)
- struct mem_node *z;
+mem_delete (struct mem_node *z)
{
struct mem_node *x, *y;
deletion. */
static void
-mem_delete_fixup (x)
- struct mem_node *x;
+mem_delete_fixup (struct mem_node *x)
{
while (x != mem_root && x->color == MEM_BLACK)
{
the heap. M is a pointer to the mem_block for P. */
static INLINE int
-live_string_p (m, p)
- struct mem_node *m;
- void *p;
+live_string_p (struct mem_node *m, void *p)
{
if (m->type == MEM_TYPE_STRING)
{
the heap. M is a pointer to the mem_block for P. */
static INLINE int
-live_cons_p (m, p)
- struct mem_node *m;
- void *p;
+live_cons_p (struct mem_node *m, void *p)
{
if (m->type == MEM_TYPE_CONS)
{
the heap. M is a pointer to the mem_block for P. */
static INLINE int
-live_symbol_p (m, p)
- struct mem_node *m;
- void *p;
+live_symbol_p (struct mem_node *m, void *p)
{
if (m->type == MEM_TYPE_SYMBOL)
{
the heap. M is a pointer to the mem_block for P. */
static INLINE int
-live_float_p (m, p)
- struct mem_node *m;
- void *p;
+live_float_p (struct mem_node *m, void *p)
{
if (m->type == MEM_TYPE_FLOAT)
{
the heap. M is a pointer to the mem_block for P. */
static INLINE int
-live_misc_p (m, p)
- struct mem_node *m;
- void *p;
+live_misc_p (struct mem_node *m, void *p)
{
if (m->type == MEM_TYPE_MISC)
{
M is a pointer to the mem_block for P. */
static INLINE int
-live_vector_p (m, p)
- struct mem_node *m;
- void *p;
+live_vector_p (struct mem_node *m, void *p)
{
return (p == m->start && m->type == MEM_TYPE_VECTORLIKE);
}
pointer to the mem_block for P. */
static INLINE int
-live_buffer_p (m, p)
- struct mem_node *m;
- void *p;
+live_buffer_p (struct mem_node *m, void *p)
{
/* P must point to the start of the block, and the buffer
must not have been killed. */
/* Mark OBJ if we can prove it's a Lisp_Object. */
static INLINE void
-mark_maybe_object (obj)
- Lisp_Object obj;
+mark_maybe_object (Lisp_Object obj)
{
void *po = (void *) XPNTR (obj);
struct mem_node *m = mem_find (po);
marked. */
static INLINE void
-mark_maybe_pointer (p)
- void *p;
+mark_maybe_pointer (void *p)
{
struct mem_node *m;
or END+OFFSET..START. */
static void
-mark_memory (start, end, offset)
- void *start, *end;
- int offset;
+mark_memory (void *start, void *end, int offset)
{
Lisp_Object *p;
void **pp;
equally on the stack. */
static void
-mark_stack ()
+mark_stack (void)
{
int i;
/* jmp_buf may not be aligned enough on darwin-ppc64 */
/* Determine whether it is safe to access memory at address P. */
static int
-valid_pointer_p (p)
- void *p;
+valid_pointer_p (void *p)
{
#ifdef WINDOWSNT
return w32_valid_pointer_p (p, 16);
so it should only be used in code for manual debugging. */
int
-valid_lisp_object_p (obj)
- Lisp_Object obj;
+valid_lisp_object_p (Lisp_Object obj)
{
void *p;
#if GC_MARK_STACK
allocated. TYPE < 0 means it's not used for a Lisp object. */
static POINTER_TYPE *
-pure_alloc (size, type)
- size_t size;
- int type;
+pure_alloc (size_t size, int type)
{
POINTER_TYPE *result;
#ifdef USE_LSB_TAG
/* Print a warning if PURESIZE is too small. */
void
-check_pure_size ()
+check_pure_size (void)
{
if (pure_bytes_used_before_overflow)
message ("emacs:0:Pure Lisp storage overflow (approx. %d bytes needed)",
address. Return NULL if not found. */
static char *
-find_string_data_in_pure (data, nbytes)
- const char *data;
- int nbytes;
+find_string_data_in_pure (const char *data, int nbytes)
{
int i, skip, bm_skip[256], last_char_skip, infinity, start, start_max;
const unsigned char *p;
string; then the string is not protected from gc. */
Lisp_Object
-make_pure_string (data, nchars, nbytes, multibyte)
- const char *data;
- int nchars, nbytes;
- int multibyte;
+make_pure_string (const char *data, int nchars, int nbytes, int multibyte)
{
Lisp_Object string;
struct Lisp_String *s;
of CAR as car and CDR as cdr. */
Lisp_Object
-pure_cons (car, cdr)
- Lisp_Object car, cdr;
+pure_cons (Lisp_Object car, Lisp_Object cdr)
{
register Lisp_Object new;
struct Lisp_Cons *p;
/* Value is a float object with value NUM allocated from pure space. */
static Lisp_Object
-make_pure_float (num)
- double num;
+make_pure_float (double num)
{
register Lisp_Object new;
struct Lisp_Float *p;
pure space. */
Lisp_Object
-make_pure_vector (len)
- EMACS_INT len;
+make_pure_vector (EMACS_INT len)
{
Lisp_Object new;
struct Lisp_Vector *p;
VARADDRESS. */
void
-staticpro (varaddress)
- Lisp_Object *varaddress;
+staticpro (Lisp_Object *varaddress)
{
staticvec[staticidx++] = varaddress;
if (staticidx >= NSTATICS)
/* Temporarily prevent garbage collection. */
int
-inhibit_garbage_collection ()
+inhibit_garbage_collection (void)
{
int count = SPECPDL_INDEX ();
int nbits = min (VALBITS, BITS_PER_INT);
only interesting objects referenced from glyphs are strings. */
static void
-mark_glyph_matrix (matrix)
- struct glyph_matrix *matrix;
+mark_glyph_matrix (struct glyph_matrix *matrix)
{
struct glyph_row *row = matrix->rows;
struct glyph_row *end = row + matrix->nrows;
/* Mark Lisp faces in the face cache C. */
static void
-mark_face_cache (c)
- struct face_cache *c;
+mark_face_cache (struct face_cache *c)
{
if (c)
{
static int mark_object_loop_halt;
static void
-mark_vectorlike (ptr)
- struct Lisp_Vector *ptr;
+mark_vectorlike (struct Lisp_Vector *ptr)
{
register EMACS_INT size = ptr->size;
register int i;
symbols. */
static void
-mark_char_table (ptr)
- struct Lisp_Vector *ptr;
+mark_char_table (struct Lisp_Vector *ptr)
{
register EMACS_INT size = ptr->size & PSEUDOVECTOR_SIZE_MASK;
register int i;
}
void
-mark_object (arg)
- Lisp_Object arg;
+mark_object (Lisp_Object arg)
{
register Lisp_Object obj = arg;
#ifdef GC_CHECK_MARKED_OBJECTS
/* Mark the pointers in a buffer structure. */
static void
-mark_buffer (buf)
- Lisp_Object buf;
+mark_buffer (Lisp_Object buf)
{
register struct buffer *buffer = XBUFFER (buf);
register Lisp_Object *ptr, tmp;
either marked or does not need to be marked to survive. */
int
-survives_gc_p (obj)
- Lisp_Object obj;
+survives_gc_p (Lisp_Object obj)
{
int survives_p;
/* Sweep: find all structures not marked, and free them. */
static void
-gc_sweep ()
+gc_sweep (void)
{
/* Remove or mark entries in weak hash tables.
This must be done before any object is unmarked. */
int suppress_checking;
void
-die (msg, file, line)
- const char *msg;
- const char *file;
- int line;
+die (const char *msg, const char *file, int line)
{
fprintf (stderr, "\r\n%s:%d: Emacs fatal error: %s\r\n",
file, line, msg);
/* Initialization */
void
-init_alloc_once ()
+init_alloc_once (void)
{
/* Used to do Vpurify_flag = Qt here, but Qt isn't set up yet! */
purebeg = PUREBEG;
}
void
-init_alloc ()
+init_alloc (void)
{
gcprolist = 0;
byte_stack_list = 0;
}
void
-syms_of_alloc ()
+syms_of_alloc (void)
{
DEFVAR_INT ("gc-cons-threshold", &gc_cons_threshold,
doc: /* *Number of bytes of consing between garbage collections.
static void schedule_atimer (struct atimer *);
static struct atimer *append_atimer_lists (struct atimer *,
struct atimer *);
-SIGTYPE alarm_signal_handler ();
+SIGTYPE alarm_signal_handler (int signo);
/* Start a new atimer of type TYPE. TIME specifies when the timer is
to cancel_atimer; don't free it yourself. */
struct atimer *
-start_atimer (type, time, fn, client_data)
- enum atimer_type type;
- EMACS_TIME time;
- atimer_callback fn;
- void *client_data;
+start_atimer (enum atimer_type type, struct timeval time, atimer_callback fn, void *client_data)
{
struct atimer *t;
/* Cancel and free atimer TIMER. */
void
-cancel_atimer (timer)
- struct atimer *timer;
+cancel_atimer (struct atimer *timer)
{
int i;
result list. */
static struct atimer *
-append_atimer_lists (list1, list2)
- struct atimer *list1, *list2;
+append_atimer_lists (struct atimer *list1, struct atimer *list2)
{
if (list1 == NULL)
return list2;
/* Stop all timers except timer T. T null means stop all timers. */
void
-stop_other_atimers (t)
- struct atimer *t;
+stop_other_atimers (struct atimer *t)
{
BLOCK_ATIMERS;
stop_other_atimers. */
void
-run_all_atimers ()
+run_all_atimers (void)
{
if (stopped_atimers)
{
/* A version of run_all_timers suitable for a record_unwind_protect. */
Lisp_Object
-unwind_stop_other_atimers (dummy)
- Lisp_Object dummy;
+unwind_stop_other_atimers (Lisp_Object dummy)
{
run_all_atimers ();
return Qnil;
/* Arrange for a SIGALRM to arrive when the next timer is ripe. */
static void
-set_alarm ()
+set_alarm (void)
{
if (atimers)
{
already. */
static void
-schedule_atimer (t)
- struct atimer *t;
+schedule_atimer (struct atimer *t)
{
struct atimer *a = atimers, *prev = NULL;
}
static void
-run_timers ()
+run_timers (void)
{
EMACS_TIME now;
SIGALRM. */
SIGTYPE
-alarm_signal_handler (signo)
- int signo;
+alarm_signal_handler (int signo)
{
#ifndef SYNC_INPUT
SIGNAL_THREAD_CHECK (signo);
/* Call alarm_signal_handler for pending timers. */
void
-do_pending_atimers ()
+do_pending_atimers (void)
{
if (pending_atimers)
{
some systems like HPUX (see process.c). */
void
-turn_on_atimers (on)
- int on;
+turn_on_atimers (int on)
{
if (on)
{
void
-init_atimer ()
+init_atimer (void)
{
free_atimers = stopped_atimers = atimers = NULL;
pending_atimers = 0;
static Lisp_Object Qparagraph_start, Qparagraph_separate;
static void
-bidi_initialize ()
+bidi_initialize (void)
{
#include "biditype.h"
/* Mark objects on byte_stack_list. Called during GC. */
void
-mark_byte_stack ()
+mark_byte_stack (void)
{
struct byte_stack *stack;
Lisp_Object *obj;
counters. Called when GC has completed. */
void
-unmark_byte_stack ()
+unmark_byte_stack (void)
{
struct byte_stack *stack;
}
void
-syms_of_bytecode ()
+syms_of_bytecode (void)
{
Qbytecode = intern_c_string ("byte-code");
staticpro (&Qbytecode);
/* Quotify EXP: if EXP is constant, return it.
If EXP is not constant, return (quote EXP). */
Lisp_Object
-quotify_arg (exp)
- register Lisp_Object exp;
+quotify_arg (register Lisp_Object exp)
{
if (!INTEGERP (exp) && !STRINGP (exp)
&& !NILP (exp) && !EQ (exp, Qt))
/* Modify EXP by quotifying each element (except the first). */
Lisp_Object
-quotify_args (exp)
- Lisp_Object exp;
+quotify_args (Lisp_Object exp)
{
register Lisp_Object tail;
Lisp_Object next;
= {"", "point", "mark", "region-beginning", "region-end"};
static void
-check_mark (for_region)
- int for_region;
+check_mark (int for_region)
{
Lisp_Object tem;
tem = Fmarker_buffer (current_buffer->mark);
of VALUES to do its job. */
static void
-fix_command (input, values)
- Lisp_Object input, values;
+fix_command (Lisp_Object input, Lisp_Object values)
{
if (CONSP (input))
{
}
void
-syms_of_callint ()
+syms_of_callint (void)
{
point_marker = Fmake_marker ();
staticpro (&point_marker);
EXFUN (Fgetenv_internal, 2);
static Lisp_Object
-call_process_kill (fdpid)
- Lisp_Object fdpid;
+call_process_kill (Lisp_Object fdpid)
{
emacs_close (XFASTINT (Fcar (fdpid)));
EMACS_KILLPG (XFASTINT (Fcdr (fdpid)), SIGKILL);
}
Lisp_Object
-call_process_cleanup (arg)
- Lisp_Object arg;
+call_process_cleanup (Lisp_Object arg)
{
Lisp_Object fdpid = Fcdr (arg);
#if defined (MSDOS)
}
\f
static Lisp_Object
-delete_temp_file (name)
- Lisp_Object name;
+delete_temp_file (Lisp_Object name)
{
/* Suppress jka-compr handling, etc. */
int count = SPECPDL_INDEX ();
RETURN_UNGCPRO (unbind_to (count, Fcall_process (nargs, args)));
}
\f
-static int relocate_fd ();
+static int relocate_fd (int fd, int minfd);
static char **
add_env (char **env, char **new_env, char *string)
executable directory by the parent. */
int
-child_setup (in, out, err, new_argv, set_pgrp, current_dir)
- int in, out, err;
- register char **new_argv;
- int set_pgrp;
- Lisp_Object current_dir;
+child_setup (int in, int out, int err, register char **new_argv, int set_pgrp, Lisp_Object current_dir)
{
char **env;
char *pwd_var;
/* Move the file descriptor FD so that its number is not less than MINFD.
If the file descriptor is moved at all, the original is freed. */
static int
-relocate_fd (fd, minfd)
- int fd, minfd;
+relocate_fd (int fd, int minfd)
{
if (fd >= minfd)
return fd;
}
static int
-getenv_internal_1 (var, varlen, value, valuelen, env)
- char *var;
- int varlen;
- char **value;
- int *valuelen;
- Lisp_Object env;
+getenv_internal_1 (char *var, int varlen, char **value, int *valuelen, Lisp_Object env)
{
for (; CONSP (env); env = XCDR (env))
{
}
static int
-getenv_internal (var, varlen, value, valuelen, frame)
- char *var;
- int varlen;
- char **value;
- int *valuelen;
- Lisp_Object frame;
+getenv_internal (char *var, int varlen, char **value, int *valuelen, Lisp_Object frame)
{
/* Try to find VAR in Vprocess_environment first. */
if (getenv_internal_1 (var, varlen, value, valuelen,
/* A version of getenv that consults the Lisp environment lists,
easily callable from C. */
char *
-egetenv (var)
- char *var;
+egetenv (char *var)
{
char *value;
int valuelen;
/* This is run before init_cmdargs. */
void
-init_callproc_1 ()
+init_callproc_1 (void)
{
char *data_dir = egetenv ("EMACSDATA");
char *doc_dir = egetenv ("EMACSDOC");
/* This is run after init_cmdargs, when Vinstallation_directory is valid. */
void
-init_callproc ()
+init_callproc (void)
{
char *data_dir = egetenv ("EMACSDATA");
}
void
-set_initial_environment ()
+set_initial_environment (void)
{
register char **envp;
#ifndef CANNOT_DUMP
}
void
-syms_of_callproc ()
+syms_of_callproc (void)
{
#ifdef DOS_NT
Qbuffer_file_type = intern ("buffer-file-type");
Lisp_Object Qidentity;
\f
Lisp_Object
-casify_object (flag, obj)
- enum case_action flag;
- Lisp_Object obj;
+casify_object (enum case_action flag, Lisp_Object obj)
{
register int c, c1;
register int inword = flag == CASE_DOWN;
b and e specify range of buffer to operate on. */
void
-casify_region (flag, b, e)
- enum case_action flag;
- Lisp_Object b, e;
+casify_region (enum case_action flag, Lisp_Object b, Lisp_Object e)
{
register int c;
register int inword = flag == CASE_DOWN;
}
\f
static Lisp_Object
-operate_on_word (arg, newpoint)
- Lisp_Object arg;
- EMACS_INT *newpoint;
+operate_on_word (Lisp_Object arg, EMACS_INT *newpoint)
{
Lisp_Object val;
int farend;
}
\f
void
-syms_of_casefiddle ()
+syms_of_casefiddle (void)
{
Qidentity = intern_c_string ("identity");
staticpro (&Qidentity);
}
void
-keys_of_casefiddle ()
+keys_of_casefiddle (void)
{
initial_define_key (control_x_map, Ctl('U'), "upcase-region");
Fput (intern ("upcase-region"), Qdisabled, Qt);
int case_temp1;
Lisp_Object case_temp2;
-static void set_canon ();
-static void set_identity ();
-static void shuffle ();
+static void set_canon (Lisp_Object case_table, Lisp_Object range, Lisp_Object elt);
+static void set_identity (Lisp_Object table, Lisp_Object c, Lisp_Object elt);
+static void shuffle (Lisp_Object table, Lisp_Object c, Lisp_Object elt);
DEFUN ("case-table-p", Fcase_table_p, Scase_table_p, 1, 1, 0,
doc: /* Return t if OBJECT is a case table.
}
static Lisp_Object
-check_case_table (obj)
- Lisp_Object obj;
+check_case_table (Lisp_Object obj)
{
CHECK_TYPE (!NILP (Fcase_table_p (obj)), Qcase_table_p, obj);
return (obj);
return Vascii_downcase_table;
}
-static Lisp_Object set_case_table ();
+static Lisp_Object set_case_table (Lisp_Object table, int standard);
DEFUN ("set-case-table", Fset_case_table, Sset_case_table, 1, 1, 0,
doc: /* Select a new case table for the current buffer.
}
static Lisp_Object
-set_case_table (table, standard)
- Lisp_Object table;
- int standard;
+set_case_table (Lisp_Object table, int standard)
{
Lisp_Object up, canon, eqv;
CASE_TABLE. */
static void
-set_canon (case_table, range, elt)
- Lisp_Object case_table, range, elt;
+set_canon (Lisp_Object case_table, Lisp_Object range, Lisp_Object elt)
{
Lisp_Object up = XCHAR_TABLE (case_table)->extras[0];
Lisp_Object canon = XCHAR_TABLE (case_table)->extras[1];
character. This is called in map_char_table. */
static void
-set_identity (table, c, elt)
- Lisp_Object table, c, elt;
+set_identity (Lisp_Object table, Lisp_Object c, Lisp_Object elt)
{
if (NATNUMP (elt))
{
operated. */
static void
-shuffle (table, c, elt)
- Lisp_Object table, c, elt;
+shuffle (Lisp_Object table, Lisp_Object c, Lisp_Object elt)
{
if (NATNUMP (elt))
{
}
\f
void
-init_casetab_once ()
+init_casetab_once (void)
{
register int i;
Lisp_Object down, up;
}
void
-syms_of_casetab ()
+syms_of_casetab (void)
{
Qcase_table_p = intern_c_string ("case-table-p");
staticpro (&Qcase_table_p);
static Lisp_Object hash_get_category_set (Lisp_Object, Lisp_Object);
static Lisp_Object
-hash_get_category_set (table, category_set)
- Lisp_Object table, category_set;
+hash_get_category_set (Lisp_Object table, Lisp_Object category_set)
{
Lisp_Object val;
struct Lisp_Hash_Table *h;
\f
/* Category staff. */
-Lisp_Object check_category_table ();
+Lisp_Object check_category_table (Lisp_Object table);
DEFUN ("define-category", Fdefine_category, Sdefine_category, 2, 3, 0,
doc: /* Define CATEGORY as a category which is described by DOCSTRING.
wrong-type-argument. */
Lisp_Object
-check_category_table (table)
- Lisp_Object table;
+check_category_table (Lisp_Object table)
{
if (NILP (table))
return current_buffer->category_table;
static void
-copy_category_entry (table, c, val)
- Lisp_Object table, c, val;
+copy_category_entry (Lisp_Object table, Lisp_Object c, Lisp_Object val)
{
val = Fcopy_sequence (val);
if (CONSP (c))
binding TABLE to a sub char table. */
Lisp_Object
-copy_category_table (table)
- Lisp_Object table;
+copy_category_table (Lisp_Object table)
{
table = copy_char_table (table);
\f
Lisp_Object
-char_category_set (c)
- int c;
+char_category_set (int c)
{
return CHAR_TABLE_REF (current_buffer->category_table, c);
}
}
void
-set_category_set (category_set, category, val)
- Lisp_Object category_set, category, val;
+set_category_set (Lisp_Object category_set, Lisp_Object category, Lisp_Object val)
{
do {
int idx = XINT (category) / 8;
directly. */
int
-word_boundary_p (c1, c2)
- int c1, c2;
+word_boundary_p (int c1, int c2)
{
Lisp_Object category_set1, category_set2;
Lisp_Object tail;
\f
void
-init_category_once ()
+init_category_once (void)
{
/* This has to be done here, before we call Fmake_char_table. */
Qcategory_table = intern_c_string ("category-table");
}
void
-syms_of_category ()
+syms_of_category (void)
{
Qcategoryp = intern_c_string ("categoryp");
staticpro (&Qcategoryp);
static struct ccl_prog_stack ccl_prog_stack_struct[256];
void
-ccl_driver (ccl, source, destination, src_size, dst_size, charset_list)
- struct ccl_program *ccl;
- int *source, *destination;
- int src_size, dst_size;
- Lisp_Object charset_list;
+ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size, int dst_size, Lisp_Object charset_list)
{
register int *reg = ccl->reg;
register int ic = ccl->ic;
or nil if CCL contains invalid data. */
static Lisp_Object
-resolve_symbol_ccl_program (ccl)
- Lisp_Object ccl;
+resolve_symbol_ccl_program (Lisp_Object ccl)
{
int i, veclen, unresolved = 0;
Lisp_Object result, contents, val;
symbols, return Qnil. */
static Lisp_Object
-ccl_get_compiled_code (ccl_prog, idx)
- Lisp_Object ccl_prog;
- int *idx;
+ccl_get_compiled_code (Lisp_Object ccl_prog, int *idx)
{
Lisp_Object val, slot;
If CCL_PROG is nil, we just reset the structure pointed by CCL. */
int
-setup_ccl_program (ccl, ccl_prog)
- struct ccl_program *ccl;
- Lisp_Object ccl_prog;
+setup_ccl_program (struct ccl_program *ccl, Lisp_Object ccl_prog)
{
int i;
/* Check if CCL is updated or not. If not, re-setup members of CCL. */
int
-check_ccl_update (ccl)
- struct ccl_program *ccl;
+check_ccl_update (struct ccl_program *ccl)
{
Lisp_Object slot, ccl_prog;
void
-syms_of_ccl ()
+syms_of_ccl (void)
{
staticpro (&Vccl_program_table);
Vccl_program_table = Fmake_vector (make_number (32), Qnil);
character code if possible. Return the resulting code. */
int
-char_resolve_modifier_mask (c)
- int c;
+char_resolve_modifier_mask (int c)
{
/* A non-ASCII character can't reflect modifier bits to the code. */
if (! ASCII_CHAR_P ((c & ~CHAR_MODIFIER_MASK)))
handle them appropriately. */
int
-char_string (c, p)
- unsigned c;
- unsigned char *p;
+char_string (unsigned int c, unsigned char *p)
{
int bytes;
character) of the multibyte form. */
int
-string_char (p, advanced, len)
- const unsigned char *p;
- const unsigned char **advanced;
- int *len;
+string_char (const unsigned char *p, const unsigned char **advanced, int *len)
{
int c;
const unsigned char *saved_p = p;
case, translace C by all tables. */
int
-translate_char (table, c)
- Lisp_Object table;
- int c;
+translate_char (Lisp_Object table, int c)
{
if (CHAR_TABLE_P (table))
{
future. */
int
-multibyte_char_to_unibyte (c, rev_tbl)
- int c;
- Lisp_Object rev_tbl;
+multibyte_char_to_unibyte (int c, Lisp_Object rev_tbl)
{
if (c < 0x80)
return c;
by charset_unibyte. */
int
-multibyte_char_to_unibyte_safe (c)
- int c;
+multibyte_char_to_unibyte_safe (int c)
{
if (c < 0x80)
return c;
occupies on the screen. */
int
-strwidth (str, len)
- unsigned char *str;
- int len;
+strwidth (unsigned char *str, int len)
{
return c_string_width (str, len, -1, NULL, NULL);
}
in *NCHARS and *NBYTES respectively. */
int
-lisp_string_width (string, precision, nchars, nbytes)
- Lisp_Object string;
- int precision, *nchars, *nbytes;
+lisp_string_width (Lisp_Object string, int precision, int *nchars, int *nbytes)
{
int len = SCHARS (string);
/* This set multibyte to 0 even if STRING is multibyte when it
nil, we treat each byte as a character. */
EMACS_INT
-chars_in_text (ptr, nbytes)
- const unsigned char *ptr;
- EMACS_INT nbytes;
+chars_in_text (const unsigned char *ptr, EMACS_INT nbytes)
{
/* current_buffer is null at early stages of Emacs initialization. */
if (current_buffer == 0
ignores enable-multibyte-characters. */
EMACS_INT
-multibyte_chars_in_text (ptr, nbytes)
- const unsigned char *ptr;
- EMACS_INT nbytes;
+multibyte_chars_in_text (const unsigned char *ptr, EMACS_INT nbytes)
{
const unsigned char *endp = ptr + nbytes;
int chars = 0;
represented by 2-byte in a multibyte text. */
void
-parse_str_as_multibyte (str, len, nchars, nbytes)
- const unsigned char *str;
- int len, *nchars, *nbytes;
+parse_str_as_multibyte (const unsigned char *str, int len, int *nchars, int *nbytes)
{
const unsigned char *endp = str + len;
int n, chars = 0, bytes = 0;
resulting text. */
int
-str_as_multibyte (str, len, nbytes, nchars)
- unsigned char *str;
- int len, nbytes, *nchars;
+str_as_multibyte (unsigned char *str, int len, int nbytes, int *nchars)
{
unsigned char *p = str, *endp = str + nbytes;
unsigned char *to;
`str_to_multibyte'. */
int
-parse_str_to_multibyte (str, len)
- unsigned char *str;
- int len;
+parse_str_to_multibyte (unsigned char *str, int len)
{
unsigned char *endp = str + len;
int bytes;
enough. */
int
-str_to_multibyte (str, len, bytes)
- unsigned char *str;
- int len, bytes;
+str_to_multibyte (unsigned char *str, int len, int bytes)
{
unsigned char *p = str, *endp = str + bytes;
unsigned char *to;
unibyte. */
int
-str_as_unibyte (str, bytes)
- unsigned char *str;
- int bytes;
+str_as_unibyte (unsigned char *str, int bytes)
{
const unsigned char *p = str, *endp = str + bytes;
unsigned char *to;
Note: Currently the arg ACCEPT_LATIN_1 is not used. */
EMACS_INT
-str_to_unibyte (src, dst, chars, accept_latin_1)
- const unsigned char *src;
- unsigned char *dst;
- EMACS_INT chars;
- int accept_latin_1;
+str_to_unibyte (const unsigned char *src, unsigned char *dst, EMACS_INT chars, int accept_latin_1)
{
EMACS_INT i;
int
-string_count_byte8 (string)
- Lisp_Object string;
+string_count_byte8 (Lisp_Object string)
{
int multibyte = STRING_MULTIBYTE (string);
int nbytes = SBYTES (string);
Lisp_Object
-string_escape_byte8 (string)
- Lisp_Object string;
+string_escape_byte8 (Lisp_Object string)
{
int nchars = SCHARS (string);
int nbytes = SBYTES (string);
void
-init_character_once ()
+init_character_once (void)
{
}
#ifdef emacs
void
-syms_of_character ()
+syms_of_character (void)
{
DEFSYM (Qcharacterp, "characterp");
DEFSYM (Qauto_fill_chars, "auto-fill-chars");
*/
static void
-load_charset_map (charset, entries, n_entries, control_flag)
- struct charset *charset;
- struct charset_map_entries *entries;
- int n_entries;
- int control_flag;
+load_charset_map (struct charset *charset, struct charset_map_entries *entries, int n_entries, int control_flag)
{
Lisp_Object vec, table;
unsigned max_code = CHARSET_MAX_CODE (charset);
paying attention to comment charcter '#'. */
static INLINE unsigned
-read_hex (fp, eof)
- FILE *fp;
- int *eof;
+read_hex (FILE *fp, int *eof)
{
int c;
unsigned n;
extern void add_to_log (char *, Lisp_Object, Lisp_Object);
static void
-load_charset_map_from_file (charset, mapfile, control_flag)
- struct charset *charset;
- Lisp_Object mapfile;
- int control_flag;
+load_charset_map_from_file (struct charset *charset, Lisp_Object mapfile, int control_flag)
{
unsigned min_code = CHARSET_MIN_CODE (charset);
unsigned max_code = CHARSET_MAX_CODE (charset);
}
static void
-load_charset_map_from_vector (charset, vec, control_flag)
- struct charset *charset;
- Lisp_Object vec;
- int control_flag;
+load_charset_map_from_vector (struct charset *charset, Lisp_Object vec, int control_flag)
{
unsigned min_code = CHARSET_MIN_CODE (charset);
unsigned max_code = CHARSET_MAX_CODE (charset);
map it is (see the comment of load_charset_map for the detail). */
static void
-load_charset (charset, control_flag)
- struct charset *charset;
- int control_flag;
+load_charset (struct charset *charset, int control_flag)
{
Lisp_Object map;
unsigned from, unsigned to);
void
-map_charset_for_dump (c_function, function, arg, from, to)
- void (*c_function) (Lisp_Object, Lisp_Object);
- Lisp_Object function, arg;
- unsigned from, to;
+map_charset_for_dump (void (*c_function) (Lisp_Object, Lisp_Object), Lisp_Object function, Lisp_Object arg, unsigned int from, unsigned int to)
{
int from_idx = CODE_POINT_TO_INDEX (temp_charset_work->current, from);
int to_idx = CODE_POINT_TO_INDEX (temp_charset_work->current, to);
}
static void
-check_iso_charset_parameter (dimension, chars, final_char)
- Lisp_Object dimension, chars, final_char;
+check_iso_charset_parameter (Lisp_Object dimension, Lisp_Object chars, Lisp_Object final_char)
{
CHECK_NATNUM (dimension);
CHECK_NATNUM (chars);
*/
int
-string_xstring_p (string)
- Lisp_Object string;
+string_xstring_p (Lisp_Object string)
{
const unsigned char *p = SDATA (string);
const unsigned char *endp = p + SBYTES (string);
It may lookup a translation table TABLE if supplied. */
static void
-find_charsets_in_text (ptr, nchars, nbytes, charsets, table, multibyte)
- const unsigned char *ptr;
- EMACS_INT nchars, nbytes;
- Lisp_Object charsets, table;
- int multibyte;
+find_charsets_in_text (const unsigned char *ptr, EMACS_INT nchars, EMACS_INT nbytes, Lisp_Object charsets, Lisp_Object table, int multibyte)
{
const unsigned char *pend = ptr + nbytes;
value of Vchar_unify_table for C; i.e. it is nil, an integer, or a
charset symbol. */
int
-maybe_unify_char (c, val)
- int c;
- Lisp_Object val;
+maybe_unify_char (int c, Lisp_Object val)
{
struct charset *charset;
CHARSET. */
int
-decode_char (charset, code)
- struct charset *charset;
- unsigned code;
+decode_char (struct charset *charset, unsigned int code)
{
int c, char_index;
enum charset_method method = CHARSET_METHOD (charset);
use CHARSET's strict_max_char instead of max_char. */
unsigned
-encode_char (charset, c)
- struct charset *charset;
- int c;
+encode_char (struct charset *charset, int c)
{
unsigned code;
enum charset_method method = CHARSET_METHOD (charset);
Vcharset_ordered_list. */
struct charset *
-char_charset (c, charset_list, code_return)
- int c;
- Lisp_Object charset_list;
- unsigned *code_return;
+char_charset (int c, Lisp_Object charset_list, unsigned int *code_return)
{
int maybe_null = 0;
\f
void
-init_charset ()
+init_charset (void)
{
Lisp_Object tempdir;
tempdir = Fexpand_file_name (build_string ("charsets"), Vdata_directory);
void
-init_charset_once ()
+init_charset_once (void)
{
int i, j, k;
#ifdef emacs
void
-syms_of_charset ()
+syms_of_charset (void)
{
DEFSYM (Qcharsetp, "charsetp");
}
static Lisp_Object
-make_sub_char_table (depth, min_char, defalt)
- int depth, min_char;
- Lisp_Object defalt;
+make_sub_char_table (int depth, int min_char, Lisp_Object defalt)
{
Lisp_Object table;
int size = VECSIZE (struct Lisp_Sub_Char_Table) - 1 + chartab_size[depth];
}
static Lisp_Object
-char_table_ascii (table)
- Lisp_Object table;
+char_table_ascii (Lisp_Object table)
{
Lisp_Object sub;
}
Lisp_Object
-copy_sub_char_table (table)
- Lisp_Object table;
+copy_sub_char_table (Lisp_Object table)
{
Lisp_Object copy;
int depth = XINT (XSUB_CHAR_TABLE (table)->depth);
Lisp_Object
-copy_char_table (table)
- Lisp_Object table;
+copy_char_table (Lisp_Object table)
{
Lisp_Object copy;
int size = XCHAR_TABLE (table)->size & PSEUDOVECTOR_SIZE_MASK;
}
Lisp_Object
-sub_char_table_ref (table, c)
- Lisp_Object table;
- int c;
+sub_char_table_ref (Lisp_Object table, int c)
{
struct Lisp_Sub_Char_Table *tbl = XSUB_CHAR_TABLE (table);
int depth = XINT (tbl->depth);
}
Lisp_Object
-char_table_ref (table, c)
- Lisp_Object table;
- int c;
+char_table_ref (Lisp_Object table, int c)
{
struct Lisp_Char_Table *tbl = XCHAR_TABLE (table);
Lisp_Object val;
}
static Lisp_Object
-sub_char_table_ref_and_range (table, c, from, to, defalt)
- Lisp_Object table;
- int c;
- int *from, *to;
- Lisp_Object defalt;
+sub_char_table_ref_and_range (Lisp_Object table, int c, int *from, int *to, Lisp_Object defalt)
{
struct Lisp_Sub_Char_Table *tbl = XSUB_CHAR_TABLE (table);
int depth = XINT (tbl->depth);
1) are different from that of C. */
Lisp_Object
-char_table_ref_and_range (table, c, from, to)
- Lisp_Object table;
- int c;
- int *from, *to;
+char_table_ref_and_range (Lisp_Object table, int c, int *from, int *to)
{
struct Lisp_Char_Table *tbl = XCHAR_TABLE (table);
int index = CHARTAB_IDX (c, 0, 0), idx;
static void
-sub_char_table_set (table, c, val)
- Lisp_Object table;
- int c;
- Lisp_Object val;
+sub_char_table_set (Lisp_Object table, int c, Lisp_Object val)
{
struct Lisp_Sub_Char_Table *tbl = XSUB_CHAR_TABLE (table);
int depth = XINT ((tbl)->depth);
}
Lisp_Object
-char_table_set (table, c, val)
- Lisp_Object table;
- int c;
- Lisp_Object val;
+char_table_set (Lisp_Object table, int c, Lisp_Object val)
{
struct Lisp_Char_Table *tbl = XCHAR_TABLE (table);
}
static void
-sub_char_table_set_range (table, depth, min_char, from, to, val)
- Lisp_Object *table;
- int depth;
- int min_char;
- int from, to;
- Lisp_Object val;
+sub_char_table_set_range (Lisp_Object *table, int depth, int min_char, int from, int to, Lisp_Object val)
{
int max_char = min_char + chartab_chars[depth] - 1;
Lisp_Object
-char_table_set_range (table, from, to, val)
- Lisp_Object table;
- int from, to;
- Lisp_Object val;
+char_table_set_range (Lisp_Object table, int from, int to, Lisp_Object val)
{
struct Lisp_Char_Table *tbl = XCHAR_TABLE (table);
Lisp_Object *contents = tbl->contents;
integer. If the element is not a character, return CH itself. */
int
-char_table_translate (table, ch)
- Lisp_Object table;
- int ch;
+char_table_translate (Lisp_Object table, int ch)
{
Lisp_Object value;
value = Faref (table, make_number (ch));
}
static Lisp_Object
-optimize_sub_char_table (table, test)
- Lisp_Object table, test;
+optimize_sub_char_table (Lisp_Object table, Lisp_Object test)
{
struct Lisp_Sub_Char_Table *tbl = XSUB_CHAR_TABLE (table);
int depth = XINT (tbl->depth);
ARG is passed to C_FUNCTION when that is called. */
void
-map_char_table (c_function, function, table, arg)
- void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object);
- Lisp_Object function, table, arg;
+map_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object), Lisp_Object function, Lisp_Object table, Lisp_Object arg)
{
Lisp_Object range, val;
struct gcpro gcpro1, gcpro2, gcpro3;
\f
void
-syms_of_chartab ()
+syms_of_chartab (void)
{
defsubr (&Smake_char_table);
defsubr (&Schar_table_parent);
static Lisp_Object Qexpand_abbrev;
int
-internal_self_insert (c, noautofill)
- int c;
- int noautofill;
+internal_self_insert (int c, int noautofill)
{
int hairy = 0;
Lisp_Object tem;
/* module initialization */
void
-syms_of_cmds ()
+syms_of_cmds (void)
{
Qkill_backward_chars = intern_c_string ("kill-backward-chars");
staticpro (&Qkill_backward_chars);
}
void
-keys_of_cmds ()
+keys_of_cmds (void)
{
int n;
static void
-coding_set_source (coding)
- struct coding_system *coding;
+coding_set_source (struct coding_system *coding)
{
if (BUFFERP (coding->src_object))
{
}
static void
-coding_set_destination (coding)
- struct coding_system *coding;
+coding_set_destination (struct coding_system *coding)
{
if (BUFFERP (coding->dst_object))
{
static void
-coding_alloc_by_realloc (coding, bytes)
- struct coding_system *coding;
- EMACS_INT bytes;
+coding_alloc_by_realloc (struct coding_system *coding, EMACS_INT bytes)
{
coding->destination = (unsigned char *) xrealloc (coding->destination,
coding->dst_bytes + bytes);
}
static void
-coding_alloc_by_making_gap (coding, gap_head_used, bytes)
- struct coding_system *coding;
- EMACS_INT gap_head_used, bytes;
+coding_alloc_by_making_gap (struct coding_system *coding, EMACS_INT gap_head_used, EMACS_INT bytes)
{
if (EQ (coding->src_object, coding->dst_object))
{
static unsigned char *
-alloc_destination (coding, nbytes, dst)
- struct coding_system *coding;
- EMACS_INT nbytes;
- unsigned char *dst;
+alloc_destination (struct coding_system *coding, EMACS_INT nbytes, unsigned char *dst)
{
EMACS_INT offset = dst - coding->destination;
#define UTF_8_BOM_3 0xBF
static int
-detect_coding_utf_8 (coding, detect_info)
- struct coding_system *coding;
- struct coding_detection_info *detect_info;
+detect_coding_utf_8 (struct coding_system *coding, struct coding_detection_info *detect_info)
{
const unsigned char *src = coding->source, *src_base;
const unsigned char *src_end = coding->source + coding->src_bytes;
static void
-decode_coding_utf_8 (coding)
- struct coding_system *coding;
+decode_coding_utf_8 (struct coding_system *coding)
{
const unsigned char *src = coding->source + coding->consumed;
const unsigned char *src_end = coding->source + coding->src_bytes;
static int
-encode_coding_utf_8 (coding)
- struct coding_system *coding;
+encode_coding_utf_8 (struct coding_system *coding)
{
int multibytep = coding->dst_multibyte;
int *charbuf = coding->charbuf;
static int
-detect_coding_utf_16 (coding, detect_info)
- struct coding_system *coding;
- struct coding_detection_info *detect_info;
+detect_coding_utf_16 (struct coding_system *coding, struct coding_detection_info *detect_info)
{
const unsigned char *src = coding->source, *src_base = src;
const unsigned char *src_end = coding->source + coding->src_bytes;
}
static void
-decode_coding_utf_16 (coding)
- struct coding_system *coding;
+decode_coding_utf_16 (struct coding_system *coding)
{
const unsigned char *src = coding->source + coding->consumed;
const unsigned char *src_end = coding->source + coding->src_bytes;
}
static int
-encode_coding_utf_16 (coding)
- struct coding_system *coding;
+encode_coding_utf_16 (struct coding_system *coding)
{
int multibytep = coding->dst_multibyte;
int *charbuf = coding->charbuf;
else return 0. */
static int
-detect_coding_emacs_mule (coding, detect_info)
- struct coding_system *coding;
- struct coding_detection_info *detect_info;
+detect_coding_emacs_mule (struct coding_system *coding, struct coding_detection_info *detect_info)
{
const unsigned char *src = coding->source, *src_base;
const unsigned char *src_end = coding->source + coding->src_bytes;
-1. If SRC is too short, return -2. */
int
-emacs_mule_char (coding, src, nbytes, nchars, id, cmp_status)
- struct coding_system *coding;
- const unsigned char *src;
- int *nbytes, *nchars, *id;
- struct composition_status *cmp_status;
+emacs_mule_char (struct coding_system *coding, const unsigned char *src, int *nbytes, int *nchars, int *id, struct composition_status *cmp_status)
{
const unsigned char *src_end = coding->source + coding->src_bytes;
const unsigned char *src_base = src;
static int
-emacs_mule_finish_composition (charbuf, cmp_status)
- int *charbuf;
- struct composition_status *cmp_status;
+emacs_mule_finish_composition (int *charbuf, struct composition_status *cmp_status)
{
int idx = - cmp_status->length;
int new_chars;
static void
-decode_coding_emacs_mule (coding)
- struct coding_system *coding;
+decode_coding_emacs_mule (struct coding_system *coding)
{
const unsigned char *src = coding->source + coding->consumed;
const unsigned char *src_end = coding->source + coding->src_bytes;
static int
-encode_coding_emacs_mule (coding)
- struct coding_system *coding;
+encode_coding_emacs_mule (struct coding_system *coding)
{
int multibytep = coding->dst_multibyte;
int *charbuf = coding->charbuf;
(CODING_ISO_INITIAL (&coding_categories[category], 1) >= 0)
static void
-setup_iso_safe_charsets (attrs)
- Lisp_Object attrs;
+setup_iso_safe_charsets (Lisp_Object attrs)
{
Lisp_Object charset_list, safe_charsets;
Lisp_Object request;
If it is, return 1, else return 0. */
static int
-detect_coding_iso_2022 (coding, detect_info)
- struct coding_system *coding;
- struct coding_detection_info *detect_info;
+detect_coding_iso_2022 (struct coding_system *coding, struct coding_detection_info *detect_info)
{
const unsigned char *src = coding->source, *src_base = src;
const unsigned char *src_end = coding->source + coding->src_bytes;
static int finish_composition (int *, struct composition_status *);
static int
-finish_composition (charbuf, cmp_status)
- int *charbuf;
- struct composition_status *cmp_status;
+finish_composition (int *charbuf, struct composition_status *cmp_status)
{
int idx = - cmp_status->length;
int new_chars;
/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
static void
-decode_coding_iso_2022 (coding)
- struct coding_system *coding;
+decode_coding_iso_2022 (struct coding_system *coding)
{
const unsigned char *src = coding->source + coding->consumed;
const unsigned char *src_end = coding->source + coding->src_bytes;
Return new DST. */
unsigned char *
-encode_invocation_designation (charset, coding, dst, p_nchars)
- struct charset *charset;
- struct coding_system *coding;
- unsigned char *dst;
- int *p_nchars;
+encode_invocation_designation (struct charset *charset, struct coding_system *coding, unsigned char *dst, int *p_nchars)
{
int multibytep = coding->dst_multibyte;
int produced_chars = *p_nchars;
find all the necessary designations. */
static unsigned char *
-encode_designation_at_bol (coding, charbuf, charbuf_end, dst)
- struct coding_system *coding;
- int *charbuf, *charbuf_end;
- unsigned char *dst;
+encode_designation_at_bol (struct coding_system *coding, int *charbuf, int *charbuf_end, unsigned char *dst)
{
struct charset *charset;
/* Table of charsets to be designated to each graphic register. */
/* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions". */
static int
-encode_coding_iso_2022 (coding)
- struct coding_system *coding;
+encode_coding_iso_2022 (struct coding_system *coding)
{
int multibytep = coding->dst_multibyte;
int *charbuf = coding->charbuf;
CATEGORY_MASK_SJIS, else return 0. */
static int
-detect_coding_sjis (coding, detect_info)
- struct coding_system *coding;
- struct coding_detection_info *detect_info;
+detect_coding_sjis (struct coding_system *coding, struct coding_detection_info *detect_info)
{
const unsigned char *src = coding->source, *src_base;
const unsigned char *src_end = coding->source + coding->src_bytes;
CATEGORY_MASK_BIG5, else return 0. */
static int
-detect_coding_big5 (coding, detect_info)
- struct coding_system *coding;
- struct coding_detection_info *detect_info;
+detect_coding_big5 (struct coding_system *coding, struct coding_detection_info *detect_info)
{
const unsigned char *src = coding->source, *src_base;
const unsigned char *src_end = coding->source + coding->src_bytes;
If SJIS_P is 1, decode SJIS text, else decode BIG5 test. */
static void
-decode_coding_sjis (coding)
- struct coding_system *coding;
+decode_coding_sjis (struct coding_system *coding)
{
const unsigned char *src = coding->source + coding->consumed;
const unsigned char *src_end = coding->source + coding->src_bytes;
}
static void
-decode_coding_big5 (coding)
- struct coding_system *coding;
+decode_coding_big5 (struct coding_system *coding)
{
const unsigned char *src = coding->source + coding->consumed;
const unsigned char *src_end = coding->source + coding->src_bytes;
SJIS text, else encode BIG5 text. */
static int
-encode_coding_sjis (coding)
- struct coding_system *coding;
+encode_coding_sjis (struct coding_system *coding)
{
int multibytep = coding->dst_multibyte;
int *charbuf = coding->charbuf;
}
static int
-encode_coding_big5 (coding)
- struct coding_system *coding;
+encode_coding_big5 (struct coding_system *coding)
{
int multibytep = coding->dst_multibyte;
int *charbuf = coding->charbuf;
CATEGORY_MASK_CCL, else return 0. */
static int
-detect_coding_ccl (coding, detect_info)
- struct coding_system *coding;
- struct coding_detection_info *detect_info;
+detect_coding_ccl (struct coding_system *coding, struct coding_detection_info *detect_info)
{
const unsigned char *src = coding->source, *src_base;
const unsigned char *src_end = coding->source + coding->src_bytes;
}
static void
-decode_coding_ccl (coding)
- struct coding_system *coding;
+decode_coding_ccl (struct coding_system *coding)
{
const unsigned char *src = coding->source + coding->consumed;
const unsigned char *src_end = coding->source + coding->src_bytes;
}
static int
-encode_coding_ccl (coding)
- struct coding_system *coding;
+encode_coding_ccl (struct coding_system *coding)
{
struct ccl_program *ccl = &coding->spec.ccl->ccl;
int multibytep = coding->dst_multibyte;
/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
static void
-decode_coding_raw_text (coding)
- struct coding_system *coding;
+decode_coding_raw_text (struct coding_system *coding)
{
int eol_crlf =
!inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos);
}
static int
-encode_coding_raw_text (coding)
- struct coding_system *coding;
+encode_coding_raw_text (struct coding_system *coding)
{
int multibytep = coding->dst_multibyte;
int *charbuf = coding->charbuf;
is, return 1, else return 0. */
static int
-detect_coding_charset (coding, detect_info)
- struct coding_system *coding;
- struct coding_detection_info *detect_info;
+detect_coding_charset (struct coding_system *coding, struct coding_detection_info *detect_info)
{
const unsigned char *src = coding->source, *src_base;
const unsigned char *src_end = coding->source + coding->src_bytes;
}
static void
-decode_coding_charset (coding)
- struct coding_system *coding;
+decode_coding_charset (struct coding_system *coding)
{
const unsigned char *src = coding->source + coding->consumed;
const unsigned char *src_end = coding->source + coding->src_bytes;
}
static int
-encode_coding_charset (coding)
- struct coding_system *coding;
+encode_coding_charset (struct coding_system *coding)
{
int multibytep = coding->dst_multibyte;
int *charbuf = coding->charbuf;
CODING_SYSTEM is invalid, signal an error. */
void
-setup_coding_system (coding_system, coding)
- Lisp_Object coding_system;
- struct coding_system *coding;
+setup_coding_system (Lisp_Object coding_system, struct coding_system *coding)
{
Lisp_Object attrs;
Lisp_Object eol_type;
/* Return a list of charsets supported by CODING. */
Lisp_Object
-coding_charset_list (coding)
- struct coding_system *coding;
+coding_charset_list (struct coding_system *coding)
{
Lisp_Object attrs, charset_list;
/* Return a list of charsets supported by CODING-SYSTEM. */
Lisp_Object
-coding_system_charset_list (coding_system)
- Lisp_Object coding_system;
+coding_system_charset_list (Lisp_Object coding_system)
{
int id;
Lisp_Object attrs, charset_list;
eol_type as CODING-SYSTEM. */
Lisp_Object
-raw_text_coding_system (coding_system)
- Lisp_Object coding_system;
+raw_text_coding_system (Lisp_Object coding_system)
{
Lisp_Object spec, attrs;
Lisp_Object eol_type, raw_text_eol_type;
(system_eol_type). */
Lisp_Object
-coding_inherit_eol_type (coding_system, parent)
- Lisp_Object coding_system, parent;
+coding_inherit_eol_type (Lisp_Object coding_system, Lisp_Object parent)
{
Lisp_Object spec, eol_type;
#define MAX_EOL_CHECK_COUNT 3
static int
-detect_eol (source, src_bytes, category)
- const unsigned char *source;
- EMACS_INT src_bytes;
- enum coding_category category;
+detect_eol (const unsigned char *source, EMACS_INT src_bytes, enum coding_category category)
{
const unsigned char *src = source, *src_end = src + src_bytes;
unsigned char c;
static Lisp_Object
-adjust_coding_eol_type (coding, eol_seen)
- struct coding_system *coding;
- int eol_seen;
+adjust_coding_eol_type (struct coding_system *coding, int eol_seen)
{
Lisp_Object eol_type;
system. */
void
-detect_coding (coding)
- struct coding_system *coding;
+detect_coding (struct coding_system *coding)
{
const unsigned char *src, *src_end;
int saved_mode = coding->mode;
static void
-decode_eol (coding)
- struct coding_system *coding;
+decode_eol (struct coding_system *coding)
{
Lisp_Object eol_type;
unsigned char *p, *pbeg, *pend;
decoding (ENCODEP is zero). */
static Lisp_Object
-get_translation_table (attrs, encodep, max_lookup)
- Lisp_Object attrs;
- int encodep, *max_lookup;
+get_translation_table (Lisp_Object attrs, int encodep, int *max_lookup)
{
Lisp_Object standard, translation_table;
Lisp_Object val;
If BUF is too short to lookup characters in FROM, return Qt. */
static Lisp_Object
-get_translation (trans, buf, buf_end)
- Lisp_Object trans;
- int *buf, *buf_end;
+get_translation (Lisp_Object trans, int *buf, int *buf_end)
{
if (INTEGERP (trans))
static int
-produce_chars (coding, translation_table, last_block)
- struct coding_system *coding;
- Lisp_Object translation_table;
- int last_block;
+produce_chars (struct coding_system *coding, Lisp_Object translation_table, int last_block)
{
unsigned char *dst = coding->destination + coding->produced;
unsigned char *dst_end = coding->destination + coding->dst_bytes;
*/
static INLINE void
-produce_composition (coding, charbuf, pos)
- struct coding_system *coding;
- int *charbuf;
- EMACS_INT pos;
+produce_composition (struct coding_system *coding, int *charbuf, EMACS_INT pos)
{
int len;
EMACS_INT to;
*/
static INLINE void
-produce_charset (coding, charbuf, pos)
- struct coding_system *coding;
- int *charbuf;
- EMACS_INT pos;
+produce_charset (struct coding_system *coding, int *charbuf, EMACS_INT pos)
{
EMACS_INT from = pos - charbuf[2];
struct charset *charset = CHARSET_FROM_ID (charbuf[3]);
static void
-produce_annotation (coding, pos)
- struct coding_system *coding;
- EMACS_INT pos;
+produce_annotation (struct coding_system *coding, EMACS_INT pos)
{
int *charbuf = coding->charbuf;
int *charbuf_end = charbuf + coding->charbuf_used;
*/
static int
-decode_coding (coding)
- struct coding_system *coding;
+decode_coding (struct coding_system *coding)
{
Lisp_Object attrs;
Lisp_Object undo_list;
return BUF. */
static INLINE int *
-handle_composition_annotation (pos, limit, coding, buf, stop)
- EMACS_INT pos, limit;
- struct coding_system *coding;
- int *buf;
- EMACS_INT *stop;
+handle_composition_annotation (EMACS_INT pos, EMACS_INT limit, struct coding_system *coding, int *buf, EMACS_INT *stop)
{
EMACS_INT start, end;
Lisp_Object prop;
property value is non-nil (limiting by LIMIT), and return BUF. */
static INLINE int *
-handle_charset_annotation (pos, limit, coding, buf, stop)
- EMACS_INT pos, limit;
- struct coding_system *coding;
- int *buf;
- EMACS_INT *stop;
+handle_charset_annotation (EMACS_INT pos, EMACS_INT limit, struct coding_system *coding, int *buf, EMACS_INT *stop)
{
Lisp_Object val, next;
int id;
static void
-consume_chars (coding, translation_table, max_lookup)
- struct coding_system *coding;
- Lisp_Object translation_table;
- int max_lookup;
+consume_chars (struct coding_system *coding, Lisp_Object translation_table, int max_lookup)
{
int *buf = coding->charbuf;
int *buf_end = coding->charbuf + coding->charbuf_size;
memory area specified by CODING->destination. */
static int
-encode_coding (coding)
- struct coding_system *coding;
+encode_coding (struct coding_system *coding)
{
Lisp_Object attrs;
Lisp_Object translation_table;
multibyteness of returning buffer. */
static Lisp_Object
-make_conversion_work_buffer (multibyte)
- int multibyte;
+make_conversion_work_buffer (int multibyte)
{
Lisp_Object name, workbuf;
struct buffer *current;
static Lisp_Object
-code_conversion_restore (arg)
- Lisp_Object arg;
+code_conversion_restore (Lisp_Object arg)
{
Lisp_Object current, workbuf;
struct gcpro gcpro1;
}
Lisp_Object
-code_conversion_save (with_work_buf, multibyte)
- int with_work_buf, multibyte;
+code_conversion_save (int with_work_buf, int multibyte)
{
Lisp_Object workbuf = Qnil;
}
int
-decode_coding_gap (coding, chars, bytes)
- struct coding_system *coding;
- EMACS_INT chars, bytes;
+decode_coding_gap (struct coding_system *coding, EMACS_INT chars, EMACS_INT bytes)
{
int count = specpdl_ptr - specpdl;
Lisp_Object attrs;
}
int
-encode_coding_gap (coding, chars, bytes)
- struct coding_system *coding;
- EMACS_INT chars, bytes;
+encode_coding_gap (struct coding_system *coding, EMACS_INT chars, EMACS_INT bytes)
{
int count = specpdl_ptr - specpdl;
Lisp_Object
-preferred_coding_system ()
+preferred_coding_system (void)
{
int id = coding_categories[coding_priorities[0]].id;
static INLINE int
-char_encodable_p (c, attrs)
- int c;
- Lisp_Object attrs;
+char_encodable_p (int c, Lisp_Object attrs)
{
Lisp_Object tail;
struct charset *charset;
Lisp_Object
-code_convert_region (start, end, coding_system, dst_object, encodep, norecord)
- Lisp_Object start, end, coding_system, dst_object;
- int encodep, norecord;
+code_convert_region (Lisp_Object start, Lisp_Object end, Lisp_Object coding_system, Lisp_Object dst_object, int encodep, int norecord)
{
struct coding_system coding;
EMACS_INT from, from_byte, to, to_byte;
ENCODE_FILE, thus we ignore character composition. */
Lisp_Object
-code_convert_string_norecord (string, coding_system, encodep)
- Lisp_Object string, coding_system;
- int encodep;
+code_convert_string_norecord (Lisp_Object string, Lisp_Object coding_system, int encodep)
{
return code_convert_string (string, coding_system, Qt, encodep, 0, 1);
}
static const char *const suffixes[] = { "-unix", "-dos", "-mac" };
static Lisp_Object
-make_subsidiaries (base)
- Lisp_Object base;
+make_subsidiaries (Lisp_Object base)
{
Lisp_Object subsidiaries;
int base_name_len = SBYTES (SYMBOL_NAME (base));
/*** 9. Post-amble ***/
void
-init_coding_once ()
+init_coding_once (void)
{
int i;
#ifdef emacs
void
-syms_of_coding ()
+syms_of_coding (void)
{
staticpro (&Vcoding_system_hash_table);
{
}
char *
-emacs_strerror (error_number)
- int error_number;
+emacs_strerror (int error_number)
{
char *str;
If the composition is invalid, return -1. */
int
-get_composition_id (charpos, bytepos, nchars, prop, string)
- int charpos, bytepos, nchars;
- Lisp_Object prop, string;
+get_composition_id (int charpos, int bytepos, int nchars, Lisp_Object prop, Lisp_Object string)
{
Lisp_Object id, length, components, key, *key_contents;
int glyph_len;
This doesn't check the validity of composition. */
int
-find_composition (pos, limit, start, end, prop, object)
- int pos, limit;
- EMACS_INT *start, *end;
- Lisp_Object *prop, object;
+find_composition (int pos, int limit, EMACS_INT *start, EMACS_INT *end, Lisp_Object *prop, Lisp_Object object)
{
Lisp_Object val;
FROM and TO with property PROP. */
static void
-run_composition_function (from, to, prop)
- int from, to;
- Lisp_Object prop;
+run_composition_function (int from, int to, Lisp_Object prop)
{
Lisp_Object func;
EMACS_INT start, end;
change is deletion, FROM == TO. Otherwise, FROM < TO. */
void
-update_compositions (from, to, check_mask)
- EMACS_INT from, to;
- int check_mask;
+update_compositions (EMACS_INT from, EMACS_INT to, int check_mask)
{
Lisp_Object prop;
EMACS_INT start, end;
top-level copies of them so that none of them are `eq'. */
void
-make_composition_value_copy (list)
- Lisp_Object list;
+make_composition_value_copy (Lisp_Object list)
{
Lisp_Object plist, val;
indices START and END in STRING. */
void
-compose_text (start, end, components, modification_func, string)
- int start, end;
- Lisp_Object components, modification_func, string;
+compose_text (int start, int end, Lisp_Object components, Lisp_Object modification_func, Lisp_Object string)
{
Lisp_Object prop;
static Lisp_Object gstring_lookup_cache (Lisp_Object);
static Lisp_Object
-gstring_lookup_cache (header)
- Lisp_Object header;
+gstring_lookup_cache (Lisp_Object header)
{
struct Lisp_Hash_Table *h = XHASH_TABLE (gstring_hash_table);
int i = hash_lookup (h, header, NULL);
}
Lisp_Object
-composition_gstring_put_cache (gstring, len)
- Lisp_Object gstring;
- int len;
+composition_gstring_put_cache (Lisp_Object gstring, int len)
{
struct Lisp_Hash_Table *h = XHASH_TABLE (gstring_hash_table);
unsigned hash;
}
Lisp_Object
-composition_gstring_from_id (id)
- int id;
+composition_gstring_from_id (int id)
{
struct Lisp_Hash_Table *h = XHASH_TABLE (gstring_hash_table);
Lisp_Object);
int
-composition_gstring_p (gstring)
- Lisp_Object gstring;
+composition_gstring_p (Lisp_Object gstring)
{
Lisp_Object header;
int i;
}
int
-composition_gstring_width (gstring, from, to, metrics)
- Lisp_Object gstring;
- int from, to;
- struct font_metrics *metrics;
+composition_gstring_width (Lisp_Object gstring, int from, int to, struct font_metrics *metrics)
{
Lisp_Object *glyph;
int width = 0;
static Lisp_Object gstring_work_headers;
static Lisp_Object
-fill_gstring_header (header, start, end, font_object, string)
- Lisp_Object header, start, end, font_object, string;
+fill_gstring_header (Lisp_Object header, Lisp_Object start, Lisp_Object end, Lisp_Object font_object, Lisp_Object string)
{
EMACS_INT from, to, from_byte;
EMACS_INT len, i;
extern void font_fill_lglyph_metrics (Lisp_Object, Lisp_Object);
static void
-fill_gstring_body (gstring)
- Lisp_Object gstring;
+fill_gstring_body (Lisp_Object gstring)
{
Lisp_Object font_object = LGSTRING_FONT (gstring);
Lisp_Object header = AREF (gstring, 0);
object. Otherwise return nil. */
static Lisp_Object
-autocmp_chars (rule, charpos, bytepos, limit, win, face, string)
- Lisp_Object rule;
- EMACS_INT charpos, bytepos, limit;
- struct window *win;
- struct face *face;
- Lisp_Object string;
+autocmp_chars (Lisp_Object rule, EMACS_INT charpos, EMACS_INT bytepos, EMACS_INT limit, struct window *win, struct face *face, Lisp_Object string)
{
int count = SPECPDL_INDEX ();
FRAME_PTR f = XFRAME (win->frame);
composition. */
void
-composition_compute_stop_pos (cmp_it, charpos, bytepos, endpos, string)
- struct composition_it *cmp_it;
- EMACS_INT charpos, bytepos, endpos;
- Lisp_Object string;
+composition_compute_stop_pos (struct composition_it *cmp_it, EMACS_INT charpos, EMACS_INT bytepos, EMACS_INT endpos, Lisp_Object string)
{
EMACS_INT start, end, c;
Lisp_Object prop, val;
CMP_IT->stop_pos, and return 0. */
int
-composition_reseat_it (cmp_it, charpos, bytepos, endpos, w, face, string)
- struct composition_it *cmp_it;
- EMACS_INT charpos, bytepos, endpos;
- struct window *w;
- struct face *face;
- Lisp_Object string;
+composition_reseat_it (struct composition_it *cmp_it, EMACS_INT charpos, EMACS_INT bytepos, EMACS_INT endpos, struct window *w, struct face *face, Lisp_Object string)
{
if (endpos <= charpos)
{
the cluster, or -1 if the composition is somehow broken. */
int
-composition_update_it (cmp_it, charpos, bytepos, string)
- struct composition_it *cmp_it;
- EMACS_INT charpos, bytepos;
- Lisp_Object string;
+composition_update_it (struct composition_it *cmp_it, EMACS_INT charpos, EMACS_INT bytepos, Lisp_Object string)
{
int i, c;
the composition, and return 1. Otherwise, return 0. */
static int
-find_automatic_composition (pos, limit, start, end, gstring, string)
- EMACS_INT pos, limit, *start, *end;
- Lisp_Object *gstring, string;
+find_automatic_composition (EMACS_INT pos, EMACS_INT limit, EMACS_INT *start, EMACS_INT *end, Lisp_Object *gstring, Lisp_Object string)
{
EMACS_INT head, tail, stop;
/* Limit to check a composition after POS. */
to NEW_PT. */
int
-composition_adjust_point (last_pt, new_pt)
- EMACS_INT last_pt, new_pt;
+composition_adjust_point (EMACS_INT last_pt, EMACS_INT new_pt)
{
EMACS_INT charpos, bytepos, startpos, beg, end, pos;
Lisp_Object val;
\f
void
-syms_of_composite ()
+syms_of_composite (void)
{
int i;
#include <math.h>
#if !defined (atof)
-extern double atof ();
+extern double atof (const char *);
#endif /* !atof */
Lisp_Object Qnil, Qt, Qquote, Qlambda, Qsubr, Qunbound;
void
-circular_list_error (list)
- Lisp_Object list;
+circular_list_error (Lisp_Object list)
{
xsignal (Qcircular_list, list);
}
Lisp_Object
-wrong_type_argument (predicate, value)
- register Lisp_Object predicate, value;
+wrong_type_argument (register Lisp_Object predicate, register Lisp_Object value)
{
/* If VALUE is not even a valid Lisp object, we'd want to abort here
where we can get a backtrace showing where it came from. We used
}
void
-pure_write_error ()
+pure_write_error (void)
{
error ("Attempt to modify read-only object");
}
void
-args_out_of_range (a1, a2)
- Lisp_Object a1, a2;
+args_out_of_range (Lisp_Object a1, Lisp_Object a2)
{
xsignal2 (Qargs_out_of_range, a1, a2);
}
void
-args_out_of_range_3 (a1, a2, a3)
- Lisp_Object a1, a2, a3;
+args_out_of_range_3 (Lisp_Object a1, Lisp_Object a2, Lisp_Object a3)
{
xsignal3 (Qargs_out_of_range, a1, a2, a3);
}
/* On a few machines, XINT can only be done by calling this. */
int
-sign_extend_lisp_int (num)
- EMACS_INT num;
+sign_extend_lisp_int (EMACS_INT num)
{
if (num & (((EMACS_INT) 1) << (VALBITS - 1)))
return num | (((EMACS_INT) (-1)) << VALBITS);
indirections contains a loop. */
struct Lisp_Symbol *
-indirect_variable (symbol)
- struct Lisp_Symbol *symbol;
+indirect_variable (struct Lisp_Symbol *symbol)
{
struct Lisp_Symbol *tortoise, *hare;
((blv)->forwarded ? do_symval_forwarding (BLV_FWD (blv)) : BLV_VALUE (blv))
Lisp_Object
-do_symval_forwarding (valcontents)
- register union Lisp_Fwd *valcontents;
+do_symval_forwarding (register union Lisp_Fwd *valcontents)
{
register Lisp_Object val;
switch (XFWDTYPE (valcontents))
} while (0)
static void
-store_symval_forwarding (/* symbol, */ valcontents, newval, buf)
+store_symval_forwarding (union Lisp_Fwd *valcontents, register Lisp_Object newval, struct buffer *buf)
/* struct Lisp_Symbol *symbol; */
- union Lisp_Fwd *valcontents;
- register Lisp_Object newval;
- struct buffer *buf;
+
+
+
{
switch (XFWDTYPE (valcontents))
{
This makes it safe to alter the status of other bindings. */
void
-swap_in_global_binding (symbol)
- struct Lisp_Symbol *symbol;
+swap_in_global_binding (struct Lisp_Symbol *symbol)
{
struct Lisp_Buffer_Local_Value *blv = SYMBOL_BLV (symbol);
This could be another forwarding pointer. */
static void
-swap_in_symval_forwarding (symbol, blv)
- struct Lisp_Symbol *symbol;
- struct Lisp_Buffer_Local_Value *blv;
+swap_in_symval_forwarding (struct Lisp_Symbol *symbol, struct Lisp_Buffer_Local_Value *blv)
{
register Lisp_Object tem1;
within this function. Great care is required for this. */
Lisp_Object
-find_symbol_value (symbol)
- Lisp_Object symbol;
+find_symbol_value (Lisp_Object symbol)
{
struct Lisp_Symbol *sym;
}
static int
-let_shadows_global_binding_p (symbol)
- Lisp_Object symbol;
+let_shadows_global_binding_p (Lisp_Object symbol)
{
struct specbinding *p;
If BINDFLAG is nonzero, we don't do that. */
void
-set_internal (symbol, newval, where, bindflag)
- register Lisp_Object symbol, newval, where;
- int bindflag;
+set_internal (register Lisp_Object symbol, register Lisp_Object newval, register Lisp_Object where, int bindflag)
{
int voide = EQ (newval, Qunbound);
struct Lisp_Symbol *sym;
Return Qunbound if it is void. */
Lisp_Object
-default_value (symbol)
- Lisp_Object symbol;
+default_value (Lisp_Object symbol)
{
struct Lisp_Symbol *sym;
This is like Findirect_function, except that it doesn't signal an
error if the chain ends up unbound. */
Lisp_Object
-indirect_function (object)
- register Lisp_Object object;
+indirect_function (register Lisp_Object object)
{
Lisp_Object tortoise, hare;
enum comparison { equal, notequal, less, grtr, less_or_equal, grtr_or_equal };
Lisp_Object
-arithcompare (num1, num2, comparison)
- Lisp_Object num1, num2;
- enum comparison comparison;
+arithcompare (Lisp_Object num1, Lisp_Object num2, enum comparison comparison)
{
double f1 = 0, f2 = 0;
int floatp = 0;
when the value fits in one. */
Lisp_Object
-long_to_cons (i)
- unsigned long i;
+long_to_cons (long unsigned int i)
{
unsigned long top = i >> 16;
unsigned int bot = i & 0xFFFF;
}
unsigned long
-cons_to_long (c)
- Lisp_Object c;
+cons_to_long (Lisp_Object c)
{
Lisp_Object top, bot;
if (INTEGERP (c))
}
INLINE static int
-digit_to_number (character, base)
- int character, base;
+digit_to_number (int character, int base)
{
int digit;
extern Lisp_Object fmod_float ();
Lisp_Object
-arith_driver (code, nargs, args)
- enum arithop code;
- int nargs;
- register Lisp_Object *args;
+arith_driver (enum arithop code, int nargs, register Lisp_Object *args)
{
register Lisp_Object val;
register int argnum;
#define isnan(x) ((x) != (x))
static Lisp_Object
-float_arith_driver (accum, argnum, code, nargs, args)
- double accum;
- register int argnum;
- enum arithop code;
- int nargs;
- register Lisp_Object *args;
+float_arith_driver (double accum, register int argnum, enum arithop code, int nargs, register Lisp_Object *args)
{
register Lisp_Object val;
double next;
\f
void
-syms_of_data ()
+syms_of_data (void)
{
Lisp_Object error_tail, arith_tail;
}
SIGTYPE
-arith_error (signo)
- int signo;
+arith_error (int signo)
{
sigsetmask (SIGEMPTYMASK);
}
void
-init_data ()
+init_data (void)
{
/* Don't do this if just dumping out.
We don't want to call `signal' in this case
/* Determine the DBusType of a given Lisp symbol. OBJECT must be one
of the predefined D-Bus type symbols. */
static int
-xd_symbol_to_dbus_type (object)
- Lisp_Object object;
+xd_symbol_to_dbus_type (Lisp_Object object)
{
return
((EQ (object, QCdbus_type_byte)) ? DBUS_TYPE_BYTE
signature is embedded, or DBUS_TYPE_INVALID. It is needed for the
check that DBUS_TYPE_DICT_ENTRY occurs only as array element. */
static void
-xd_signature (signature, dtype, parent_type, object)
- char *signature;
- unsigned int dtype, parent_type;
- Lisp_Object object;
+xd_signature (char *signature, unsigned int dtype, unsigned int parent_type, Lisp_Object object)
{
unsigned int subtype;
Lisp_Object elt;
`dbus-send-signal', into corresponding C values appended as
arguments to a D-Bus message. */
static void
-xd_append_arg (dtype, object, iter)
- unsigned int dtype;
- Lisp_Object object;
- DBusMessageIter *iter;
+xd_append_arg (unsigned int dtype, Lisp_Object object, DBusMessageIter *iter)
{
char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
DBusMessageIter subiter;
D-Bus message must be a valid DBusType. Compound D-Bus types
result always in a Lisp list. */
static Lisp_Object
-xd_retrieve_arg (dtype, iter)
- unsigned int dtype;
- DBusMessageIter *iter;
+xd_retrieve_arg (unsigned int dtype, DBusMessageIter *iter)
{
switch (dtype)
/* Initialize D-Bus connection. BUS is a Lisp symbol, either :system
or :session. It tells which D-Bus to be initialized. */
static DBusConnection *
-xd_initialize (bus)
- Lisp_Object bus;
+xd_initialize (Lisp_Object bus)
{
DBusConnection *connection;
DBusError derror;
/* Add connection file descriptor to input_wait_mask, in order to
let select() detect, whether a new message has been arrived. */
dbus_bool_t
-xd_add_watch (watch, data)
- DBusWatch *watch;
- void *data;
+xd_add_watch (DBusWatch *watch, void *data)
{
/* We check only for incoming data. */
if (dbus_watch_get_flags (watch) & DBUS_WATCH_READABLE)
/* Remove connection file descriptor from input_wait_mask. DATA is
the used bus, either QCdbus_system_bus or QCdbus_session_bus. */
void
-xd_remove_watch (watch, data)
- DBusWatch *watch;
- void *data;
+xd_remove_watch (DBusWatch *watch, void *data)
{
/* We check only for incoming data. */
if (dbus_watch_get_flags (watch) & DBUS_WATCH_READABLE)
/* Check, whether there is pending input in the message queue of the
D-Bus BUS. BUS is a Lisp symbol, either :system or :session. */
int
-xd_get_dispatch_status (bus)
- Lisp_Object bus;
+xd_get_dispatch_status (Lisp_Object bus)
{
DBusConnection *connection;
/* Check for queued incoming messages from the system and session buses. */
int
-xd_pending_messages ()
+xd_pending_messages (void)
{
/* Vdbus_registered_objects_table will be initialized as hash table
/* Read queued incoming message of the D-Bus BUS. BUS is a Lisp
symbol, either :system or :session. */
static Lisp_Object
-xd_read_message (bus)
- Lisp_Object bus;
+xd_read_message (Lisp_Object bus)
{
Lisp_Object args, key, value;
struct gcpro gcpro1;
/* Read queued incoming messages from the system and session buses. */
void
-xd_read_queued_messages ()
+xd_read_queued_messages (void)
{
/* Vdbus_registered_objects_table will be initialized as hash table
\f
void
-syms_of_dbusbind ()
+syms_of_dbusbind (void)
{
Qdbus_init_bus = intern_c_string ("dbus-init-bus");
#endif
Lisp_Object
-directory_files_internal_unwind (dh)
- Lisp_Object dh;
+directory_files_internal_unwind (Lisp_Object dh)
{
DIR *d = (DIR *) XSAVE_VALUE (dh)->pointer;
BLOCK_INPUT;
In the latter case, ID_FORMAT is passed to Ffile_attributes. */
Lisp_Object
-directory_files_internal (directory, full, match, nosort, attrs, id_format)
- Lisp_Object directory, full, match, nosort;
- int attrs;
- Lisp_Object id_format;
+directory_files_internal (Lisp_Object directory, Lisp_Object full, Lisp_Object match, Lisp_Object nosort, int attrs, Lisp_Object id_format)
{
DIR *d;
int directory_nbytes;
}
\f
-Lisp_Object file_name_completion ();
+Lisp_Object file_name_completion (Lisp_Object file, Lisp_Object dirname, int all_flag, int ver_flag, Lisp_Object predicate);
DEFUN ("file-name-completion", Ffile_name_completion, Sfile_name_completion,
2, 3, 0,
return file_name_completion (file, directory, 1, 0, Qnil);
}
-static int file_name_completion_stat ();
+static int file_name_completion_stat (Lisp_Object dirname, struct dirent *dp, struct stat *st_addr);
Lisp_Object Qdefault_directory;
Lisp_Object
-file_name_completion (file, dirname, all_flag, ver_flag, predicate)
- Lisp_Object file, dirname;
- int all_flag, ver_flag;
- Lisp_Object predicate;
+file_name_completion (Lisp_Object file, Lisp_Object dirname, int all_flag, int ver_flag, Lisp_Object predicate)
{
DIR *d;
int bestmatchsize = 0;
else number of chars that match at the beginning. */
static int
-scmp (s1, s2, len)
- register unsigned char *s1, *s2;
- int len;
+scmp (register unsigned char *s1, register unsigned char *s2, int len)
{
register int l = len;
}
static int
-file_name_completion_stat (dirname, dp, st_addr)
- Lisp_Object dirname;
- DIRENTRY *dp;
- struct stat *st_addr;
+file_name_completion_stat (Lisp_Object dirname, struct dirent *dp, struct stat *st_addr)
{
int len = NAMLEN (dp);
int pos = SCHARS (dirname);
}
\f
Lisp_Object
-make_time (time)
- time_t time;
+make_time (time_t time)
{
return Fcons (make_number (time >> 16),
Fcons (make_number (time & 0177777), Qnil));
}
\f
void
-syms_of_dired ()
+syms_of_dired (void)
{
Qdirectory_files = intern_c_string ("directory-files");
Qdirectory_files_and_attributes = intern_c_string ("directory-files-and-attributes");
address of this function is used. */
void
-safe_bcopy (from, to, size)
- const char *from;
- char *to;
- int size;
+safe_bcopy (const char *from, char *to, int size)
{
if (size <= 0 || from == to)
return;
POOL, the structure is otherwise zeroed. */
struct glyph_matrix *
-new_glyph_matrix (pool)
- struct glyph_pool *pool;
+new_glyph_matrix (struct glyph_pool *pool)
{
struct glyph_matrix *result;
matrix also frees the glyph memory in this case. */
static void
-free_glyph_matrix (matrix)
- struct glyph_matrix *matrix;
+free_glyph_matrix (struct glyph_matrix *matrix)
{
if (matrix)
{
or a float. */
static int
-margin_glyphs_to_reserve (w, total_glyphs, margin)
- struct window *w;
- int total_glyphs;
- Lisp_Object margin;
+margin_glyphs_to_reserve (struct window *w, int total_glyphs, Lisp_Object margin)
{
int n;
leads to screen flickering. */
static void
-adjust_glyph_matrix (w, matrix, x, y, dim)
- struct window *w;
- struct glyph_matrix *matrix;
- int x, y;
- struct dim dim;
+adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y, struct dim dim)
{
int i;
int new_rows;
below). */
static void
-reverse_rows (matrix, start, end)
- struct glyph_matrix *matrix;
- int start, end;
+reverse_rows (struct glyph_matrix *matrix, int start, int end)
{
int i, j;
rotating right. */
void
-rotate_matrix (matrix, first, last, by)
- struct glyph_matrix *matrix;
- int first, last, by;
+rotate_matrix (struct glyph_matrix *matrix, int first, int last, int by)
{
if (by < 0)
{
DELTA_BYTES. */
void
-increment_matrix_positions (matrix, start, end, delta, delta_bytes)
- struct glyph_matrix *matrix;
- int start, end, delta, delta_bytes;
+increment_matrix_positions (struct glyph_matrix *matrix, int start, int end, int delta, int delta_bytes)
{
/* Check that START and END are reasonable values. */
xassert (start >= 0 && start <= matrix->nrows);
ENABLED_P is non-zero, enabled_p flags in rows will be set to 1. */
void
-enable_glyph_matrix_rows (matrix, start, end, enabled_p)
- struct glyph_matrix *matrix;
- int start, end;
- int enabled_p;
+enable_glyph_matrix_rows (struct glyph_matrix *matrix, int start, int end, int enabled_p)
{
xassert (start <= end);
xassert (start >= 0 && start < matrix->nrows);
currently present is the flag MATRIX->no_scrolling_p. */
void
-clear_glyph_matrix (matrix)
- struct glyph_matrix *matrix;
+clear_glyph_matrix (struct glyph_matrix *matrix)
{
if (matrix)
{
and recompute their visible height. */
void
-shift_glyph_matrix (w, matrix, start, end, dy)
- struct window *w;
- struct glyph_matrix *matrix;
- int start, end, dy;
+shift_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int start, int end, int dy)
{
int min_y, max_y;
current matrix. */
void
-clear_current_matrices (f)
- register struct frame *f;
+clear_current_matrices (register struct frame *f)
{
/* Clear frame current matrix, if we have one. */
if (f->current_matrix)
/* Clear out all display lines of F for a coming redisplay. */
void
-clear_desired_matrices (f)
- register struct frame *f;
+clear_desired_matrices (register struct frame *f)
{
if (f->desired_matrix)
clear_glyph_matrix (f->desired_matrix);
non-zero clear desired matrices, otherwise clear current matrices. */
static void
-clear_window_matrices (w, desired_p)
- struct window *w;
- int desired_p;
+clear_window_matrices (struct window *w, int desired_p)
{
while (w)
{
static struct glyph_row null_row;
void
-clear_glyph_row (row)
- struct glyph_row *row;
+clear_glyph_row (struct glyph_row *row)
{
struct glyph *p[1 + LAST_AREA];
in window W starting at y-position Y. */
void
-blank_row (w, row, y)
- struct window *w;
- struct glyph_row *row;
- int y;
+blank_row (struct window *w, struct glyph_row *row, int y)
{
int min_y, max_y;
ends. */
void
-increment_row_positions (row, delta, delta_bytes)
- struct glyph_row *row;
- int delta, delta_bytes;
+increment_row_positions (struct glyph_row *row, int delta, int delta_bytes)
{
int area, i;
/* Exchange pointers to glyph memory between glyph rows A and B. */
static INLINE void
-swap_glyph_pointers (a, b)
- struct glyph_row *a, *b;
+swap_glyph_pointers (struct glyph_row *a, struct glyph_row *b)
{
int i;
for (i = 0; i < LAST_AREA + 1; ++i)
that glyph pointers in the structures are left unchanged. */
INLINE void
-copy_row_except_pointers (to, from)
- struct glyph_row *to, *from;
+copy_row_except_pointers (struct glyph_row *to, struct glyph_row *from)
{
struct glyph *pointers[1 + LAST_AREA];
positions in row TO by DELTA/ DELTA_BYTES. */
void
-copy_glyph_row_contents (to, from, delta, delta_bytes)
- struct glyph_row *to, *from;
- int delta, delta_bytes;
+copy_glyph_row_contents (struct glyph_row *to, struct glyph_row *from, int delta, int delta_bytes)
{
int area;
a memory leak. */
static INLINE void
-assign_row (to, from)
- struct glyph_row *to, *from;
+assign_row (struct glyph_row *to, struct glyph_row *from)
{
swap_glyph_pointers (to, from);
copy_row_except_pointers (to, from);
call to this function really clears it. */
void
-prepare_desired_row (row)
- struct glyph_row *row;
+prepare_desired_row (struct glyph_row *row)
{
if (!row->enabled_p)
{
/* Return a hash code for glyph row ROW. */
int
-line_hash_code (row)
- struct glyph_row *row;
+line_hash_code (struct glyph_row *row)
{
int hash = 0;
zero, leading and trailing spaces are ignored. */
static unsigned int
-line_draw_cost (matrix, vpos)
- struct glyph_matrix *matrix;
- int vpos;
+line_draw_cost (struct glyph_matrix *matrix, int vpos)
{
struct glyph_row *row = matrix->rows + vpos;
struct glyph *beg = row->glyphs[TEXT_AREA];
flags of A and B, too. */
static INLINE int
-row_equal_p (w, a, b, mouse_face_p)
- struct window *w;
- struct glyph_row *a, *b;
- int mouse_face_p;
+row_equal_p (struct window *w, struct glyph_row *a, struct glyph_row *b, int mouse_face_p)
{
if (a == b)
return 1;
incremented for each pool allocated. */
static struct glyph_pool *
-new_glyph_pool ()
+new_glyph_pool (void)
{
struct glyph_pool *result;
was passed to free_glyph_pool. */
static void
-free_glyph_pool (pool)
- struct glyph_pool *pool;
+free_glyph_pool (struct glyph_pool *pool)
{
if (pool)
{
re-adjusting window glyph matrices necessary. */
static int
-realloc_glyph_pool (pool, matrix_dim)
- struct glyph_pool *pool;
- struct dim matrix_dim;
+realloc_glyph_pool (struct glyph_pool *pool, struct dim matrix_dim)
{
int needed;
int changed_p;
/* Return the required height of glyph matrices for window W. */
int
-required_matrix_height (w)
- struct window *w;
+required_matrix_height (struct window *w)
{
#ifdef HAVE_WINDOW_SYSTEM
struct frame *f = XFRAME (w->frame);
/* Return the required width of glyph matrices for window W. */
int
-required_matrix_width (w)
- struct window *w;
+required_matrix_width (struct window *w)
{
#ifdef HAVE_WINDOW_SYSTEM
struct frame *f = XFRAME (w->frame);
window whose matrices must be allocated/reallocated. */
static void
-allocate_matrices_for_window_redisplay (w)
- struct window *w;
+allocate_matrices_for_window_redisplay (struct window *w)
{
while (w)
{
changes, or its window configuration changes. */
void
-adjust_glyphs (f)
- struct frame *f;
+adjust_glyphs (struct frame *f)
{
/* Block input so that expose events and other events that access
glyph matrices are not processed while we are changing them. */
windows to estimated values. */
static void
-adjust_frame_glyphs_initially ()
+adjust_frame_glyphs_initially (void)
{
struct frame *sf = SELECTED_FRAME ();
struct window *root = XWINDOW (sf->root_window);
/* Allocate/reallocate glyph matrices of a single frame F. */
static void
-adjust_frame_glyphs (f)
- struct frame *f;
+adjust_frame_glyphs (struct frame *f)
{
if (FRAME_WINDOW_P (f))
adjust_frame_glyphs_for_window_redisplay (f);
/* Return 1 if any window in the tree has nonzero window margins. See
the hack at the end of adjust_frame_glyphs_for_frame_redisplay. */
static int
-showing_window_margins_p (w)
- struct window *w;
+showing_window_margins_p (struct window *w)
{
while (w)
{
windows from the frame's current matrix. */
static void
-fake_current_matrices (window)
- Lisp_Object window;
+fake_current_matrices (Lisp_Object window)
{
struct window *w;
a glyph matrix holding the contents of F's current frame matrix. */
static struct glyph_matrix *
-save_current_matrix (f)
- struct frame *f;
+save_current_matrix (struct frame *f)
{
int i;
struct glyph_matrix *saved;
and free memory associated with SAVED. */
static void
-restore_current_matrix (f, saved)
- struct frame *f;
- struct glyph_matrix *saved;
+restore_current_matrix (struct frame *f, struct glyph_matrix *saved)
{
int i;
frame-based redisplay. */
static void
-adjust_frame_glyphs_for_frame_redisplay (f)
- struct frame *f;
+adjust_frame_glyphs_for_frame_redisplay (struct frame *f)
{
struct dim matrix_dim;
int pool_changed_p;
window-based redisplay. */
static void
-adjust_frame_glyphs_for_window_redisplay (f)
- struct frame *f;
+adjust_frame_glyphs_for_window_redisplay (struct frame *f)
{
struct window *w;
eventually without causing trouble). */
static void
-adjust_frame_message_buffer (f)
- struct frame *f;
+adjust_frame_message_buffer (struct frame *f)
{
int size = FRAME_MESSAGE_BUF_SIZE (f) + 1;
/* Re-allocate buffer for decode_mode_spec on frame F. */
static void
-adjust_decode_mode_spec_buffer (f)
- struct frame *f;
+adjust_decode_mode_spec_buffer (struct frame *f)
{
f->decode_mode_spec_buffer
= (char *) xrealloc (f->decode_mode_spec_buffer,
the function is called when F is destroyed. */
void
-free_glyphs (f)
- struct frame *f;
+free_glyphs (struct frame *f)
{
if (f && f->glyphs_initialized_p)
{
the same tree more than once. */
void
-free_window_matrices (w)
- struct window *w;
+free_window_matrices (struct window *w)
{
while (w)
{
explicitly and check that nothing is left allocated. */
void
-check_glyph_memory ()
+check_glyph_memory (void)
{
Lisp_Object tail, frame;
sure not to touch them in this function. */
static void
-build_frame_matrix (f)
- struct frame *f;
+build_frame_matrix (struct frame *f)
{
int i;
matrices. W is the root of a window tree. */
static void
-build_frame_matrix_from_window_tree (matrix, w)
- struct glyph_matrix *matrix;
- struct window *w;
+build_frame_matrix_from_window_tree (struct glyph_matrix *matrix, struct window *w)
{
while (w)
{
preserve_other_columns in the old redisplay. */
static void
-build_frame_matrix_from_leaf_window (frame_matrix, w)
- struct glyph_matrix *frame_matrix;
- struct window *w;
+build_frame_matrix_from_leaf_window (struct glyph_matrix *frame_matrix, struct window *w)
{
struct glyph_matrix *window_matrix;
int window_y, frame_y;
for instance, vertical separators, truncation markers, etc. */
void
-spec_glyph_lookup_face (w, glyph)
- struct window *w;
- GLYPH *glyph;
+spec_glyph_lookup_face (struct window *w, GLYPH *glyph)
{
int lface_id = GLYPH_FACE (*glyph);
/* Convert the glyph's specified face to a realized (cache) face. */
To be called for frame-based redisplay, only. */
static void
-fill_up_glyph_row_with_spaces (row)
- struct glyph_row *row;
+fill_up_glyph_row_with_spaces (struct glyph_row *row)
{
fill_up_glyph_row_area_with_spaces (row, LEFT_MARGIN_AREA);
fill_up_glyph_row_area_with_spaces (row, TEXT_AREA);
frame-based redisplay only. */
static void
-fill_up_glyph_row_area_with_spaces (row, area)
- struct glyph_row *row;
- int area;
+fill_up_glyph_row_area_with_spaces (struct glyph_row *row, int area)
{
if (row->glyphs[area] < row->glyphs[area + 1])
{
reached. In frame matrices only one area, TEXT_AREA, is used. */
static void
-fill_up_frame_row_with_spaces (row, upto)
- struct glyph_row *row;
- int upto;
+fill_up_frame_row_with_spaces (struct glyph_row *row, int upto)
{
int i = row->used[TEXT_AREA];
struct glyph *glyph = row->glyphs[TEXT_AREA];
working on frame matrices or not. */
static INLINE void
-set_frame_matrix_frame (f)
- struct frame *f;
+set_frame_matrix_frame (struct frame *f)
{
frame_matrix_frame = f;
}
operations in window matrices of frame_matrix_frame. */
static INLINE void
-make_current (desired_matrix, current_matrix, row)
- struct glyph_matrix *desired_matrix, *current_matrix;
- int row;
+make_current (struct glyph_matrix *desired_matrix, struct glyph_matrix *current_matrix, int row)
{
struct glyph_row *current_row = MATRIX_ROW (current_matrix, row);
struct glyph_row *desired_row = MATRIX_ROW (desired_matrix, row);
matrices of leaf windows in the window tree rooted at W. */
static void
-mirror_make_current (w, frame_row)
- struct window *w;
- int frame_row;
+mirror_make_current (struct window *w, int frame_row)
{
while (w)
{
the current frame matrix. */
static void
-sync_window_with_frame_matrix_rows (w)
- struct window *w;
+sync_window_with_frame_matrix_rows (struct window *w)
{
struct frame *f = XFRAME (w->frame);
struct glyph_row *window_row, *window_row_end, *frame_row;
row ROW. Value is null if none is found. */
struct window *
-frame_row_to_window (w, row)
- struct window *w;
- int row;
+frame_row_to_window (struct window *w, int row)
{
struct window *found = NULL;
which is empty. */
static void
-mirror_line_dance (w, unchanged_at_top, nlines, copy_from, retained_p)
- struct window *w;
- int unchanged_at_top, nlines;
- int *copy_from;
- char *retained_p;
+mirror_line_dance (struct window *w, int unchanged_at_top, int nlines, int *copy_from, char *retained_p)
{
while (w)
{
function redraw-frame. */
void
-redraw_frame (f)
- struct frame *f;
+redraw_frame (struct frame *f)
{
Lisp_Object frame;
XSETFRAME (frame, f);
visible frames marked as garbaged. */
void
-redraw_garbaged_frames ()
+redraw_garbaged_frames (void)
{
Lisp_Object tail, frame;
Value is non-zero if redisplay was stopped due to pending input. */
int
-update_frame (f, force_p, inhibit_hairy_id_p)
- struct frame *f;
- int force_p;
- int inhibit_hairy_id_p;
+update_frame (struct frame *f, int force_p, int inhibit_hairy_id_p)
{
/* 1 means display has been paused because of pending input. */
int paused_p;
don't stop updating when input is pending. */
static int
-update_window_tree (w, force_p)
- struct window *w;
- int force_p;
+update_window_tree (struct window *w, int force_p)
{
int paused_p = 0;
FORCE_P is non-zero, don't stop updating if input is pending. */
void
-update_single_window (w, force_p)
- struct window *w;
- int force_p;
+update_single_window (struct window *w, int force_p)
{
if (w->must_be_updated_p)
{
overlapped by other rows. YB is bottom-most y-position in W. */
static void
-redraw_overlapped_rows (w, yb)
- struct window *w;
- int yb;
+redraw_overlapped_rows (struct window *w, int yb)
{
int i;
struct frame *f = XFRAME (WINDOW_FRAME (w));
others. YB is bottom-most y-position in W. */
static void
-redraw_overlapping_rows (w, yb)
- struct window *w;
- int yb;
+redraw_overlapping_rows (struct window *w, int yb)
{
int i, bottom_y;
struct glyph_row *row;
which is below what's displayed in the window. */
void
-check_current_matrix_flags (w)
- struct window *w;
+check_current_matrix_flags (struct window *w)
{
int last_seen_p = 0;
int i, yb = window_text_bottom_y (w);
not stop when detecting pending input. */
static int
-update_window (w, force_p)
- struct window *w;
- int force_p;
+update_window (struct window *w, int force_p)
{
struct glyph_matrix *desired_matrix = w->desired_matrix;
int paused_p;
AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
static void
-update_marginal_area (w, area, vpos)
- struct window *w;
- int area, vpos;
+update_marginal_area (struct window *w, int area, int vpos)
{
struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos);
struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
Value is non-zero if display has changed. */
static int
-update_text_area (w, vpos)
- struct window *w;
- int vpos;
+update_text_area (struct window *w, int vpos)
{
struct glyph_row *current_row = MATRIX_ROW (w->current_matrix, vpos);
struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos);
changed. */
static int
-update_window_line (w, vpos, mouse_face_overwritten_p)
- struct window *w;
- int vpos, *mouse_face_overwritten_p;
+update_window_line (struct window *w, int vpos, int *mouse_face_overwritten_p)
{
struct glyph_row *current_row = MATRIX_ROW (w->current_matrix, vpos);
struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos);
be called from update_window. */
static void
-set_window_cursor_after_update (w)
- struct window *w;
+set_window_cursor_after_update (struct window *w)
{
struct frame *f = XFRAME (w->frame);
struct redisplay_interface *rif = FRAME_RIF (f);
tree rooted at W. */
void
-set_window_update_flags (w, on_p)
- struct window *w;
- int on_p;
+set_window_update_flags (struct window *w, int on_p)
{
while (w)
{
of window W. */
static INLINE struct row_entry *
-add_row_entry (w, row)
- struct window *w;
- struct glyph_row *row;
+add_row_entry (struct window *w, struct glyph_row *row)
{
struct row_entry *entry;
int i = row->hash % row_table_size;
1 if we did scroll. */
static int
-scrolling_window (w, header_line_p)
- struct window *w;
- int header_line_p;
+scrolling_window (struct window *w, int header_line_p)
{
struct glyph_matrix *desired_matrix = w->desired_matrix;
struct glyph_matrix *current_matrix = w->current_matrix;
Value is non-zero if update was stopped due to pending input. */
static int
-update_frame_1 (f, force_p, inhibit_id_p)
- struct frame *f;
- int force_p;
- int inhibit_id_p;
+update_frame_1 (struct frame *f, int force_p, int inhibit_id_p)
{
/* Frame matrices to work on. */
struct glyph_matrix *current_matrix = f->current_matrix;
/* Do line insertions/deletions on frame F for frame-based redisplay. */
int
-scrolling (frame)
- struct frame *frame;
+scrolling (struct frame *frame)
{
int unchanged_at_top, unchanged_at_bottom;
int window_size;
which is LEN glyphs long. */
static int
-count_blanks (r, len)
- struct glyph *r;
- int len;
+count_blanks (struct glyph *r, int len)
{
int i;
of STR2. Value is the number of equal glyphs equal at the start. */
static int
-count_match (str1, end1, str2, end2)
- struct glyph *str1, *end1, *str2, *end2;
+count_match (struct glyph *str1, struct glyph *end1, struct glyph *str2, struct glyph *end2)
{
struct glyph *p1 = str1;
struct glyph *p2 = str2;
/* Perform a frame-based update on line VPOS in frame FRAME. */
static void
-update_frame_line (f, vpos)
- struct frame *f;
- int vpos;
+update_frame_line (struct frame *f, int vpos)
{
struct glyph *obody, *nbody, *op1, *op2, *np1, *nend;
int tem;
Adjust *X and *Y to character positions. */
Lisp_Object
-buffer_posn_from_coords (w, x, y, pos, object, dx, dy, width, height)
- struct window *w;
- int *x, *y;
- struct display_pos *pos;
- Lisp_Object *object;
- int *dx, *dy;
- int *width, *height;
+buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *pos, Lisp_Object *object, int *dx, int *dy, int *width, int *height)
{
struct it it;
Lisp_Object old_current_buffer = Fcurrent_buffer ();
*CHARPOS is set to the position in the string returned. */
Lisp_Object
-mode_line_string (w, part, x, y, charpos, object, dx, dy, width, height)
- struct window *w;
- enum window_part part;
- int *x, *y;
- int *charpos;
- Lisp_Object *object;
- int *dx, *dy;
- int *width, *height;
+mode_line_string (struct window *w, enum window_part part, int *x, int *y, int *charpos, Lisp_Object *object, int *dx, int *dy, int *width, int *height)
{
struct glyph_row *row;
struct glyph *glyph, *end;
the string returned. */
Lisp_Object
-marginal_area_string (w, part, x, y, charpos, object, dx, dy, width, height)
- struct window *w;
- enum window_part part;
- int *x, *y;
- int *charpos;
- Lisp_Object *object;
- int *dx, *dy;
- int *width, *height;
+marginal_area_string (struct window *w, enum window_part part, int *x, int *y, int *charpos, Lisp_Object *object, int *dx, int *dy, int *width, int *height)
{
struct glyph_row *row = w->current_matrix->rows;
struct glyph *glyph, *end;
#ifdef SIGWINCH
SIGTYPE
-window_change_signal (signalnum) /* If we don't have an argument, */
- int signalnum; /* some compilers complain in signal calls. */
+window_change_signal (int signalnum) /* If we don't have an argument, */
+ /* some compilers complain in signal calls. */
{
int width, height;
int old_errno = errno;
safe to change frame sizes while a redisplay is in progress. */
void
-do_pending_window_change (safe)
- int safe;
+do_pending_window_change (int safe)
{
/* If window_change_signal should have run before, run it now. */
if (redisplaying_p && !safe)
safe to change frame sizes while a redisplay is in progress. */
void
-change_frame_size (f, newheight, newwidth, pretend, delay, safe)
- register struct frame *f;
- int newheight, newwidth, pretend, delay, safe;
+change_frame_size (register struct frame *f, int newheight, int newwidth, int pretend, int delay, int safe)
{
Lisp_Object tail, frame;
}
static void
-change_frame_size_1 (f, newheight, newwidth, pretend, delay, safe)
- register struct frame *f;
- int newheight, newwidth, pretend, delay, safe;
+change_frame_size_1 (register struct frame *f, int newheight, int newwidth, int pretend, int delay, int safe)
{
int new_frame_total_cols;
int count = SPECPDL_INDEX ();
}
void
-bitch_at_user ()
+bitch_at_user (void)
{
if (noninteractive)
putchar (07);
*/
Lisp_Object
-sit_for (timeout, reading, do_display)
- Lisp_Object timeout;
- int reading, do_display;
+sit_for (Lisp_Object timeout, int reading, int do_display)
{
int sec, usec;
decoding routine to set up variables in the terminal package. */
void
-init_display ()
+init_display (void)
{
char *terminal_type;
***********************************************************************/
void
-syms_of_display ()
+syms_of_display (void)
{
defsubr (&Sredraw_frame);
defsubr (&Sredraw_display);
If UNREADFLAG is 1, we unread a byte. */
int
-read_bytecode_char (unreadflag)
- int unreadflag;
+read_bytecode_char (int unreadflag)
{
if (unreadflag)
{
and return a cons cell. */
Lisp_Object
-get_doc_string (filepos, unibyte, definition)
- Lisp_Object filepos;
- int unibyte, definition;
+get_doc_string (Lisp_Object filepos, int unibyte, int definition)
{
char *from, *to;
register int fd;
of a compiled function from the .elc file. */
Lisp_Object
-read_doc_string (filepos)
- Lisp_Object filepos;
+read_doc_string (Lisp_Object filepos)
{
return get_doc_string (filepos, 0, 1);
}
static int
-reread_doc_file (file)
- Lisp_Object file;
+reread_doc_file (Lisp_Object file)
{
#if 0
Lisp_Object reply, prompt[3];
/* Scanning the DOC files and placing docstring offsets into functions. */
static void
-store_function_docstring (fun, offset)
- Lisp_Object fun;
+store_function_docstring (Lisp_Object fun, EMACS_INT offset)
+
/* Use EMACS_INT because we get this from pointer subtraction. */
- EMACS_INT offset;
+
{
fun = indirect_function (fun);
}
\f
void
-syms_of_doc ()
+syms_of_doc (void)
{
Qfunction_documentation = intern_c_string ("function-documentation");
staticpro (&Qfunction_documentation);
Integers are passed as C integers. */
int
-doprnt (buffer, bufsize, format, format_end, nargs, args)
- char *buffer;
- register int bufsize;
- char *format;
- char *format_end;
- int nargs;
- char **args;
+doprnt (char *buffer, register int bufsize, char *format, char *format_end, int nargs, char **args)
{
int cnt = 0; /* Number of arg to gobble next */
register char *fmt = format; /* Pointer into format string */
char **environ;
-static start1 ();
+static start1 (int bogus_fp, int argc, char *xargv);
/* Define symbol "start": here; some systems want that symbol. */
asm(" .text ");
asm(" .globl start ");
asm(" start: ");
-_start ()
+_start (void)
{
/* On vax, nothing is pushed here */
start1 ();
}
static
-start1 (bogus_fp, argc, xargv)
- int argc;
- char *xargv;
+start1 (int bogus_fp, int argc, char *xargv)
{
register char **argv = &xargv;
environ = argv + argc + 1;
void
-init_editfns ()
+init_editfns (void)
{
char *user_name;
register unsigned char *p;
}
\f
static Lisp_Object
-buildmark (charpos, bytepos)
- int charpos, bytepos;
+buildmark (int charpos, int bytepos)
{
register Lisp_Object mark;
mark = Fmake_marker ();
}
int
-clip_to_bounds (lower, num, upper)
- int lower, num, upper;
+clip_to_bounds (int lower, int num, int upper)
{
if (num < lower)
return lower;
If there is no region active, signal an error. */
static Lisp_Object
-region_limit (beginningp)
- int beginningp;
+region_limit (int beginningp)
{
extern Lisp_Object Vmark_even_if_inactive; /* Defined in callint.c. */
Lisp_Object m;
of length LEN. */
static int
-overlays_around (pos, vec, len)
- int pos;
- Lisp_Object *vec;
- int len;
+overlays_around (int pos, Lisp_Object *vec, int len)
{
Lisp_Object overlay, start, end;
struct Lisp_Overlay *tail;
window-specific overlays are considered only if they are associated
with OBJECT. */
Lisp_Object
-get_pos_property (position, prop, object)
- Lisp_Object position, object;
- register Lisp_Object prop;
+get_pos_property (Lisp_Object position, register Lisp_Object prop, Lisp_Object object)
{
CHECK_NUMBER_COERCE_MARKER (position);
is not stored. */
static void
-find_field (pos, merge_at_boundary, beg_limit, beg, end_limit, end)
- Lisp_Object pos;
- Lisp_Object merge_at_boundary;
- Lisp_Object beg_limit, end_limit;
- int *beg, *end;
+find_field (Lisp_Object pos, Lisp_Object merge_at_boundary, Lisp_Object beg_limit, int *beg, Lisp_Object end_limit, int *end)
{
/* Fields right before and after the point. */
Lisp_Object before_field, after_field;
\f
Lisp_Object
-save_excursion_save ()
+save_excursion_save (void)
{
int visible = (XBUFFER (XWINDOW (selected_window)->buffer)
== current_buffer);
}
Lisp_Object
-save_excursion_restore (info)
- Lisp_Object info;
+save_excursion_restore (Lisp_Object info)
{
Lisp_Object tem, tem1, omark, nmark;
struct gcpro gcpro1, gcpro2, gcpro3;
/* For the benefit of callers who don't want to include lisp.h */
char *
-get_system_name ()
+get_system_name (void)
{
if (STRINGP (Vsystem_name))
return (char *) SDATA (Vsystem_name);
}
char *
-get_operating_system_release()
+get_operating_system_release(void)
{
if (STRINGP (Voperating_system_release))
return (char *) SDATA (Voperating_system_release);
\f
int
-lisp_time_argument (specified_time, result, usec)
- Lisp_Object specified_time;
- time_t *result;
- int *usec;
+lisp_time_argument (Lisp_Object specified_time, time_t *result, int *usec)
{
if (NILP (specified_time))
{
This function behaves like emacs_strftimeu, except it allows null
bytes in FORMAT. */
static size_t
-emacs_memftimeu (s, maxsize, format, format_len, tp, ut)
- char *s;
- size_t maxsize;
- const char *format;
- size_t format_len;
- const struct tm *tp;
- int ut;
+emacs_memftimeu (char *s, size_t maxsize, const char *format, size_t format_len, const struct tm *tp, int ut)
{
size_t total = 0;
/* Yield A - B, measured in seconds.
This function is copied from the GNU C Library. */
static int
-tm_diff (a, b)
- struct tm *a, *b;
+tm_diff (struct tm *a, struct tm *b)
{
/* Compute intervening leap days correctly even if year is negative.
Take care to avoid int overflow in leap day calculations,
responsibility to free. */
void
-set_time_zone_rule (tzstring)
- char *tzstring;
+set_time_zone_rule (char *tzstring)
{
int envptrs;
char **from, **to, **newenv;
}
void
-insert1 (arg)
- Lisp_Object arg;
+insert1 (Lisp_Object arg)
{
Finsert (1, &arg);
}
buffer substrings. */
Lisp_Object
-make_buffer_string (start, end, props)
- int start, end;
- int props;
+make_buffer_string (int start, int end, int props)
{
int start_byte = CHAR_TO_BYTE (start);
int end_byte = CHAR_TO_BYTE (end);
buffer substrings. */
Lisp_Object
-make_buffer_string_both (start, start_byte, end, end_byte, props)
- int start, start_byte, end, end_byte;
- int props;
+make_buffer_string_both (int start, int start_byte, int end, int end_byte, int props)
{
Lisp_Object result, tem, tem1;
in the current buffer, if necessary. */
static void
-update_buffer_properties (start, end)
- int start, end;
+update_buffer_properties (int start, int end)
{
/* If this buffer has some access functions,
call them, specifying the range of the buffer being accessed. */
}
\f
static Lisp_Object
-subst_char_in_region_unwind (arg)
- Lisp_Object arg;
+subst_char_in_region_unwind (Lisp_Object arg)
{
return current_buffer->undo_list = arg;
}
static Lisp_Object
-subst_char_in_region_unwind_1 (arg)
- Lisp_Object arg;
+subst_char_in_region_unwind_1 (Lisp_Object arg)
{
return current_buffer->filename = arg;
}
element is found, return it. Otherwise return Qnil. */
static Lisp_Object
-check_translation (pos, pos_byte, end, val)
- int pos, pos_byte, end;
- Lisp_Object val;
+check_translation (int pos, int pos_byte, int end, Lisp_Object val)
{
int buf_size = 16, buf_used = 0;
int *buf = alloca (sizeof (int) * buf_size);
}
Lisp_Object
-save_restriction_save ()
+save_restriction_save (void)
{
if (BEGV == BEG && ZV == Z)
/* The common case that the buffer isn't narrowed.
}
Lisp_Object
-save_restriction_restore (data)
- Lisp_Object data;
+save_restriction_restore (Lisp_Object data)
{
struct buffer *cur = NULL;
struct buffer *buf = (CONSP (data)
}
Lisp_Object
-format2 (string1, arg0, arg1)
- char *string1;
- Lisp_Object arg0, arg1;
+format2 (char *string1, Lisp_Object arg0, Lisp_Object arg1)
{
Lisp_Object args[3];
args[0] = build_string (string1);
\f
void
-syms_of_editfns ()
+syms_of_editfns (void)
{
environbuf = 0;
initial_tz = 0;
\f
void
-report_file_error (string, data)
- const char *string;
- Lisp_Object data;
+report_file_error (const char *string, Lisp_Object data)
{
Lisp_Object errstring;
int errorno = errno;
}
Lisp_Object
-close_file_unwind (fd)
- Lisp_Object fd;
+close_file_unwind (Lisp_Object fd)
{
emacs_close (XFASTINT (fd));
return Qnil;
/* Restore point, having saved it as a marker. */
Lisp_Object
-restore_point_unwind (location)
- Lisp_Object location;
+restore_point_unwind (Lisp_Object location)
{
Fgoto_char (location);
Fset_marker (location, Qnil, Qnil);
\f
char *
-file_name_as_directory (out, in)
- char *out, *in;
+file_name_as_directory (char *out, char *in)
{
int size = strlen (in) - 1;
*/
int
-directory_file_name (src, dst)
- char *src, *dst;
+directory_file_name (char *src, char *dst)
{
long slen;
generated. */
Lisp_Object
-make_temp_name (prefix, base64_p)
- Lisp_Object prefix;
- int base64_p;
+make_temp_name (Lisp_Object prefix, int base64_p)
{
Lisp_Object val;
int len, clen;
\f
/* If /~ or // appears, discard everything through first slash. */
static int
-file_name_absolute_p (filename)
- const unsigned char *filename;
+file_name_absolute_p (const unsigned char *filename)
{
return
(IS_DIRECTORY_SEP (*filename) || *filename == '~'
}
static unsigned char *
-search_embedded_absfilename (nm, endp)
- unsigned char *nm, *endp;
+search_embedded_absfilename (unsigned char *nm, unsigned char *endp)
{
unsigned char *p, *s;
(directory-file-name (expand-file-name FOO)). */
Lisp_Object
-expand_and_dir_to_file (filename, defdir)
- Lisp_Object filename, defdir;
+expand_and_dir_to_file (Lisp_Object filename, Lisp_Object defdir)
{
register Lisp_Object absname;
If QUICK is nonzero, we ask for y or n, not yes or no. */
void
-barf_or_query_if_file_exists (absname, querystring, interactive, statptr, quick)
- Lisp_Object absname;
- unsigned char *querystring;
- int interactive;
- struct stat *statptr;
- int quick;
+barf_or_query_if_file_exists (Lisp_Object absname, unsigned char *querystring, int interactive, struct stat *statptr, int quick)
{
register Lisp_Object tem, encoded_filename;
struct stat statbuf;
}
static Lisp_Object
-internal_delete_file_1 (ignore)
- Lisp_Object ignore;
+internal_delete_file_1 (Lisp_Object ignore)
{
return Qt;
}
/* Return nonzero if file FILENAME exists and can be executed. */
static int
-check_executable (filename)
- char *filename;
+check_executable (char *filename)
{
#ifdef DOS_NT
int len = strlen (filename);
/* Return nonzero if file FILENAME exists and can be written. */
static int
-check_writable (filename)
- char *filename;
+check_writable (char *filename)
{
#ifdef MSDOS
struct stat st;
o set back the buffer multibyteness. */
static Lisp_Object
-decide_coding_unwind (unwind_data)
- Lisp_Object unwind_data;
+decide_coding_unwind (Lisp_Object unwind_data)
{
Lisp_Object multibyte, undo_list, buffer;
Value is the number of bytes read. */
static Lisp_Object
-read_non_regular ()
+read_non_regular (void)
{
EMACS_INT nbytes;
in insert-file-contents. */
static Lisp_Object
-read_non_regular_quit ()
+read_non_regular_quit (void)
{
return Qnil;
}
static Lisp_Object build_annotations (Lisp_Object, Lisp_Object);
static Lisp_Object
-build_annotations_unwind (arg)
- Lisp_Object arg;
+build_annotations_unwind (Lisp_Object arg)
{
Vwrite_region_annotation_buffers = arg;
return Qnil;
as save-excursion would do. */
static Lisp_Object
-build_annotations (start, end)
- Lisp_Object start, end;
+build_annotations (Lisp_Object start, Lisp_Object end)
{
Lisp_Object annotations;
Lisp_Object p, res;
The return value is negative in case of system call failure. */
static int
-a_write (desc, string, pos, nchars, annot, coding)
- int desc;
- Lisp_Object string;
- register int nchars;
- int pos;
- Lisp_Object *annot;
- struct coding_system *coding;
+a_write (int desc, Lisp_Object string, int pos, register int nchars, Lisp_Object *annot, struct coding_system *coding)
{
Lisp_Object tem;
int nextpos;
are indexes to the string STRING. */
static int
-e_write (desc, string, start, end, coding)
- int desc;
- Lisp_Object string;
- int start, end;
- struct coding_system *coding;
+e_write (int desc, Lisp_Object string, int start, int end, struct coding_system *coding)
{
if (STRINGP (string))
{
}
\f
Lisp_Object
-auto_save_error (error)
- Lisp_Object error;
+auto_save_error (Lisp_Object error)
{
Lisp_Object args[3], msg;
int i, nbytes;
}
Lisp_Object
-auto_save_1 ()
+auto_save_1 (void)
{
struct stat st;
Lisp_Object modes;
}
static Lisp_Object
-do_auto_save_unwind (arg) /* used as unwind-protect function */
- Lisp_Object arg;
+do_auto_save_unwind (Lisp_Object arg) /* used as unwind-protect function */
+
{
FILE *stream = (FILE *) XSAVE_VALUE (arg)->pointer;
auto_saving = 0;
}
static Lisp_Object
-do_auto_save_unwind_1 (value) /* used as unwind-protect function */
- Lisp_Object value;
+do_auto_save_unwind_1 (Lisp_Object value) /* used as unwind-protect function */
+
{
minibuffer_auto_raise = XINT (value);
return Qnil;
}
static Lisp_Object
-do_auto_save_make_dir (dir)
- Lisp_Object dir;
+do_auto_save_make_dir (Lisp_Object dir)
{
Lisp_Object mode;
}
static Lisp_Object
-do_auto_save_eh (ignore)
- Lisp_Object ignore;
+do_auto_save_eh (Lisp_Object ignore)
{
return Qnil;
}
}
Lisp_Object
-Fread_file_name (prompt, dir, default_filename, mustmatch, initial, predicate)
- Lisp_Object prompt, dir, default_filename, mustmatch, initial, predicate;
+Fread_file_name (Lisp_Object prompt, Lisp_Object dir, Lisp_Object default_filename, Lisp_Object mustmatch, Lisp_Object initial, Lisp_Object predicate)
{
struct gcpro gcpro1, gcpro2;
Lisp_Object args[7];
\f
void
-syms_of_fileio ()
+syms_of_fileio (void)
{
Qoperations = intern_c_string ("operations");
Qexpand_file_name = intern_c_string ("expand-file-name");
#endif
static time_t
-get_boot_time ()
+get_boot_time (void)
{
#if defined (BOOT_TIME)
int counter;
Success is indicated by setting BOOT_TIME to a larger value. */
void
-get_boot_time_1 (filename, newest)
- char *filename;
- int newest;
+get_boot_time_1 (char *filename, int newest)
{
struct utmp ut, *utp;
int desc;
fill_in_lock_file_name (lock, (file)))
static void
-fill_in_lock_file_name (lockfile, fn)
- register char *lockfile;
- register Lisp_Object fn;
+fill_in_lock_file_name (register char *lockfile, register Lisp_Object fn)
{
register char *p;
struct stat st;
Return 1 if successful, 0 if not. */
static int
-lock_file_1 (lfname, force)
- char *lfname;
- int force;
+lock_file_1 (char *lfname, int force)
{
register int err;
time_t boot_time;
/* Return 1 if times A and B are no more than one second apart. */
int
-within_one_second (a, b)
- time_t a, b;
+within_one_second (time_t a, time_t b)
{
return (a - b >= -1 && a - b <= 1);
}
or -1 if something is wrong with the locking mechanism. */
static int
-current_lock_owner (owner, lfname)
- lock_info_type *owner;
- char *lfname;
+current_lock_owner (lock_info_type *owner, char *lfname)
{
#ifndef index
- extern char *rindex (), *index ();
+ extern char *rindex (const char *, int), *index (const char *, int);
#endif
int len, ret;
int local_owner = 0;
Return -1 if cannot lock for any other reason. */
static int
-lock_if_free (clasher, lfname)
- lock_info_type *clasher;
- register char *lfname;
+lock_if_free (lock_info_type *clasher, register char *lfname)
{
while (lock_file_1 (lfname, 0) == 0)
{
take away the lock, or return nil meaning ignore the lock. */
void
-lock_file (fn)
- Lisp_Object fn;
+lock_file (Lisp_Object fn)
{
register Lisp_Object attack, orig_fn, encoded_fn;
register char *lfname, *locker;
}
void
-unlock_file (fn)
- register Lisp_Object fn;
+unlock_file (register Lisp_Object fn)
{
register char *lfname;
}
void
-unlock_all_files ()
+unlock_all_files (void)
{
register Lisp_Object tail;
register struct buffer *b;
/* Unlock the file visited in buffer BUFFER. */
void
-unlock_buffer (buffer)
- struct buffer *buffer;
+unlock_buffer (struct buffer *buffer)
{
if (BUF_SAVE_MODIFF (buffer) < BUF_MODIFF (buffer)
&& STRINGP (buffer->file_truename))
/* Initialization functions. */
void
-init_filelock ()
+init_filelock (void)
{
boot_time = 0;
boot_time_initialized = 0;
}
void
-syms_of_filelock ()
+syms_of_filelock (void)
{
DEFVAR_LISP ("temporary-file-directory", &Vtemporary_file_directory,
doc: /* The directory for writing temporary files. */);
#define S_ISNWK(m) (((m) & S_IFMT) == S_IFNWK)
#endif
-void mode_string ();
-static char ftypelet ();
-static void rwx ();
-static void setst ();
+void mode_string (short unsigned int mode, char *str);
+static char ftypelet (long int bits);
+static void rwx (short unsigned int bits, char *chars);
+static void setst (short unsigned int bits, char *chars);
/* filemodestring - fill in string STR with an ls-style ASCII
representation of the st_mode field of file stats block STATP.
'T' if the file is sticky but not executable. */
void
-filemodestring (statp, str)
- struct stat *statp;
- char *str;
+filemodestring (struct stat *statp, char *str)
{
mode_string (statp->st_mode, str);
}
is given as an argument. */
void
-mode_string (mode, str)
- unsigned short mode;
- char *str;
+mode_string (short unsigned int mode, char *str)
{
str[0] = ftypelet ((long) mode);
rwx ((mode & 0700) << 0, &str[1]);
'?' for any other file type. */
static char
-ftypelet (bits)
- long bits;
+ftypelet (long int bits)
{
#ifdef S_ISBLK
if (S_ISBLK (bits))
flags in CHARS accordingly. */
static void
-rwx (bits, chars)
- unsigned short bits;
- char *chars;
+rwx (short unsigned int bits, char *chars)
{
chars[0] = (bits & S_IRUSR) ? 'r' : '-';
chars[1] = (bits & S_IWUSR) ? 'w' : '-';
according to the file mode BITS. */
static void
-setst (bits, chars)
- unsigned short bits;
- char *chars;
+setst (short unsigned int bits, char *chars)
{
#ifdef S_ISUID
if (bits & S_ISUID)
static int internal_equal (Lisp_Object , Lisp_Object, int, int);
-extern long get_random ();
+extern long get_random (void);
extern void seed_random (long);
#ifndef HAVE_UNISTD_H
/* ARGSUSED */
Lisp_Object
-concat2 (s1, s2)
- Lisp_Object s1, s2;
+concat2 (Lisp_Object s1, Lisp_Object s2)
{
Lisp_Object args[2];
args[0] = s1;
/* ARGSUSED */
Lisp_Object
-concat3 (s1, s2, s3)
- Lisp_Object s1, s2, s3;
+concat3 (Lisp_Object s1, Lisp_Object s2, Lisp_Object s3)
{
Lisp_Object args[3];
args[0] = s1;
};
static Lisp_Object
-concat (nargs, args, target_type, last_special)
- int nargs;
- Lisp_Object *args;
- enum Lisp_Type target_type;
- int last_special;
+concat (int nargs, Lisp_Object *args, enum Lisp_Type target_type, int last_special)
{
Lisp_Object val;
register Lisp_Object tail;
static EMACS_INT string_char_byte_cache_bytepos;
void
-clear_string_char_byte_cache ()
+clear_string_char_byte_cache (void)
{
string_char_byte_cache_string = Qnil;
}
/* Return the byte index corresponding to CHAR_INDEX in STRING. */
EMACS_INT
-string_char_to_byte (string, char_index)
- Lisp_Object string;
- EMACS_INT char_index;
+string_char_to_byte (Lisp_Object string, EMACS_INT char_index)
{
EMACS_INT i_byte;
EMACS_INT best_below, best_below_byte;
/* Return the character index corresponding to BYTE_INDEX in STRING. */
EMACS_INT
-string_byte_to_char (string, byte_index)
- Lisp_Object string;
- EMACS_INT byte_index;
+string_byte_to_char (Lisp_Object string, EMACS_INT byte_index)
{
EMACS_INT i, i_byte;
EMACS_INT best_below, best_below_byte;
/* Convert STRING to a multibyte string. */
Lisp_Object
-string_make_multibyte (string)
- Lisp_Object string;
+string_make_multibyte (Lisp_Object string)
{
unsigned char *buf;
EMACS_INT nbytes;
converted to eight-bit characters. */
Lisp_Object
-string_to_multibyte (string)
- Lisp_Object string;
+string_to_multibyte (Lisp_Object string)
{
unsigned char *buf;
EMACS_INT nbytes;
/* Convert STRING to a single-byte string. */
Lisp_Object
-string_make_unibyte (string)
- Lisp_Object string;
+string_make_unibyte (Lisp_Object string)
{
int nchars;
unsigned char *buf;
both in characters and in bytes. */
Lisp_Object
-substring_both (string, from, from_byte, to, to_byte)
- Lisp_Object string;
- int from, from_byte, to, to_byte;
+substring_both (Lisp_Object string, int from, int from_byte, int to, int to_byte)
{
Lisp_Object res;
int size;
Use only on lists known never to be circular. */
Lisp_Object
-assq_no_quit (key, list)
- Lisp_Object key, list;
+assq_no_quit (Lisp_Object key, Lisp_Object list)
{
while (CONSP (list)
&& (!CONSP (XCAR (list))
Use only on lists known never to be circular. */
Lisp_Object
-assoc_no_quit (key, list)
- Lisp_Object key, list;
+assoc_no_quit (Lisp_Object key, Lisp_Object list)
{
while (CONSP (list)
&& (!CONSP (XCAR (list))
return new;
}
\f
-Lisp_Object merge ();
+Lisp_Object merge (Lisp_Object org_l1, Lisp_Object org_l2, Lisp_Object pred);
DEFUN ("sort", Fsort, Ssort, 2, 2, 0,
doc: /* Sort LIST, stably, comparing elements using PREDICATE.
}
Lisp_Object
-merge (org_l1, org_l2, pred)
- Lisp_Object org_l1, org_l2;
- Lisp_Object pred;
+merge (Lisp_Object org_l1, Lisp_Object org_l2, Lisp_Object pred)
{
Lisp_Object value;
register Lisp_Object tail;
PROPS, if non-nil, means compare string text properties too. */
static int
-internal_equal (o1, o2, depth, props)
- register Lisp_Object o1, o2;
- int depth, props;
+internal_equal (register Lisp_Object o1, register Lisp_Object o2, int depth, int props)
{
if (depth > 200)
error ("Stack overflow in equal");
return 0;
}
\f
-extern Lisp_Object Fmake_char_internal ();
DEFUN ("fillarray", Ffillarray, Sfillarray, 2, 2, 0,
doc: /* Store each element of ARRAY with ITEM.
\f
/* ARGSUSED */
Lisp_Object
-nconc2 (s1, s2)
- Lisp_Object s1, s2;
+nconc2 (Lisp_Object s1, Lisp_Object s2)
{
Lisp_Object args[2];
args[0] = s1;
LENI is the length of VALS, which should also be the length of SEQ. */
static void
-mapcar1 (leni, vals, fn, seq)
- int leni;
- Lisp_Object *vals;
- Lisp_Object fn, seq;
+mapcar1 (int leni, Lisp_Object *vals, Lisp_Object fn, Lisp_Object seq)
{
register Lisp_Object tail;
Lisp_Object dummy;
Anything that calls this function must protect from GC! */
Lisp_Object
-do_yes_or_no_p (prompt)
- Lisp_Object prompt;
+do_yes_or_no_p (Lisp_Object prompt)
{
return call1 (intern ("yes-or-no-p"), prompt);
}
Lisp_Object require_nesting_list;
Lisp_Object
-require_unwind (old_value)
- Lisp_Object old_value;
+require_unwind (Lisp_Object old_value)
{
return require_nesting_list = old_value;
}
}
static int
-base64_encode_1 (from, to, length, line_break, multibyte)
- const char *from;
- char *to;
- int length;
- int line_break;
- int multibyte;
+base64_encode_1 (const char *from, char *to, int length, int line_break, int multibyte)
{
int counter = 0, i = 0;
char *e = to;
characters in *NCHARS_RETURN. */
static int
-base64_decode_1 (from, to, length, multibyte, nchars_return)
- const char *from;
- char *to;
- int length;
- int multibyte;
- int *nchars_return;
+base64_decode_1 (const char *from, char *to, int length, int multibyte, int *nchars_return)
{
int i = 0;
char *e = to;
Lisp_Hash_Table. Otherwise, signal an error. */
static struct Lisp_Hash_Table *
-check_hash_table (obj)
- Lisp_Object obj;
+check_hash_table (Lisp_Object obj)
{
CHECK_HASH_TABLE (obj);
return XHASH_TABLE (obj);
number. */
int
-next_almost_prime (n)
- int n;
+next_almost_prime (int n)
{
if (n % 2 == 0)
n += 1;
a DEFUN parameter list. */
static int
-get_key_arg (key, nargs, args, used)
- Lisp_Object key;
- int nargs;
- Lisp_Object *args;
- char *used;
+get_key_arg (Lisp_Object key, int nargs, Lisp_Object *args, char *used)
{
int i;
vector that are not copied from VEC are set to INIT. */
Lisp_Object
-larger_vector (vec, new_size, init)
- Lisp_Object vec;
- int new_size;
- Lisp_Object init;
+larger_vector (Lisp_Object vec, int new_size, Lisp_Object init)
{
struct Lisp_Vector *v;
int i, old_size;
KEY2 are the same. */
static int
-cmpfn_eql (h, key1, hash1, key2, hash2)
- struct Lisp_Hash_Table *h;
- Lisp_Object key1, key2;
- unsigned hash1, hash2;
+cmpfn_eql (struct Lisp_Hash_Table *h, Lisp_Object key1, unsigned int hash1, Lisp_Object key2, unsigned int hash2)
{
return (FLOATP (key1)
&& FLOATP (key2)
KEY2 are the same. */
static int
-cmpfn_equal (h, key1, hash1, key2, hash2)
- struct Lisp_Hash_Table *h;
- Lisp_Object key1, key2;
- unsigned hash1, hash2;
+cmpfn_equal (struct Lisp_Hash_Table *h, Lisp_Object key1, unsigned int hash1, Lisp_Object key2, unsigned int hash2)
{
return hash1 == hash2 && !NILP (Fequal (key1, key2));
}
if KEY1 and KEY2 are the same. */
static int
-cmpfn_user_defined (h, key1, hash1, key2, hash2)
- struct Lisp_Hash_Table *h;
- Lisp_Object key1, key2;
- unsigned hash1, hash2;
+cmpfn_user_defined (struct Lisp_Hash_Table *h, Lisp_Object key1, unsigned int hash1, Lisp_Object key2, unsigned int hash2)
{
if (hash1 == hash2)
{
in a Lisp integer. */
static unsigned
-hashfn_eq (h, key)
- struct Lisp_Hash_Table *h;
- Lisp_Object key;
+hashfn_eq (struct Lisp_Hash_Table *h, Lisp_Object key)
{
unsigned hash = XUINT (key) ^ XTYPE (key);
xassert ((hash & ~INTMASK) == 0);
in a Lisp integer. */
static unsigned
-hashfn_eql (h, key)
- struct Lisp_Hash_Table *h;
- Lisp_Object key;
+hashfn_eql (struct Lisp_Hash_Table *h, Lisp_Object key)
{
unsigned hash;
if (FLOATP (key))
in a Lisp integer. */
static unsigned
-hashfn_equal (h, key)
- struct Lisp_Hash_Table *h;
- Lisp_Object key;
+hashfn_equal (struct Lisp_Hash_Table *h, Lisp_Object key)
{
unsigned hash = sxhash (key, 0);
xassert ((hash & ~INTMASK) == 0);
guaranteed to fit in a Lisp integer. */
static unsigned
-hashfn_user_defined (h, key)
- struct Lisp_Hash_Table *h;
- Lisp_Object key;
+hashfn_user_defined (struct Lisp_Hash_Table *h, Lisp_Object key)
{
Lisp_Object args[2], hash;
only the table itself is. */
Lisp_Object
-copy_hash_table (h1)
- struct Lisp_Hash_Table *h1;
+copy_hash_table (struct Lisp_Hash_Table *h1)
{
Lisp_Object table;
struct Lisp_Hash_Table *h2;
because it's already too large, throw an error. */
static INLINE void
-maybe_resize_hash_table (h)
- struct Lisp_Hash_Table *h;
+maybe_resize_hash_table (struct Lisp_Hash_Table *h)
{
if (NILP (h->next_free))
{
matching KEY, or -1 if not found. */
int
-hash_lookup (h, key, hash)
- struct Lisp_Hash_Table *h;
- Lisp_Object key;
- unsigned *hash;
+hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key, unsigned int *hash)
{
unsigned hash_code;
int start_of_bucket;
Value is the index of the entry in H matching KEY. */
int
-hash_put (h, key, value, hash)
- struct Lisp_Hash_Table *h;
- Lisp_Object key, value;
- unsigned hash;
+hash_put (struct Lisp_Hash_Table *h, Lisp_Object key, Lisp_Object value, unsigned int hash)
{
int start_of_bucket, i;
/* Remove the entry matching KEY from hash table H, if there is one. */
static void
-hash_remove_from_table (h, key)
- struct Lisp_Hash_Table *h;
- Lisp_Object key;
+hash_remove_from_table (struct Lisp_Hash_Table *h, Lisp_Object key)
{
unsigned hash_code;
int start_of_bucket;
/* Clear hash table H. */
void
-hash_clear (h)
- struct Lisp_Hash_Table *h;
+hash_clear (struct Lisp_Hash_Table *h)
{
if (h->count > 0)
{
************************************************************************/
void
-init_weak_hash_tables ()
+init_weak_hash_tables (void)
{
weak_hash_tables = NULL;
}
non-zero if anything was marked. */
static int
-sweep_weak_table (h, remove_entries_p)
- struct Lisp_Hash_Table *h;
- int remove_entries_p;
+sweep_weak_table (struct Lisp_Hash_Table *h, int remove_entries_p)
{
int bucket, n, marked;
from Vweak_hash_tables. Called from gc_sweep. */
void
-sweep_weak_hash_tables ()
+sweep_weak_hash_tables (void)
{
struct Lisp_Hash_Table *h, *used, *next;
int marked;
code returned is guaranteed to fit in a Lisp integer. */
static unsigned
-sxhash_string (ptr, len)
- unsigned char *ptr;
- int len;
+sxhash_string (unsigned char *ptr, int len)
{
unsigned char *p = ptr;
unsigned char *end = p + len;
list. We don't recurse deeper than SXHASH_MAX_DEPTH in it. */
static unsigned
-sxhash_list (list, depth)
- Lisp_Object list;
- int depth;
+sxhash_list (Lisp_Object list, int depth)
{
unsigned hash = 0;
int i;
the Lisp structure. */
static unsigned
-sxhash_vector (vec, depth)
- Lisp_Object vec;
- int depth;
+sxhash_vector (Lisp_Object vec, int depth)
{
unsigned hash = ASIZE (vec);
int i, n;
/* Return a hash for bool-vector VECTOR. */
static unsigned
-sxhash_bool_vector (vec)
- Lisp_Object vec;
+sxhash_bool_vector (Lisp_Object vec)
{
unsigned hash = XBOOL_VECTOR (vec)->size;
int i, n;
structure. Value is an unsigned integer clipped to INTMASK. */
unsigned
-sxhash (obj, depth)
- Lisp_Object obj;
- int depth;
+sxhash (Lisp_Object obj, int depth)
{
unsigned hash;
\f
void
-syms_of_fns ()
+syms_of_fns (void)
{
/* Hash table stuff. */
Qhash_table_p = intern_c_string ("hash-table-p");
void
-init_fns ()
+init_fns (void)
{
}
/* Creaters of font-related Lisp object. */
Lisp_Object
-font_make_spec ()
+font_make_spec (void)
{
Lisp_Object font_spec;
struct font_spec *spec
}
Lisp_Object
-font_make_entity ()
+font_make_entity (void)
{
Lisp_Object font_entity;
struct font_entity *entity
not nil, copy properties from ENTITY to the font-object. If
PIXELSIZE is positive, set the `size' property to PIXELSIZE. */
Lisp_Object
-font_make_object (size, entity, pixelsize)
- int size;
- Lisp_Object entity;
- int pixelsize;
+font_make_object (int size, Lisp_Object entity, int pixelsize)
{
Lisp_Object font_object;
struct font *font
STR. */
Lisp_Object
-font_intern_prop (str, len, force_symbol)
- char *str;
- int len;
- int force_symbol;
+font_intern_prop (char *str, int len, int force_symbol)
{
int i;
Lisp_Object tem;
/* Return a pixel size of font-spec SPEC on frame F. */
static int
-font_pixel_size (f, spec)
- FRAME_PTR f;
- Lisp_Object spec;
+font_pixel_size (FRAME_PTR f, Lisp_Object spec)
{
#ifdef HAVE_WINDOW_SYSTEM
Lisp_Object size = AREF (spec, FONT_SIZE_INDEX);
VAL is an integer. */
int
-font_style_to_value (prop, val, noerror)
- enum font_property_index prop;
- Lisp_Object val;
- int noerror;
+font_style_to_value (enum font_property_index prop, Lisp_Object val, int noerror)
{
Lisp_Object table = AREF (font_style_table, prop - FONT_WEIGHT_INDEX);
int len = ASIZE (table);
}
Lisp_Object
-font_style_symbolic (font, prop, for_face)
- Lisp_Object font;
- enum font_property_index prop;
- int for_face;
+font_style_symbolic (Lisp_Object font, enum font_property_index prop, int for_face)
{
Lisp_Object val = AREF (font, prop);
Lisp_Object table, elt;
of the font. REPERTORY is a charset symbol or nil. */
Lisp_Object
-find_font_encoding (fontname)
- Lisp_Object fontname;
+find_font_encoding (Lisp_Object fontname)
{
Lisp_Object tail, elt;
REGISTRY is available, return 0. Otherwise return -1. */
int
-font_registry_charsets (registry, encoding, repertory)
- Lisp_Object registry;
- struct charset **encoding, **repertory;
+font_registry_charsets (Lisp_Object registry, struct charset **encoding, struct charset **repertory)
{
Lisp_Object val;
int encoding_id, repertory_id;
static int get_font_prop_index (Lisp_Object);
static Lisp_Object
-font_prop_validate_symbol (prop, val)
- Lisp_Object prop, val;
+font_prop_validate_symbol (Lisp_Object prop, Lisp_Object val)
{
if (STRINGP (val))
val = Fintern (val, Qnil);
static Lisp_Object
-font_prop_validate_style (style, val)
- Lisp_Object style, val;
+font_prop_validate_style (Lisp_Object style, Lisp_Object val)
{
enum font_property_index prop = (EQ (style, QCweight) ? FONT_WEIGHT_INDEX
: EQ (style, QCslant) ? FONT_SLANT_INDEX
}
static Lisp_Object
-font_prop_validate_non_neg (prop, val)
- Lisp_Object prop, val;
+font_prop_validate_non_neg (Lisp_Object prop, Lisp_Object val)
{
return (NATNUMP (val) || (FLOATP (val) && XFLOAT_DATA (val) >= 0)
? val : Qerror);
}
static Lisp_Object
-font_prop_validate_spacing (prop, val)
- Lisp_Object prop, val;
+font_prop_validate_spacing (Lisp_Object prop, Lisp_Object val)
{
if (NILP (val) || (NATNUMP (val) && XINT (val) <= FONT_SPACING_CHARCELL))
return val;
}
static Lisp_Object
-font_prop_validate_otf (prop, val)
- Lisp_Object prop, val;
+font_prop_validate_otf (Lisp_Object prop, Lisp_Object val)
{
Lisp_Object tail, tmp;
int i;
already known property. */
static int
-get_font_prop_index (key)
- Lisp_Object key;
+get_font_prop_index (Lisp_Object key)
{
int i;
signal an error. The value is VAL or the regularized one. */
static Lisp_Object
-font_prop_validate (idx, prop, val)
- int idx;
- Lisp_Object prop, val;
+font_prop_validate (int idx, Lisp_Object prop, Lisp_Object val)
{
Lisp_Object validated;
keeping the sorting order. Don't check the validity of VAL. */
Lisp_Object
-font_put_extra (font, prop, val)
- Lisp_Object font, prop, val;
+font_put_extra (Lisp_Object font, Lisp_Object prop, Lisp_Object val)
{
Lisp_Object extra = AREF (font, FONT_EXTRA_INDEX);
Lisp_Object slot = (NILP (extra) ? Qnil : assq_no_quit (prop, extra));
-1. */
static int
-parse_matrix (p)
- char *p;
+parse_matrix (char *p)
{
double matrix[4];
char *end;
field position by its contents. */
static int
-font_expand_wildcards (field, n)
- Lisp_Object field[XLFD_LAST_INDEX];
- int n;
+font_expand_wildcards (Lisp_Object *field, int n)
{
/* Copy of FIELD. */
Lisp_Object tmp[XLFD_LAST_INDEX];
a fully specified XLFD. */
int
-font_parse_xlfd (name, font)
- char *name;
- Lisp_Object font;
+font_parse_xlfd (char *name, Lisp_Object font)
{
int len = strlen (name);
int i, j, n;
0, use PIXEL_SIZE instead. */
int
-font_unparse_xlfd (font, pixel_size, name, nbytes)
- Lisp_Object font;
- int pixel_size;
- char *name;
- int nbytes;
+font_unparse_xlfd (Lisp_Object font, int pixel_size, char *name, int nbytes)
{
char *f[XLFD_REGISTRY_INDEX + 1];
Lisp_Object val;
This function tries to guess which format it is. */
int
-font_parse_fcname (name, font)
- char *name;
- Lisp_Object font;
+font_parse_fcname (char *name, Lisp_Object font)
{
char *p, *q;
char *size_beg = NULL, *size_end = NULL;
FONT_SIZE_INDEX of FONT is 0, use PIXEL_SIZE instead. */
int
-font_unparse_fcname (font, pixel_size, name, nbytes)
- Lisp_Object font;
- int pixel_size;
- char *name;
- int nbytes;
+font_unparse_fcname (Lisp_Object font, int pixel_size, char *name, int nbytes)
{
Lisp_Object family, foundry;
Lisp_Object tail, val;
size. */
int
-font_unparse_gtkname (font, f, name, nbytes)
- Lisp_Object font;
- struct frame *f;
- char *name;
- int nbytes;
+font_unparse_gtkname (Lisp_Object font, struct frame *f, char *name, int nbytes)
{
char *p;
int len = 1;
0. Otherwise return -1. */
static int
-font_parse_name (name, font)
- char *name;
- Lisp_Object font;
+font_parse_name (char *name, Lisp_Object font)
{
if (name[0] == '-' || index (name, '*') || index (name, '?'))
return font_parse_xlfd (name, font);
part. */
void
-font_parse_family_registry (family, registry, font_spec)
- Lisp_Object family, registry, font_spec;
+font_parse_family_registry (Lisp_Object family, Lisp_Object registry, Lisp_Object font_spec)
{
int len;
char *p0, *p1;
extern Lisp_Object Vface_font_rescale_alist;
static double
-font_rescale_ratio (font_entity)
- Lisp_Object font_entity;
+font_rescale_ratio (Lisp_Object font_entity)
{
Lisp_Object tail, elt;
Lisp_Object name = Qnil;
SPEC_PROP. */
static unsigned
-font_score (entity, spec_prop)
- Lisp_Object entity, *spec_prop;
+font_score (Lisp_Object entity, Lisp_Object *spec_prop)
{
unsigned score = 0;
int i;
/* The comparison function for qsort. */
static int
-font_compare (d1, d2)
- const void *d1, *d2;
+font_compare (const void *d1, const void *d2)
{
const struct font_sort_data *data1 = d1;
const struct font_sort_data *data2 = d2;
such a case. */
static Lisp_Object
-font_sort_entities (list, prefer, frame, best_only)
- Lisp_Object list, prefer, frame;
- int best_only;
+font_sort_entities (Lisp_Object list, Lisp_Object prefer, Lisp_Object frame, int best_only)
{
Lisp_Object prefer_prop[FONT_SPEC_MAX];
int len, maxlen, i;
function with font_sort_order after setting up it. */
void
-font_update_sort_order (order)
- int *order;
+font_update_sort_order (int *order)
{
int i, shift_bits;
}
static int
-font_check_otf_features (script, langsys, features, table)
- Lisp_Object script, langsys, features, table;
+font_check_otf_features (Lisp_Object script, Lisp_Object langsys, Lisp_Object features, Lisp_Object table)
{
Lisp_Object val;
int negative;
specification SPEC. */
int
-font_match_p (spec, font)
- Lisp_Object spec, font;
+font_match_p (Lisp_Object spec, Lisp_Object font)
{
Lisp_Object prop[FONT_SPEC_MAX], *props;
Lisp_Object extra, font_extra;
struct font_driver *);
static void
-font_prepare_cache (f, driver)
- FRAME_PTR f;
- struct font_driver *driver;
+font_prepare_cache (FRAME_PTR f, struct font_driver *driver)
{
Lisp_Object cache, val;
static void
-font_finish_cache (f, driver)
- FRAME_PTR f;
- struct font_driver *driver;
+font_finish_cache (FRAME_PTR f, struct font_driver *driver)
{
Lisp_Object cache, val, tmp;
static Lisp_Object
-font_get_cache (f, driver)
- FRAME_PTR f;
- struct font_driver *driver;
+font_get_cache (FRAME_PTR f, struct font_driver *driver)
{
Lisp_Object val = driver->get_cache (f);
Lisp_Object type = driver->type;
static int num_fonts;
static void
-font_clear_cache (f, cache, driver)
- FRAME_PTR f;
- Lisp_Object cache;
- struct font_driver *driver;
+font_clear_cache (FRAME_PTR f, Lisp_Object cache, struct font_driver *driver)
{
Lisp_Object tail, elt;
Lisp_Object tail2, entity;
extern Lisp_Object Vface_ignored_fonts;
Lisp_Object
-font_delete_unmatched (vec, spec, size)
- Lisp_Object vec, spec;
- int size;
+font_delete_unmatched (Lisp_Object vec, Lisp_Object spec, int size)
{
Lisp_Object entity, val;
enum font_property_index prop;
same font-driver. */
Lisp_Object
-font_list_entities (frame, spec)
- Lisp_Object frame, spec;
+font_list_entities (Lisp_Object frame, Lisp_Object spec)
{
FRAME_PTR f = XFRAME (frame);
struct font_driver_list *driver_list = f->font_driver_list;
font-related attributes. */
static Lisp_Object
-font_matching_entity (f, attrs, spec)
- FRAME_PTR f;
- Lisp_Object *attrs, spec;
+font_matching_entity (FRAME_PTR f, Lisp_Object *attrs, Lisp_Object spec)
{
struct font_driver_list *driver_list = f->font_driver_list;
Lisp_Object ftype, size, entity;
opened font object. */
static Lisp_Object
-font_open_entity (f, entity, pixel_size)
- FRAME_PTR f;
- Lisp_Object entity;
- int pixel_size;
+font_open_entity (FRAME_PTR f, Lisp_Object entity, int pixel_size)
{
struct font_driver_list *driver_list;
Lisp_Object objlist, size, val, font_object;
/* Close FONT_OBJECT that is opened on frame F. */
void
-font_close_object (f, font_object)
- FRAME_PTR f;
- Lisp_Object font_object;
+font_close_object (FRAME_PTR f, Lisp_Object font_object)
{
struct font *font = XFONT_OBJECT (font_object);
FONT is a font-entity and it must be opened to check. */
int
-font_has_char (f, font, c)
- FRAME_PTR f;
- Lisp_Object font;
- int c;
+font_has_char (FRAME_PTR f, Lisp_Object font, int c)
{
struct font *fontp;
/* Return the glyph ID of FONT_OBJECT for character C. */
unsigned
-font_encode_char (font_object, c)
- Lisp_Object font_object;
- int c;
+font_encode_char (Lisp_Object font_object, int c)
{
struct font *font;
/* Return the name of FONT_OBJECT. */
Lisp_Object
-font_get_name (font_object)
- Lisp_Object font_object;
+font_get_name (Lisp_Object font_object)
{
font_assert (FONT_OBJECT_P (font_object));
return AREF (font_object, FONT_NAME_INDEX);
/* Return the specification of FONT_OBJECT. */
Lisp_Object
-font_get_spec (font_object)
- Lisp_Object font_object;
+font_get_spec (Lisp_Object font_object)
{
Lisp_Object spec = font_make_spec ();
int i;
could not be parsed by font_parse_name, return Qnil. */
Lisp_Object
-font_spec_from_name (font_name)
- Lisp_Object font_name;
+font_spec_from_name (Lisp_Object font_name)
{
Lisp_Object spec = Ffont_spec (0, NULL);
void
-font_clear_prop (attrs, prop)
- Lisp_Object *attrs;
- enum font_property_index prop;
+font_clear_prop (Lisp_Object *attrs, enum font_property_index prop)
{
Lisp_Object font = attrs[LFACE_FONT_INDEX];
}
void
-font_update_lface (f, attrs)
- FRAME_PTR f;
- Lisp_Object *attrs;
+font_update_lface (FRAME_PTR f, Lisp_Object *attrs)
{
Lisp_Object spec;
supports C and matches best with ATTRS and PIXEL_SIZE. */
static Lisp_Object
-font_select_entity (frame, entities, attrs, pixel_size, c)
- Lisp_Object frame, entities, *attrs;
- int pixel_size, c;
+font_select_entity (Lisp_Object frame, Lisp_Object entities, Lisp_Object *attrs, int pixel_size, int c)
{
Lisp_Object font_entity;
Lisp_Object prefer;
character that the entity must support. */
Lisp_Object
-font_find_for_lface (f, attrs, spec, c)
- FRAME_PTR f;
- Lisp_Object *attrs;
- Lisp_Object spec;
- int c;
+font_find_for_lface (FRAME_PTR f, Lisp_Object *attrs, Lisp_Object spec, int c)
{
Lisp_Object work;
Lisp_Object frame, entities, val;
Lisp_Object
-font_open_for_lface (f, entity, attrs, spec)
- FRAME_PTR f;
- Lisp_Object entity;
- Lisp_Object *attrs;
- Lisp_Object spec;
+font_open_for_lface (FRAME_PTR f, Lisp_Object entity, Lisp_Object *attrs, Lisp_Object spec)
{
int size;
font-object. */
Lisp_Object
-font_load_for_lface (f, attrs, spec)
- FRAME_PTR f;
- Lisp_Object *attrs, spec;
+font_load_for_lface (FRAME_PTR f, Lisp_Object *attrs, Lisp_Object spec)
{
Lisp_Object entity, name;
/* Make FACE on frame F ready to use the font opened for FACE. */
void
-font_prepare_for_face (f, face)
- FRAME_PTR f;
- struct face *face;
+font_prepare_for_face (FRAME_PTR f, struct face *face)
{
if (face->font->driver->prepare_face)
face->font->driver->prepare_face (f, face);
/* Make FACE on frame F stop using the font opened for FACE. */
void
-font_done_for_face (f, face)
- FRAME_PTR f;
- struct face *face;
+font_done_for_face (FRAME_PTR f, struct face *face)
{
if (face->font->driver->done_face)
face->font->driver->done_face (f, face);
font is found, return Qnil. */
Lisp_Object
-font_open_by_spec (f, spec)
- FRAME_PTR f;
- Lisp_Object spec;
+font_open_by_spec (FRAME_PTR f, Lisp_Object spec)
{
Lisp_Object attrs[LFACE_VECTOR_SIZE];
found, return Qnil. */
Lisp_Object
-font_open_by_name (f, name)
- FRAME_PTR f;
- char *name;
+font_open_by_name (FRAME_PTR f, char *name)
{
Lisp_Object args[2];
Lisp_Object spec, ret;
(e.g. syms_of_xfont). */
void
-register_font_driver (driver, f)
- struct font_driver *driver;
- FRAME_PTR f;
+register_font_driver (struct font_driver *driver, FRAME_PTR f)
{
struct font_driver_list *root = f ? f->font_driver_list : font_driver_list;
struct font_driver_list *prev, *list;
}
void
-free_font_driver_list (f)
- FRAME_PTR f;
+free_font_driver_list (FRAME_PTR f)
{
struct font_driver_list *list, *next;
F. */
Lisp_Object
-font_update_drivers (f, new_drivers)
- FRAME_PTR f;
- Lisp_Object new_drivers;
+font_update_drivers (FRAME_PTR f, Lisp_Object new_drivers)
{
Lisp_Object active_drivers = Qnil;
struct font_driver *driver;
}
int
-font_put_frame_data (f, driver, data)
- FRAME_PTR f;
- struct font_driver *driver;
- void *data;
+font_put_frame_data (FRAME_PTR f, struct font_driver *driver, void *data)
{
struct font_data_list *list, *prev;
void *
-font_get_frame_data (f, driver)
- FRAME_PTR f;
- struct font_driver *driver;
+font_get_frame_data (FRAME_PTR f, struct font_driver *driver)
{
struct font_data_list *list;
STRING. */
Lisp_Object
-font_at (c, pos, face, w, string)
- int c;
- EMACS_INT pos;
- struct face *face;
- struct window *w;
- Lisp_Object string;
+font_at (int c, EMACS_INT pos, struct face *face, struct window *w, Lisp_Object string)
{
FRAME_PTR f;
int multibyte;
It is assured that the current buffer (or STRING) is multibyte. */
Lisp_Object
-font_range (pos, limit, w, face, string)
- EMACS_INT pos, *limit;
- struct window *w;
- struct face *face;
- Lisp_Object string;
+font_range (EMACS_INT pos, EMACS_INT *limit, struct window *w, struct face *face, Lisp_Object string)
{
EMACS_INT pos_byte, ignore;
int c;
\f
void
-font_fill_lglyph_metrics (glyph, font_object)
- Lisp_Object glyph, font_object;
+font_fill_lglyph_metrics (Lisp_Object glyph, Lisp_Object font_object)
{
struct font *font = XFONT_OBJECT (font_object);
unsigned code;
build_style_table ((TBL), sizeof TBL / sizeof (struct table_entry))
static Lisp_Object
-build_style_table (entry, nelement)
- struct table_entry *entry;
- int nelement;
+build_style_table (const struct table_entry *entry, int nelement)
{
int i, j;
Lisp_Object table, elt;
opening), ARG is the argument for the action, and RESULT is the
result of the action. */
void
-font_add_log (action, arg, result)
- char *action;
- Lisp_Object arg, result;
+font_add_log (char *action, Lisp_Object arg, Lisp_Object result)
{
Lisp_Object tail, val;
int i;
as font_add_log. */
void
-font_deferred_log (action, arg, result)
- char *action;
- Lisp_Object arg, result;
+font_deferred_log (char *action, Lisp_Object arg, Lisp_Object result)
{
if (EQ (Vfont_log, Qt))
return;
ASET (Vfont_log_deferred, 2, result);
}
-extern void syms_of_ftfont ();
-extern void syms_of_xfont ();
-extern void syms_of_xftfont ();
-extern void syms_of_ftxfont ();
-extern void syms_of_bdffont ();
-extern void syms_of_w32font ();
-extern void syms_of_atmfont ();
-extern void syms_of_nsfont ();
+extern void syms_of_ftfont (void);
+extern void syms_of_xfont (void);
+extern void syms_of_xftfont (void);
+extern void syms_of_ftxfont (void);
+extern void syms_of_bdffont (void);
+extern void syms_of_w32font (void);
+extern void syms_of_atmfont (void);
+extern void syms_of_nsfont (void);
void
-syms_of_font ()
+syms_of_font (void)
{
sort_shift_bits[FONT_TYPE_INDEX] = 0;
sort_shift_bits[FONT_SLANT_INDEX] = 2;
}
void
-init_font ()
+init_font (void)
{
Vfont_log = egetenv ("EMACS_FONT_LOG") ? Qnil : Qt;
}
: fontset_ref ((fontset), (c)))
static Lisp_Object
-fontset_ref (fontset, c)
- Lisp_Object fontset;
- int c;
+fontset_ref (Lisp_Object fontset, int c)
{
Lisp_Object elt;
: fontset_add ((fontset), (range), (elt), (add)))
static Lisp_Object
-fontset_add (fontset, range, elt, add)
- Lisp_Object fontset, range, elt, add;
+fontset_add (Lisp_Object fontset, Lisp_Object range, Lisp_Object elt, Lisp_Object add)
{
Lisp_Object args[2];
int idx = (EQ (add, Qappend) ? 0 : 1);
}
static int
-fontset_compare_rfontdef (val1, val2)
- const void *val1, *val2;
+fontset_compare_rfontdef (const void *val1, const void *val2)
{
return (RFONT_DEF_SCORE (*(Lisp_Object *) val1)
- RFONT_DEF_SCORE (*(Lisp_Object *) val2));
If PREFERRED_FAMILY is not nil, that family has the higher priority
if the encoding charsets or languages in font-specs are the same. */
-extern Lisp_Object Fassoc_string ();
+extern Lisp_Object Fassoc_string (Lisp_Object, Lisp_Object, Lisp_Object);
static void
-reorder_font_vector (font_group, font)
- Lisp_Object font_group;
- struct font *font;
+reorder_font_vector (Lisp_Object font_group, struct font *font)
{
Lisp_Object vec, font_object;
int size;
If FALLBACK is nonzero, search only fallback fonts. */
static Lisp_Object
-fontset_find_font (fontset, c, face, id, fallback)
- Lisp_Object fontset;
- int c;
- struct face *face;
- int id, fallback;
+fontset_find_font (Lisp_Object fontset, int c, struct face *face, int id, int fallback)
{
Lisp_Object vec, font_group;
int i, charset_matched = 0, found_index;
static Lisp_Object
-fontset_font (fontset, c, face, id)
- Lisp_Object fontset;
- int c;
- struct face *face;
- int id;
+fontset_font (Lisp_Object fontset, int c, struct face *face, int id)
{
Lisp_Object rfont_def, default_rfont_def;
Lisp_Object base_fontset;
BASE. */
static Lisp_Object
-make_fontset (frame, name, base)
- Lisp_Object frame, name, base;
+make_fontset (Lisp_Object frame, Lisp_Object name, Lisp_Object base)
{
Lisp_Object fontset;
int size = ASIZE (Vfontset_table);
/* Return the name of the fontset who has ID. */
Lisp_Object
-fontset_name (id)
- int id;
+fontset_name (int id)
{
Lisp_Object fontset;
/* Return the ASCII font name of the fontset who has ID. */
Lisp_Object
-fontset_ascii (id)
- int id;
+fontset_ascii (int id)
{
Lisp_Object fontset, elt;
}
void
-free_realized_fontset (f, fontset)
- FRAME_PTR f;
- Lisp_Object fontset;
+free_realized_fontset (FRAME_PTR f, Lisp_Object fontset)
{
Lisp_Object tail;
free_realized_face. */
void
-free_face_fontset (f, face)
- FRAME_PTR f;
- struct face *face;
+free_face_fontset (FRAME_PTR f, struct face *face)
{
Lisp_Object fontset;
when C is not an ASCII character. */
int
-face_suitable_for_char_p (face, c)
- struct face *face;
- int c;
+face_suitable_for_char_p (struct face *face, int c)
{
Lisp_Object fontset, rfont_def;
the macro FACE_FOR_CHAR. */
int
-face_for_char (f, face, c, pos, object)
- FRAME_PTR f;
- struct face *face;
- int c, pos;
- Lisp_Object object;
+face_for_char (FRAME_PTR f, struct face *face, int c, int pos, Lisp_Object object)
{
Lisp_Object fontset, rfont_def, charset;
int face_id;
Lisp_Object
-font_for_char (face, c, pos, object)
- struct face *face;
- int c, pos;
- Lisp_Object object;
+font_for_char (struct face *face, int c, int pos, Lisp_Object object)
{
Lisp_Object fontset, rfont_def, charset;
int id;
Called from realize_x_face. */
int
-make_fontset_for_ascii_face (f, base_fontset_id, face)
- FRAME_PTR f;
- int base_fontset_id;
- struct face *face;
+make_fontset_for_ascii_face (FRAME_PTR f, int base_fontset_id, struct face *face)
{
Lisp_Object base_fontset, fontset, frame;
expression corresponding to PATTERN. */
static Lisp_Object
-fontset_pattern_regexp (pattern)
- Lisp_Object pattern;
+fontset_pattern_regexp (Lisp_Object pattern)
{
if (!index ((char *) SDATA (pattern), '*')
&& !index ((char *) SDATA (pattern), '?'))
*/
int
-fs_query_fontset (name, name_pattern)
- Lisp_Object name;
- int name_pattern;
+fs_query_fontset (Lisp_Object name, int name_pattern)
{
Lisp_Object tem;
int i;
/* Return a list of base fontset names matching PATTERN on frame F. */
Lisp_Object
-list_fontsets (f, pattern, size)
- FRAME_PTR f;
- Lisp_Object pattern;
- int size;
+list_fontsets (FRAME_PTR f, Lisp_Object pattern, int size)
{
Lisp_Object frame, regexp, val;
int id;
/* Free all realized fontsets whose base fontset is BASE. */
static void
-free_realized_fontsets (base)
- Lisp_Object base;
+free_realized_fontsets (Lisp_Object base)
{
int id;
Set *FRAME to the actual frame. */
static Lisp_Object
-check_fontset_name (name, frame)
- Lisp_Object name, *frame;
+check_fontset_name (Lisp_Object name, Lisp_Object *frame)
{
int id;
}
static void
-accumulate_script_ranges (arg, range, val)
- Lisp_Object arg, range, val;
+accumulate_script_ranges (Lisp_Object arg, Lisp_Object range, Lisp_Object val)
{
if (EQ (XCAR (arg), val))
{
case. */
static void
-set_fontset_font (arg, range)
- Lisp_Object arg, range;
+set_fontset_font (Lisp_Object arg, Lisp_Object range)
{
Lisp_Object fontset, font_def, add, ascii, script_range_list;
int from = XINT (XCAR (range)), to = XINT (XCDR (range));
user intends to use FONT-OBJECT for Latin characters. */
int
-fontset_from_font (font_object)
- Lisp_Object font_object;
+fontset_from_font (Lisp_Object font_object)
{
Lisp_Object font_name = font_get_name (font_object);
Lisp_Object font_spec = Fcopy_font_spec (font_object);
fontset_from_font. */
static void
-update_auto_fontset_alist (font_object, fontset)
- Lisp_Object font_object, fontset;
+update_auto_fontset_alist (Lisp_Object font_object, Lisp_Object fontset)
{
Lisp_Object prev, tail;
#endif /* FONTSET_DEBUG */
void
-syms_of_fontset ()
+syms_of_fontset (void)
{
DEFSYM (Qfontset, "fontset");
Fput (Qfontset, Qchar_table_extra_slots, make_number (9));
int focus_follows_mouse;
\f
static void
-set_menu_bar_lines_1 (window, n)
- Lisp_Object window;
- int n;
+set_menu_bar_lines_1 (Lisp_Object window, int n)
{
struct window *w = XWINDOW (window);
}
void
-set_menu_bar_lines (f, value, oldval)
- struct frame *f;
- Lisp_Object value, oldval;
+set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
{
int nlines;
int olines = FRAME_MENU_BAR_LINES (f);
Lisp_Object Vframe_list;
extern Lisp_Object Vminibuffer_list;
-extern Lisp_Object get_minibuffer ();
-extern Lisp_Object Fhandle_switch_frame ();
-extern Lisp_Object Fredirect_frame_focus ();
+extern Lisp_Object get_minibuffer (int);
+extern Lisp_Object Fhandle_switch_frame (Lisp_Object event);
+extern Lisp_Object Fredirect_frame_focus (Lisp_Object frame, Lisp_Object focus_frame);
extern Lisp_Object x_get_focus_frame ();
extern Lisp_Object QCname, Qfont_param;
}
struct frame *
-make_frame (mini_p)
- int mini_p;
+make_frame (int mini_p)
{
Lisp_Object frame;
register struct frame *f;
default (the global minibuffer). */
struct frame *
-make_frame_without_minibuffer (mini_window, kb, display)
- register Lisp_Object mini_window;
- KBOARD *kb;
- Lisp_Object display;
+make_frame_without_minibuffer (register Lisp_Object mini_window, KBOARD *kb, Lisp_Object display)
{
register struct frame *f;
struct gcpro gcpro1;
/* Make a frame containing only a minibuffer window. */
struct frame *
-make_minibuffer_frame ()
+make_minibuffer_frame (void)
{
/* First make a frame containing just a root window, no minibuffer. */
The value of NORECORD is passed as argument to Fselect_window. */
Lisp_Object
-do_switch_frame (frame, track, for_deletion, norecord)
- Lisp_Object frame, norecord;
- int track, for_deletion;
+do_switch_frame (Lisp_Object frame, int track, int for_deletion, Lisp_Object norecord)
{
struct frame *sf = SELECTED_FRAME ();
Otherwise, include all frames. */
static Lisp_Object
-next_frame (frame, minibuf)
- Lisp_Object frame;
- Lisp_Object minibuf;
+next_frame (Lisp_Object frame, Lisp_Object minibuf)
{
Lisp_Object tail;
int passed = 0;
Otherwise, include all frames. */
static Lisp_Object
-prev_frame (frame, minibuf)
- Lisp_Object frame;
- Lisp_Object minibuf;
+prev_frame (Lisp_Object frame, Lisp_Object minibuf)
{
Lisp_Object tail;
Lisp_Object prev;
(Exception: if F is the terminal frame, and we are using X, return 1.) */
int
-other_visible_frames (f)
- FRAME_PTR f;
+other_visible_frames (FRAME_PTR f)
{
/* We know the selected frame is visible,
so if F is some other frame, it can't be the sole visible one. */
this. Any other value of FORCE implements the semantics
described for Fdelete_frame. */
Lisp_Object
-delete_frame (frame, force)
+delete_frame (Lisp_Object frame, Lisp_Object force)
/* If we use `register' here, gcc-4.0.2 on amd64 using
-DUSE_LISP_UNION_TYPE complains further down that we're getting the
address of `force'. Go figure. */
- Lisp_Object frame, force;
+
{
struct frame *f;
struct frame *sf = SELECTED_FRAME ();
and all its descendents. */
static void
-make_frame_visible_1 (window)
- Lisp_Object window;
+make_frame_visible_1 (Lisp_Object window)
{
struct window *w;
/* Return the value of frame parameter PROP in frame FRAME. */
Lisp_Object
-get_frame_param (frame, prop)
- register struct frame *frame;
- Lisp_Object prop;
+get_frame_param (register struct frame *frame, Lisp_Object prop)
{
register Lisp_Object tem;
/* Return the buffer-predicate of the selected frame. */
Lisp_Object
-frame_buffer_predicate (frame)
- Lisp_Object frame;
+frame_buffer_predicate (Lisp_Object frame)
{
return XFRAME (frame)->buffer_predicate;
}
/* Return the buffer-list of the selected frame. */
Lisp_Object
-frame_buffer_list (frame)
- Lisp_Object frame;
+frame_buffer_list (Lisp_Object frame)
{
return XFRAME (frame)->buffer_list;
}
/* Set the buffer-list of the selected frame. */
void
-set_frame_buffer_list (frame, list)
- Lisp_Object frame, list;
+set_frame_buffer_list (Lisp_Object frame, Lisp_Object list)
{
XFRAME (frame)->buffer_list = list;
}
/* Discard BUFFER from the buffer-list and buried-buffer-list of each frame. */
void
-frames_discard_buffer (buffer)
- Lisp_Object buffer;
+frames_discard_buffer (Lisp_Object buffer)
{
Lisp_Object frame, tail;
If the alist already has an element for PROP, we change it. */
void
-store_in_alist (alistptr, prop, val)
- Lisp_Object *alistptr, val;
- Lisp_Object prop;
+store_in_alist (Lisp_Object *alistptr, Lisp_Object prop, Lisp_Object val)
{
register Lisp_Object tem;
}
static int
-frame_name_fnn_p (str, len)
- char *str;
- EMACS_INT len;
+frame_name_fnn_p (char *str, EMACS_INT len)
{
if (len > 1 && str[0] == 'F')
{
Modeled after x_set_name which is used for WINDOW frames. */
static void
-set_term_frame_name (f, name)
- struct frame *f;
- Lisp_Object name;
+set_term_frame_name (struct frame *f, Lisp_Object name)
{
f->explicit_name = ! NILP (name);
}
void
-store_frame_param (f, prop, val)
- struct frame *f;
- Lisp_Object prop, val;
+store_frame_param (struct frame *f, Lisp_Object prop, Lisp_Object val)
{
register Lisp_Object old_alist_elt;
*/
void
-x_fullscreen_adjust (f, width, height, top_pos, left_pos)
- struct frame *f;
- int *width;
- int *height;
- int *top_pos;
- int *left_pos;
+x_fullscreen_adjust (struct frame *f, int *width, int *height, int *top_pos, int *left_pos)
{
int newwidth = FRAME_COLS (f);
int newheight = FRAME_LINES (f);
to store the new value in the parameter alist. */
void
-x_set_frame_parameters (f, alist)
- FRAME_PTR f;
- Lisp_Object alist;
+x_set_frame_parameters (FRAME_PTR f, Lisp_Object alist)
{
Lisp_Object tail;
param_alist need to be considered here. */
void
-x_report_frame_params (f, alistptr)
- struct frame *f;
- Lisp_Object *alistptr;
+x_report_frame_params (struct frame *f, Lisp_Object *alistptr)
{
char buf[16];
Lisp_Object tem;
the previous value of that parameter, NEW_VALUE is the new value. */
void
-x_set_fullscreen (f, new_value, old_value)
- struct frame *f;
- Lisp_Object new_value, old_value;
+x_set_fullscreen (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
{
if (NILP (new_value))
f->want_fullscreen = FULLSCREEN_NONE;
the previous value of that parameter, NEW_VALUE is the new value. */
void
-x_set_line_spacing (f, new_value, old_value)
- struct frame *f;
- Lisp_Object new_value, old_value;
+x_set_line_spacing (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
{
if (NILP (new_value))
f->extra_line_spacing = 0;
the previous value of that parameter, NEW_VALUE is the new value. */
void
-x_set_screen_gamma (f, new_value, old_value)
- struct frame *f;
- Lisp_Object new_value, old_value;
+x_set_screen_gamma (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
{
Lisp_Object bgcolor;
void
-x_set_font (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_font (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
Lisp_Object frame, font_object, font_param = Qnil;
int fontset = -1;
void
-x_set_font_backend (f, new_value, old_value)
- struct frame *f;
- Lisp_Object new_value, old_value;
+x_set_font_backend (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
{
if (! NILP (new_value)
&& !CONSP (new_value))
void
-x_set_fringe_width (f, new_value, old_value)
- struct frame *f;
- Lisp_Object new_value, old_value;
+x_set_fringe_width (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
{
compute_fringe_widths (f, 1);
}
void
-x_set_border_width (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_border_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
CHECK_NUMBER (arg);
}
void
-x_set_internal_border_width (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_internal_border_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
int old = FRAME_INTERNAL_BORDER_WIDTH (f);
}
void
-x_set_visibility (f, value, oldval)
- struct frame *f;
- Lisp_Object value, oldval;
+x_set_visibility (struct frame *f, Lisp_Object value, Lisp_Object oldval)
{
Lisp_Object frame;
XSETFRAME (frame, f);
}
void
-x_set_autoraise (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_autoraise (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
f->auto_raise = !EQ (Qnil, arg);
}
void
-x_set_autolower (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_autolower (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
f->auto_lower = !EQ (Qnil, arg);
}
void
-x_set_unsplittable (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_unsplittable (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
f->no_split = !NILP (arg);
}
void
-x_set_vertical_scroll_bars (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_vertical_scroll_bars (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
if ((EQ (arg, Qleft) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
|| (EQ (arg, Qright) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f))
}
void
-x_set_scroll_bar_width (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_scroll_bar_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
int wid = FRAME_COLUMN_WIDTH (f);
/* Return non-nil if frame F wants a bitmap icon. */
Lisp_Object
-x_icon_type (f)
- FRAME_PTR f;
+x_icon_type (FRAME_PTR f)
{
Lisp_Object tem;
}
void
-x_set_alpha (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_alpha (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
double alpha = 1.0;
double newval[2];
Fix it up, or set it to `emacs' if it is too hopeless. */
void
-validate_x_resource_name ()
+validate_x_resource_name (void)
{
int len = 0;
/* Number of valid characters in the resource name. */
See Fx_get_resource below for other parameters. */
static Lisp_Object
-xrdb_get_resource (rdb, attribute, class, component, subclass)
- XrmDatabase rdb;
- Lisp_Object attribute, class, component, subclass;
+xrdb_get_resource (XrmDatabase rdb, Lisp_Object attribute, Lisp_Object class, Lisp_Object component, Lisp_Object subclass)
{
register char *value;
char *name_key;
/* Get an X resource, like Fx_get_resource, but for display DPYINFO. */
Lisp_Object
-display_x_get_resource (dpyinfo, attribute, class, component, subclass)
- Display_Info *dpyinfo;
- Lisp_Object attribute, class, component, subclass;
+display_x_get_resource (Display_Info *dpyinfo, Lisp_Object attribute, Lisp_Object class, Lisp_Object component, Lisp_Object subclass)
{
return xrdb_get_resource (dpyinfo->xrdb,
attribute, class, component, subclass);
/* Used when C code wants a resource value. */
/* Called from oldXMenu/Create.c. */
char *
-x_get_resource_string (attribute, class)
- char *attribute, *class;
+x_get_resource_string (char *attribute, char *class)
{
char *name_key;
char *class_key;
and don't let it get stored in any Lisp-visible variables! */
Lisp_Object
-x_get_arg (dpyinfo, alist, param, attribute, class, type)
- Display_Info *dpyinfo;
- Lisp_Object alist, param;
- char *attribute;
- char *class;
- enum resource_types type;
+x_get_arg (Display_Info *dpyinfo, Lisp_Object alist, Lisp_Object param, char *attribute, char *class, enum resource_types type)
{
register Lisp_Object tem;
}
Lisp_Object
-x_frame_get_arg (f, alist, param, attribute, class, type)
- struct frame *f;
- Lisp_Object alist, param;
- char *attribute;
- char *class;
- enum resource_types type;
+x_frame_get_arg (struct frame *f, Lisp_Object alist, Lisp_Object param, char *attribute, char *class, enum resource_types type)
{
return x_get_arg (FRAME_X_DISPLAY_INFO (f),
alist, param, attribute, class, type);
/* Like x_frame_get_arg, but also record the value in f->param_alist. */
Lisp_Object
-x_frame_get_and_record_arg (f, alist, param, attribute, class, type)
- struct frame *f;
- Lisp_Object alist, param;
- char *attribute;
- char *class;
- enum resource_types type;
+x_frame_get_and_record_arg (struct frame *f, Lisp_Object alist, Lisp_Object param, char *attribute, char *class, enum resource_types type)
{
Lisp_Object value;
If that is not found either, use the value DEFLT. */
Lisp_Object
-x_default_parameter (f, alist, prop, deflt, xprop, xclass, type)
- struct frame *f;
- Lisp_Object alist;
- Lisp_Object prop;
- Lisp_Object deflt;
- char *xprop;
- char *xclass;
- enum resource_types type;
+x_default_parameter (struct frame *f, Lisp_Object alist, Lisp_Object prop, Lisp_Object deflt, char *xprop, char *xclass, enum resource_types type)
{
Lisp_Object tem;
#define DEFAULT_COLS 80
int
-x_figure_window_size (f, parms, toolbar_p)
- struct frame *f;
- Lisp_Object parms;
- int toolbar_p;
+x_figure_window_size (struct frame *f, Lisp_Object parms, int toolbar_p)
{
register Lisp_Object tem0, tem1, tem2;
long window_prompting = 0;
#endif /* HAVE_WINDOW_SYSTEM */
void
-frame_make_pointer_invisible ()
+frame_make_pointer_invisible (void)
{
if (! NILP (Vmake_pointer_invisible))
{
}
void
-frame_make_pointer_visible ()
+frame_make_pointer_visible (void)
{
/* We don't check Vmake_pointer_invisible here in case the
pointer was invisible when Vmake_pointer_invisible was set to nil. */
***********************************************************************/
void
-syms_of_frame ()
+syms_of_frame (void)
{
Qframep = intern_c_string ("framep");
staticpro (&Qframep);
Return 0 if not a bitmap. */
int
-lookup_fringe_bitmap (bitmap)
- Lisp_Object bitmap;
+lookup_fringe_bitmap (Lisp_Object bitmap)
{
int bn;
Return BN if not found in Vfringe_bitmaps. */
static Lisp_Object
-get_fringe_bitmap_name (bn)
- int bn;
+get_fringe_bitmap_name (int bn)
{
Lisp_Object bitmaps;
Lisp_Object num;
*/
static void
-draw_fringe_bitmap_1 (w, row, left_p, overlay, which)
- struct window *w;
- struct glyph_row *row;
- int left_p, overlay;
- int which;
+draw_fringe_bitmap_1 (struct window *w, struct glyph_row *row, int left_p, int overlay, int which)
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
struct draw_fringe_bitmap_params p;
}
static int
-get_logical_cursor_bitmap (w, cursor)
- struct window *w;
- Lisp_Object cursor;
+get_logical_cursor_bitmap (struct window *w, Lisp_Object cursor)
{
Lisp_Object cmap, bm = Qnil;
}
static int
-get_logical_fringe_bitmap (w, bitmap, right_p, partial_p)
- struct window *w;
- Lisp_Object bitmap;
- int right_p, partial_p;
+get_logical_fringe_bitmap (struct window *w, Lisp_Object bitmap, int right_p, int partial_p)
{
Lisp_Object cmap, bm1 = Qnil, bm2 = Qnil, bm;
int ln1 = 0, ln2 = 0;
void
-draw_fringe_bitmap (w, row, left_p)
- struct window *w;
- struct glyph_row *row;
- int left_p;
+draw_fringe_bitmap (struct window *w, struct glyph_row *row, int left_p)
{
int overlay = 0;
function with input blocked. */
void
-draw_row_fringe_bitmaps (w, row)
- struct window *w;
- struct glyph_row *row;
+draw_row_fringe_bitmaps (struct window *w, struct glyph_row *row)
{
xassert (interrupt_input_blocked);
*/
int
-draw_window_fringes (w, no_fringe)
- struct window *w;
- int no_fringe;
+draw_window_fringes (struct window *w, int no_fringe)
{
struct glyph_row *row;
int yb = window_text_bottom_y (w);
If KEEP_CURRENT_P is 0, update current_matrix too. */
int
-update_window_fringes (w, keep_current_p)
- struct window *w;
- int keep_current_p;
+update_window_fringes (struct window *w, int keep_current_p)
{
struct glyph_row *row, *cur = 0;
int yb = window_text_bottom_y (w);
*/
void
-compute_fringe_widths (f, redraw)
- struct frame *f;
- int redraw;
+compute_fringe_widths (struct frame *f, int redraw)
{
int o_left = FRAME_LEFT_FRINGE_WIDTH (f);
int o_right = FRAME_RIGHT_FRINGE_WIDTH (f);
/* Free resources used by a user-defined bitmap. */
void
-destroy_fringe_bitmap (n)
- int n;
+destroy_fringe_bitmap (int n)
{
struct fringe_bitmap **fbp;
#endif /* HAVE_X_WINDOWS */
void
-init_fringe_bitmap (which, fb, once_p)
- int which;
- struct fringe_bitmap *fb;
- int once_p;
+init_fringe_bitmap (int which, struct fringe_bitmap *fb, int once_p)
{
if (once_p || fb->dynamic)
{
***********************************************************************/
void
-syms_of_fringe ()
+syms_of_fringe (void)
{
Qtruncation = intern_c_string ("truncation");
staticpro (&Qtruncation);
/* Garbage collection hook */
void
-mark_fringe_data ()
+mark_fringe_data (void)
{
int i;
/* Initialize this module when Emacs starts. */
void
-init_fringe_once ()
+init_fringe_once (void)
{
int bt;
}
void
-init_fringe ()
+init_fringe (void)
{
int i;
}
static Lisp_Object
-ftfont_pattern_entity (p, extra)
- FcPattern *p;
- Lisp_Object extra;
+ftfont_pattern_entity (FcPattern *p, Lisp_Object extra)
{
Lisp_Object key, cache, entity;
char *file, *str;
static Lisp_Object ftfont_generic_family_list;
static Lisp_Object
-ftfont_resolve_generic_family (family, pattern)
- Lisp_Object family;
- FcPattern *pattern;
+ftfont_resolve_generic_family (Lisp_Object family, FcPattern *pattern)
{
Lisp_Object slot;
FcPattern *match;
};
static Lisp_Object
-ftfont_lookup_cache (key, cache_for)
- Lisp_Object key;
- enum ftfont_cache_for cache_for;
+ftfont_lookup_cache (Lisp_Object key, enum ftfont_cache_for cache_for)
{
Lisp_Object cache, val, entity;
struct ftfont_cache_data *cache_data;
}
FcCharSet *
-ftfont_get_fc_charset (entity)
- Lisp_Object entity;
+ftfont_get_fc_charset (Lisp_Object entity)
{
Lisp_Object val, cache;
struct ftfont_cache_data *cache_data;
extern Lisp_Object QCname;
static Lisp_Object
-ftfont_get_cache (f)
- FRAME_PTR f;
+ftfont_get_cache (FRAME_PTR f)
{
return freetype_font_cache;
}
static int
-ftfont_get_charset (registry)
- Lisp_Object registry;
+ftfont_get_charset (Lisp_Object registry)
{
char *str = (char *) SDATA (SYMBOL_NAME (registry));
char *re = alloca (SBYTES (SYMBOL_NAME (registry)) * 2 + 1);
char **langname);
static FcPattern *
-ftfont_spec_pattern (spec, otlayout, otspec, langname)
- Lisp_Object spec;
- char *otlayout;
- struct OpenTypeSpec **otspec;
- char **langname;
+ftfont_spec_pattern (Lisp_Object spec, char *otlayout, struct OpenTypeSpec **otspec, char **langname)
{
Lisp_Object tmp, extra;
FcPattern *pattern = NULL;
}
static Lisp_Object
-ftfont_list (frame, spec)
- Lisp_Object frame, spec;
+ftfont_list (Lisp_Object frame, Lisp_Object spec)
{
Lisp_Object val = Qnil, family, adstyle;
int i;
}
static Lisp_Object
-ftfont_match (frame, spec)
- Lisp_Object frame, spec;
+ftfont_match (Lisp_Object frame, Lisp_Object spec)
{
Lisp_Object entity = Qnil;
FcPattern *pattern, *match = NULL;
}
static Lisp_Object
-ftfont_list_family (frame)
- Lisp_Object frame;
+ftfont_list_family (Lisp_Object frame)
{
Lisp_Object list = Qnil;
FcPattern *pattern = NULL;
static Lisp_Object
-ftfont_open (f, entity, pixel_size)
- FRAME_PTR f;
- Lisp_Object entity;
- int pixel_size;
+ftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
{
struct ftfont_info *ftfont_info;
struct font *font;
}
static void
-ftfont_close (f, font)
- FRAME_PTR f;
- struct font *font;
+ftfont_close (FRAME_PTR f, struct font *font)
{
struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
Lisp_Object val, cache;
}
static int
-ftfont_has_char (font, c)
- Lisp_Object font;
- int c;
+ftfont_has_char (Lisp_Object font, int c)
{
struct charset *cs = NULL;
}
static unsigned
-ftfont_encode_char (font, c)
- struct font *font;
- int c;
+ftfont_encode_char (struct font *font, int c)
{
struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
FT_Face ft_face = ftfont_info->ft_size->face;
}
static int
-ftfont_text_extents (font, code, nglyphs, metrics)
- struct font *font;
- unsigned *code;
- int nglyphs;
- struct font_metrics *metrics;
+ftfont_text_extents (struct font *font, unsigned int *code, int nglyphs, struct font_metrics *metrics)
{
struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
FT_Face ft_face = ftfont_info->ft_size->face;
}
static int
-ftfont_get_bitmap (font, code, bitmap, bits_per_pixel)
- struct font *font;
- unsigned code;
- struct font_bitmap *bitmap;
- int bits_per_pixel;
+ftfont_get_bitmap (struct font *font, unsigned int code, struct font_bitmap *bitmap, int bits_per_pixel)
{
struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
FT_Face ft_face = ftfont_info->ft_size->face;
}
static int
-ftfont_anchor_point (font, code, index, x, y)
- struct font *font;
- unsigned code;
- int index;
- int *x, *y;
+ftfont_anchor_point (struct font *font, unsigned int code, int index, int *x, int *y)
{
struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
FT_Face ft_face = ftfont_info->ft_size->face;
};
static void
-ftfont_filter_properties (font, alist)
- Lisp_Object font;
- Lisp_Object alist;
+ftfont_filter_properties (Lisp_Object font, Lisp_Object alist)
{
Lisp_Object it;
int i;
void
-syms_of_ftfont ()
+syms_of_ftfont (void)
{
DEFSYM (Qfreetype, "freetype");
DEFSYM (Qmonospace, "monospace");
/* Return an array of 6 GCs for antialiasing. */
static GC *
-ftxfont_get_gcs (f, foreground, background)
- FRAME_PTR f;
- unsigned long foreground, background;
+ftxfont_get_gcs (FRAME_PTR f, long unsigned int foreground, long unsigned int background)
{
XColor color;
XGCValues xgcv;
}
static int
-ftxfont_draw_bitmap (f, gc_fore, gcs, font, code, x, y, p, size, n, flush)
- FRAME_PTR f;
- GC gc_fore, *gcs;
- struct font *font;
- unsigned code;
- int x, y;
- XPoint *p;
- int size, *n;
- int flush;
+ftxfont_draw_bitmap (FRAME_PTR f, GC gc_fore, GC *gcs, struct font *font, unsigned int code, int x, int y, XPoint *p, int size, int *n, int flush)
{
struct font_bitmap bitmap;
unsigned char *b;
}
static void
-ftxfont_draw_backgrond (f, font, gc, x, y, width)
- FRAME_PTR f;
- struct font *font;
- GC gc;
- int x, y, width;
+ftxfont_draw_backgrond (FRAME_PTR f, struct font *font, GC gc, int x, int y, int width)
{
XGCValues xgcv;
struct font_driver ftxfont_driver;
static Lisp_Object
-ftxfont_list (frame, spec)
- Lisp_Object frame;
- Lisp_Object spec;
+ftxfont_list (Lisp_Object frame, Lisp_Object spec)
{
Lisp_Object list = ftfont_driver.list (frame, spec), tail;
}
static Lisp_Object
-ftxfont_match (frame, spec)
- Lisp_Object frame;
- Lisp_Object spec;
+ftxfont_match (Lisp_Object frame, Lisp_Object spec)
{
Lisp_Object entity = ftfont_driver.match (frame, spec);
}
static Lisp_Object
-ftxfont_open (f, entity, pixel_size)
- FRAME_PTR f;
- Lisp_Object entity;
- int pixel_size;
+ftxfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
{
Lisp_Object font_object;
struct font *font;
}
static void
-ftxfont_close (f, font)
- FRAME_PTR f;
- struct font *font;
+ftxfont_close (FRAME_PTR f, struct font *font)
{
ftfont_driver.close (f, font);
}
static int
-ftxfont_draw (s, from, to, x, y, with_background)
- struct glyph_string *s;
- int from, to, x, y, with_background;
+ftxfont_draw (struct glyph_string *s, int from, int to, int x, int y, int with_background)
{
FRAME_PTR f = s->f;
struct face *face = s->face;
}
static int
-ftxfont_end_for_frame (f)
- FRAME_PTR f;
+ftxfont_end_for_frame (FRAME_PTR f)
{
struct ftxfont_frame_data *data = font_get_frame_data (f, &ftxfont_driver);
\f
void
-syms_of_ftxfont ()
+syms_of_ftxfont (void)
{
DEFSYM (Qftx, "ftx");
W can be a GtkMenu or a GtkWindow widget. */
static void
-xg_set_screen (w, f)
- GtkWidget *w;
- FRAME_PTR f;
+xg_set_screen (GtkWidget *w, FRAME_PTR f)
{
if (FRAME_X_DISPLAY (f) != GDK_DISPLAY ())
{
multipe displays. */
void
-xg_display_open (display_name, dpy)
- char *display_name;
- Display **dpy;
+xg_display_open (char *display_name, Display **dpy)
{
GdkDisplay *gdpy;
Return a pointer to the allocated structure. */
widget_value *
-malloc_widget_value ()
+malloc_widget_value (void)
{
widget_value *wv;
if (widget_value_free_list)
by malloc_widget_value, and no substructures. */
void
-free_widget_value (wv)
- widget_value *wv;
+free_widget_value (widget_value *wv)
{
if (wv->free_list)
abort ();
scroll bars on display DPY. */
GdkCursor *
-xg_create_default_cursor (dpy)
- Display *dpy;
+xg_create_default_cursor (Display *dpy)
{
GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (dpy);
return gdk_cursor_new_for_display (gdpy, GDK_LEFT_PTR);
/* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
static GdkPixbuf *
-xg_get_pixbuf_from_pix_and_mask (gpix, gmask, cmap)
- GdkPixmap *gpix;
- GdkPixmap *gmask;
- GdkColormap *cmap;
+xg_get_pixbuf_from_pix_and_mask (GdkPixmap *gpix, GdkPixmap *gmask, GdkColormap *cmap)
{
int width, height;
GdkPixbuf *icon_buf, *tmp_buf;
}
static Lisp_Object
-file_for_image (image)
- Lisp_Object image;
+file_for_image (Lisp_Object image)
{
Lisp_Object specified_file = Qnil;
Lisp_Object tail;
If OLD_WIDGET is not NULL, that widget is modified. */
static GtkWidget *
-xg_get_image_for_pixmap (f, img, widget, old_widget)
- FRAME_PTR f;
- struct image *img;
- GtkWidget *widget;
- GtkImage *old_widget;
+xg_get_image_for_pixmap (FRAME_PTR f, struct image *img, GtkWidget *widget, GtkImage *old_widget)
{
GdkPixmap *gpix;
GdkPixmap *gmask;
and it is those widgets that are visible. */
static void
-xg_set_cursor (w, cursor)
- GtkWidget *w;
- GdkCursor *cursor;
+xg_set_cursor (GtkWidget *w, GdkCursor *cursor)
{
GdkWindow *window = gtk_widget_get_window(w);
GList *children = gdk_window_peek_children (window);
with g_free. */
static char *
-get_utf8_string (str)
- char *str;
+get_utf8_string (char *str)
{
char *utf8_str = str;
F is the frame we shall set geometry for. */
static void
-xg_set_geometry (f)
- FRAME_PTR f;
+xg_set_geometry (FRAME_PTR f)
{
if (f->size_hint_flags & (USPosition | PPosition))
{
and use a GtkFixed widget, this doesn't happen automatically. */
static void
-xg_clear_under_internal_border (f)
- FRAME_PTR f;
+xg_clear_under_internal_border (FRAME_PTR f)
{
if (FRAME_INTERNAL_BORDER_WIDTH (f) > 0)
{
PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
void
-xg_frame_resized (f, pixelwidth, pixelheight)
- FRAME_PTR f;
- int pixelwidth, pixelheight;
+xg_frame_resized (FRAME_PTR f, int pixelwidth, int pixelheight)
{
int rows, columns;
COLUMNS/ROWS is the size the edit area shall have after the resize. */
void
-xg_frame_set_char_size (f, cols, rows)
- FRAME_PTR f;
- int cols;
- int rows;
+xg_frame_set_char_size (FRAME_PTR f, int cols, int rows)
{
int pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows)
+ FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f);
The policy is to keep the number of editable lines. */
static void
-xg_height_changed (f)
- FRAME_PTR f;
+xg_height_changed (FRAME_PTR f)
{
gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
FRAME_PIXEL_WIDTH (f), FRAME_TOTAL_PIXEL_HEIGHT (f));
Return 0 if no widget match WDESC. */
GtkWidget *
-xg_win_to_widget (dpy, wdesc)
- Display *dpy;
- Window wdesc;
+xg_win_to_widget (Display *dpy, Window wdesc)
{
gpointer gdkwin;
GtkWidget *gwdesc = 0;
W is the widget that color will be used for. Used to find colormap. */
static void
-xg_pix_to_gcolor (w, pixel, c)
- GtkWidget *w;
- unsigned long pixel;
- GdkColor *c;
+xg_pix_to_gcolor (GtkWidget *w, long unsigned int pixel, GdkColor *c)
{
GdkColormap *map = gtk_widget_get_colormap (w);
gdk_colormap_query_color (map, pixel, c);
Return 0 if creation failed, non-zero otherwise. */
int
-xg_create_frame_widgets (f)
- FRAME_PTR f;
+xg_create_frame_widgets (FRAME_PTR f)
{
GtkWidget *wtop;
GtkWidget *wvbox;
flag (this is useful when FLAGS is 0). */
void
-x_wm_set_size_hint (f, flags, user_position)
- FRAME_PTR f;
- long flags;
- int user_position;
+x_wm_set_size_hint (FRAME_PTR f, long int flags, int user_position)
{
/* Must use GTK routines here, otherwise GTK resets the size hints
to its own defaults. */
BG is the pixel value to change to. */
void
-xg_set_background_color (f, bg)
- FRAME_PTR f;
- unsigned long bg;
+xg_set_background_color (FRAME_PTR f, long unsigned int bg)
{
if (FRAME_GTK_WIDGET (f))
{
functions so GTK does not overwrite the icon. */
void
-xg_set_frame_icon (f, icon_pixmap, icon_mask)
- FRAME_PTR f;
- Pixmap icon_pixmap;
- Pixmap icon_mask;
+xg_set_frame_icon (FRAME_PTR f, Pixmap icon_pixmap, Pixmap icon_mask)
{
GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f));
GdkPixmap *gpix = gdk_pixmap_foreign_new_for_display (gdpy, icon_pixmap);
Returns TRUE to end propagation of event. */
static gboolean
-dialog_delete_callback (w, event, user_data)
- GtkWidget *w;
- GdkEvent *event;
- gpointer user_data;
+dialog_delete_callback (GtkWidget *w, GdkEvent *event, gpointer user_data)
{
gtk_widget_unmap (w);
return TRUE;
Returns the GTK dialog widget. */
static GtkWidget *
-create_dialog (wv, select_cb, deactivate_cb)
- widget_value *wv;
- GCallback select_cb;
- GCallback deactivate_cb;
+create_dialog (widget_value *wv, GCallback select_cb, GCallback deactivate_cb)
{
char *title = get_dialog_title (wv->name[0]);
int total_buttons = wv->name[1] - '0';
/* Destroy the dialog. This makes it pop down. */
static Lisp_Object
-pop_down_dialog (arg)
- Lisp_Object arg;
+pop_down_dialog (Lisp_Object arg)
{
struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
struct xg_dialog_data *dd = (struct xg_dialog_data *) p->pointer;
We pass in DATA as gpointer* so we can use this as a callback. */
static gboolean
-xg_maybe_add_timer (data)
- gpointer data;
+xg_maybe_add_timer (gpointer data)
{
struct xg_dialog_data *dd = (struct xg_dialog_data *) data;
EMACS_TIME next_time = timer_check (1);
The dialog W is not destroyed when this function returns. */
static int
-xg_dialog_run (f, w)
- FRAME_PTR f;
- GtkWidget *w;
-
+xg_dialog_run (FRAME_PTR f, GtkWidget *w)
{
int count = SPECPDL_INDEX ();
struct xg_dialog_data dd;
Return zero if not. */
int
-xg_uses_old_file_dialog ()
+xg_uses_old_file_dialog (void)
{
#ifdef HAVE_GTK_FILE_SELECTION_NEW
extern int x_gtk_use_old_file_dialog;
The returned string must be free:d. */
static char *
-xg_get_file_name_from_chooser (w)
- GtkWidget *w;
+xg_get_file_name_from_chooser (GtkWidget *w)
{
return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w));
}
WIDGET is the toggle widget, DATA is the file chooser dialog. */
static void
-xg_toggle_visibility_cb (widget, data)
- GtkWidget *widget;
- gpointer data;
+xg_toggle_visibility_cb (GtkWidget *widget, gpointer data)
{
GtkFileChooser *dialog = GTK_FILE_CHOOSER (data);
gboolean visible;
changes that property by right clicking in the file list. */
static void
-xg_toggle_notify_cb (gobject, arg1, user_data)
- GObject *gobject;
- GParamSpec *arg1;
- gpointer user_data;
+xg_toggle_notify_cb (GObject *gobject, GParamSpec *arg1, gpointer user_data)
{
extern int x_gtk_show_hidden_files;
The returned string must be free:d. */
static char *
-xg_get_file_name_from_selector (w)
- GtkWidget *w;
+xg_get_file_name_from_selector (GtkWidget *w)
{
GtkFileSelection *filesel = GTK_FILE_SELECTION (w);
return xstrdup ((char*) gtk_file_selection_get_filename (filesel));
The returned string must be freed by the caller. */
char *
-xg_get_file_name (f, prompt, default_filename, mustmatch_p, only_dir_p)
- FRAME_PTR f;
- char *prompt;
- char *default_filename;
- int mustmatch_p, only_dir_p;
+xg_get_file_name (FRAME_PTR f, char *prompt, char *default_filename, int mustmatch_p, int only_dir_p)
{
GtkWidget *w = 0;
char *fn = 0;
DEFAULT_NAME, if non-zero, is the default font name. */
char *
-xg_get_font_name (f, default_name)
- FRAME_PTR f;
- char *default_name;
+xg_get_font_name (FRAME_PTR f, char *default_name)
{
GtkWidget *w;
char *fontname = NULL;
allocated xg_menu_cb_data if CL_DATA is NULL. */
static xg_menu_cb_data *
-make_cl_data (cl_data, f, highlight_cb)
- xg_menu_cb_data *cl_data;
- FRAME_PTR f;
- GCallback highlight_cb;
+make_cl_data (xg_menu_cb_data *cl_data, FRAME_PTR f, GCallback highlight_cb)
{
if (! cl_data)
{
creating the menu bar. */
static void
-update_cl_data (cl_data, f, highlight_cb)
- xg_menu_cb_data *cl_data;
- FRAME_PTR f;
- GCallback highlight_cb;
+update_cl_data (xg_menu_cb_data *cl_data, FRAME_PTR f, GCallback highlight_cb)
{
if (cl_data)
{
If reference count is zero, free CL_DATA. */
static void
-unref_cl_data (cl_data)
- xg_menu_cb_data *cl_data;
+unref_cl_data (xg_menu_cb_data *cl_data)
{
if (cl_data && cl_data->ref_count > 0)
{
/* Function that marks all lisp data during GC. */
void
-xg_mark_data ()
+xg_mark_data (void)
{
xg_list_node *iter;
CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
static void
-menuitem_destroy_callback (w, client_data)
- GtkWidget *w;
- gpointer client_data;
+menuitem_destroy_callback (GtkWidget *w, gpointer client_data)
{
if (client_data)
{
Returns FALSE to tell GTK to keep processing this event. */
static gboolean
-menuitem_highlight_callback (w, event, client_data)
- GtkWidget *w;
- GdkEventCrossing *event;
- gpointer client_data;
+menuitem_highlight_callback (GtkWidget *w, GdkEventCrossing *event, gpointer client_data)
{
GdkEvent ev;
GtkWidget *subwidget;
CLIENT_DATA points to the xg_menu_cb_data associated with W. */
static void
-menu_destroy_callback (w, client_data)
- GtkWidget *w;
- gpointer client_data;
+menu_destroy_callback (GtkWidget *w, gpointer client_data)
{
unref_cl_data ((xg_menu_cb_data*) client_data);
}
Returns the GtkHBox. */
static GtkWidget *
-make_widget_for_menu_item (utf8_label, utf8_key)
- char *utf8_label;
- char *utf8_key;
+make_widget_for_menu_item (char *utf8_label, char *utf8_key)
{
GtkWidget *wlbl;
GtkWidget *wkey;
but the MacOS X version doesn't either, so I guess that is OK. */
static GtkWidget *
-make_menu_item (utf8_label, utf8_key, item, group)
- char *utf8_label;
- char *utf8_key;
- widget_value *item;
- GSList **group;
+make_menu_item (char *utf8_label, char *utf8_key, widget_value *item, GSList **group)
{
GtkWidget *w;
GtkWidget *wtoadd = 0;
/* Returns non-zero if there are detached menus. */
int
-xg_have_tear_offs ()
+xg_have_tear_offs (void)
{
return xg_detached_menus > 0;
}
CLIENT_DATA is not used. */
static void
-tearoff_remove (widget, client_data)
- GtkWidget *widget;
- gpointer client_data;
+tearoff_remove (GtkWidget *widget, gpointer client_data)
{
if (xg_detached_menus > 0) --xg_detached_menus;
}
CLIENT_DATA is not used. */
static void
-tearoff_activate (widget, client_data)
- GtkWidget *widget;
- gpointer client_data;
+tearoff_activate (GtkWidget *widget, gpointer client_data)
{
GtkWidget *menu = gtk_widget_get_parent (widget);
if (gtk_menu_get_tearoff_state (GTK_MENU (menu)))
Returns the created GtkWidget. */
static GtkWidget *
-xg_create_one_menuitem (item, f, select_cb, highlight_cb, cl_data, group)
- widget_value *item;
- FRAME_PTR f;
- GCallback select_cb;
- GCallback highlight_cb;
- xg_menu_cb_data *cl_data;
- GSList **group;
+xg_create_one_menuitem (widget_value *item, FRAME_PTR f, GCallback select_cb, GCallback highlight_cb, xg_menu_cb_data *cl_data, GSList **group)
{
char *utf8_label;
char *utf8_key;
/* Return the label for menu item WITEM. */
static const char *
-xg_get_menu_item_label (witem)
- GtkMenuItem *witem;
+xg_get_menu_item_label (GtkMenuItem *witem)
{
GtkLabel *wlabel = GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem)));
return gtk_label_get_label (wlabel);
/* Return non-zero if the menu item WITEM has the text LABEL. */
static int
-xg_item_label_same_p (witem, label)
- GtkMenuItem *witem;
- char *label;
+xg_item_label_same_p (GtkMenuItem *witem, char *label)
{
int is_same = 0;
char *utf8_label = get_utf8_string (label);
/* Destroy widgets in LIST. */
static void
-xg_destroy_widgets (list)
- GList *list;
+xg_destroy_widgets (GList *list)
{
GList *iter;
CL_DATA is the data to set in the widget for menu invocation. */
static void
-xg_update_menu_item (val, w, select_cb, highlight_cb, cl_data)
- widget_value *val;
- GtkWidget *w;
- GCallback select_cb;
- GCallback highlight_cb;
- xg_menu_cb_data *cl_data;
+xg_update_menu_item (widget_value *val, GtkWidget *w, GCallback select_cb, GCallback highlight_cb, xg_menu_cb_data *cl_data)
{
GtkWidget *wchild;
GtkLabel *wlbl = 0;
/* Update the toggle menu item W so it corresponds to VAL. */
static void
-xg_update_toggle_item (val, w)
- widget_value *val;
- GtkWidget *w;
+xg_update_toggle_item (widget_value *val, GtkWidget *w)
{
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), val->selected);
}
/* Update the radio menu item W so it corresponds to VAL. */
static void
-xg_update_radio_item (val, w)
- widget_value *val;
- GtkWidget *w;
+xg_update_radio_item (widget_value *val, GtkWidget *w)
{
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), val->selected);
}
changed. Value is non-zero if widgets were updated. */
int
-xg_update_frame_menubar (f)
- FRAME_PTR f;
+xg_update_frame_menubar (FRAME_PTR f)
{
struct x_output *x = f->output_data.x;
GtkRequisition req;
This is used when deleting a frame, and when turning off the menu bar. */
void
-free_frame_menubar (f)
- FRAME_PTR f;
+free_frame_menubar (FRAME_PTR f)
{
struct x_output *x = f->output_data.x;
/* Store the widget pointer W in id_to_widget and return the integer index. */
static int
-xg_store_widget_in_map (w)
- GtkWidget *w;
+xg_store_widget_in_map (GtkWidget *w)
{
int i;
Called when scroll bar is destroyed. */
static void
-xg_remove_widget_from_map (idx)
- int idx;
+xg_remove_widget_from_map (int idx)
{
if (idx < id_to_widget.max_size && id_to_widget.widgets[idx] != 0)
{
/* Get the widget pointer at IDX from id_to_widget. */
static GtkWidget *
-xg_get_widget_from_map (idx)
- int idx;
+xg_get_widget_from_map (int idx)
{
if (idx < id_to_widget.max_size && id_to_widget.widgets[idx] != 0)
return id_to_widget.widgets[idx];
Return -1 if WID not in id_to_widget. */
int
-xg_get_scroll_id_for_window (dpy, wid)
- Display *dpy;
- Window wid;
+xg_get_scroll_id_for_window (Display *dpy, Window wid)
{
int idx;
GtkWidget *w;
We free pointer to last scroll bar values here and remove the index. */
static void
-xg_gtk_scroll_destroy (widget, data)
- GtkWidget *widget;
- gpointer data;
+xg_gtk_scroll_destroy (GtkWidget *widget, gpointer data)
{
int id = (int) (EMACS_INT) data; /* The EMACS_INT cast avoids a warning. */
xg_remove_widget_from_map (id);
to set resources for the widget. */
void
-xg_create_scroll_bar (f, bar, scroll_callback, end_callback, scroll_bar_name)
- FRAME_PTR f;
- struct scroll_bar *bar;
- GCallback scroll_callback, end_callback;
- char *scroll_bar_name;
+xg_create_scroll_bar (FRAME_PTR f, struct scroll_bar *bar, GCallback scroll_callback, GCallback end_callback, char *scroll_bar_name)
{
GtkWidget *wscroll;
GtkWidget *webox;
/* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
void
-xg_remove_scroll_bar (f, scrollbar_id)
- FRAME_PTR f;
- int scrollbar_id;
+xg_remove_scroll_bar (FRAME_PTR f, int scrollbar_id)
{
GtkWidget *w = xg_get_widget_from_map (scrollbar_id);
if (w)
WIDTH, HEIGHT is the size in pixels the bar shall have. */
void
-xg_update_scrollbar_pos (f, scrollbar_id, top, left, width, height)
- FRAME_PTR f;
- int scrollbar_id;
- int top;
- int left;
- int width;
- int height;
+xg_update_scrollbar_pos (FRAME_PTR f, int scrollbar_id, int top, int left, int width, int height)
{
GtkWidget *wscroll = xg_get_widget_from_map (scrollbar_id);
displaying PORTION out of a whole WHOLE, and our position POSITION. */
void
-xg_set_toolkit_scroll_bar_thumb (bar, portion, position, whole)
- struct scroll_bar *bar;
- int portion, position, whole;
+xg_set_toolkit_scroll_bar_thumb (struct scroll_bar *bar, int portion, int position, int whole)
{
GtkWidget *wscroll = xg_get_widget_from_map (bar->x_window);
Return non-zero if the event is for a scroll bar, zero otherwise. */
int
-xg_event_is_for_scrollbar (f, event)
- FRAME_PTR f;
- XEvent *event;
+xg_event_is_for_scrollbar (FRAME_PTR f, XEvent *event)
{
int retval = 0;
tool bar. 0 is the first button. */
static gboolean
-xg_tool_bar_button_cb (widget, event, user_data)
- GtkWidget *widget;
- GdkEventButton *event;
- gpointer user_data;
+xg_tool_bar_button_cb (GtkWidget *widget, GdkEventButton *event, gpointer user_data)
{
/* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
gpointer ptr = (gpointer) (EMACS_INT) event->state;
tool bar. 0 is the first button. */
static void
-xg_tool_bar_callback (w, client_data)
- GtkWidget *w;
- gpointer client_data;
+xg_tool_bar_callback (GtkWidget *w, gpointer client_data)
{
/* The EMACS_INT cast avoids a warning. */
int idx = (int) (EMACS_INT) client_data;
tool bar. 0 is the first button. */
static void
-xg_tool_bar_proxy_callback (w, client_data)
- GtkWidget *w;
- gpointer client_data;
+xg_tool_bar_proxy_callback (GtkWidget *w, gpointer client_data)
{
GtkWidget *wbutton = GTK_WIDGET (g_object_get_data (G_OBJECT (w),
XG_TOOL_BAR_PROXY_BUTTON));
the detached tool bar when the detached tool bar it is not expanded. */
static gboolean
-xg_tool_bar_proxy_help_callback (w, event, client_data)
- GtkWidget *w;
- GdkEventCrossing *event;
- gpointer client_data;
+xg_tool_bar_proxy_help_callback (GtkWidget *w, GdkEventCrossing *event, gpointer client_data)
{
GtkWidget *wbutton = GTK_WIDGET (g_object_get_data (G_OBJECT (w),
XG_TOOL_BAR_PROXY_BUTTON));
blank. */
static gboolean
-xg_tool_bar_menu_proxy (toolitem, user_data)
- GtkToolItem *toolitem;
- gpointer user_data;
+xg_tool_bar_menu_proxy (GtkToolItem *toolitem, gpointer user_data)
{
GtkWidget *weventbox = gtk_bin_get_child (GTK_BIN (toolitem));
GtkButton *wbutton = GTK_BUTTON (gtk_bin_get_child (GTK_BIN (weventbox)));
CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
static void
-xg_tool_bar_detach_callback (wbox, w, client_data)
- GtkHandleBox *wbox;
- GtkWidget *w;
- gpointer client_data;
+xg_tool_bar_detach_callback (GtkHandleBox *wbox, GtkWidget *w, gpointer client_data)
{
FRAME_PTR f = (FRAME_PTR) client_data;
extern int x_gtk_whole_detached_tool_bar;
CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
static void
-xg_tool_bar_attach_callback (wbox, w, client_data)
- GtkHandleBox *wbox;
- GtkWidget *w;
- gpointer client_data;
+xg_tool_bar_attach_callback (GtkHandleBox *wbox, GtkWidget *w, gpointer client_data)
{
FRAME_PTR f = (FRAME_PTR) client_data;
g_object_set (G_OBJECT (w), "show-arrow", TRUE, NULL);
Returns FALSE to tell GTK to keep processing this event. */
static gboolean
-xg_tool_bar_help_callback (w, event, client_data)
- GtkWidget *w;
- GdkEventCrossing *event;
- gpointer client_data;
+xg_tool_bar_help_callback (GtkWidget *w, GdkEventCrossing *event, gpointer client_data)
{
/* The EMACS_INT cast avoids a warning. */
int idx = (int) (EMACS_INT) client_data;
Returns FALSE to tell GTK to keep processing this event. */
static gboolean
-xg_tool_bar_item_expose_callback (w, event, client_data)
- GtkWidget *w;
- GdkEventExpose *event;
- gpointer client_data;
+xg_tool_bar_item_expose_callback (GtkWidget *w, GdkEventExpose *event, gpointer client_data)
{
gint width, height;
/* Attach a tool bar to frame F. */
static void
-xg_pack_tool_bar (f)
- FRAME_PTR f;
+xg_pack_tool_bar (FRAME_PTR f)
{
struct x_output *x = f->output_data.x;
int vbox_pos = x->menubar_widget ? 1 : 0;
#endif
static void
-xg_create_tool_bar (f)
- FRAME_PTR f;
+xg_create_tool_bar (FRAME_PTR f)
{
struct x_output *x = f->output_data.x;
Returns IMAGE if RTL is not found. */
static Lisp_Object
-find_rtl_image (f, image, rtl)
- FRAME_PTR f;
- Lisp_Object image;
- Lisp_Object rtl;
+find_rtl_image (FRAME_PTR f, Lisp_Object image, Lisp_Object rtl)
{
int i;
Lisp_Object file, rtl_name;
extern Lisp_Object Qx_gtk_map_stock;
void
-update_frame_tool_bar (f)
- FRAME_PTR f;
+update_frame_tool_bar (FRAME_PTR f)
{
int i;
GtkRequisition old_req, new_req;
Remove the tool bar. */
void
-free_frame_tool_bar (f)
- FRAME_PTR f;
+free_frame_tool_bar (FRAME_PTR f)
{
struct x_output *x = f->output_data.x;
Initializing
***********************************************************************/
void
-xg_initialize ()
+xg_initialize (void)
{
GtkBindingSet *binding_set;
/* Get the display table to use for the current buffer. */
struct Lisp_Char_Table *
-buffer_display_table ()
+buffer_display_table (void)
{
Lisp_Object thisbuf;
/* Return the width of character C under display table DP. */
static int
-character_width (c, dp)
- int c;
- struct Lisp_Char_Table *dp;
+character_width (int c, struct Lisp_Char_Table *dp)
{
Lisp_Object elt;
invalidate the buffer's width_run_cache. */
int
-disptab_matches_widthtab (disptab, widthtab)
- struct Lisp_Char_Table *disptab;
- struct Lisp_Vector *widthtab;
+disptab_matches_widthtab (struct Lisp_Char_Table *disptab, struct Lisp_Vector *widthtab)
{
int i;
/* Recompute BUF's width table, using the display table DISPTAB. */
void
-recompute_width_table (buf, disptab)
- struct buffer *buf;
- struct Lisp_Char_Table *disptab;
+recompute_width_table (struct buffer *buf, struct Lisp_Char_Table *disptab)
{
int i;
struct Lisp_Vector *widthtab;
state of current_buffer's cache_long_line_scans variable. */
static void
-width_run_cache_on_off ()
+width_run_cache_on_off (void)
{
if (NILP (current_buffer->cache_long_line_scans)
/* And, for the moment, this feature doesn't work on multibyte
will equal the return value. */
EMACS_INT
-skip_invisible (pos, next_boundary_p, to, window)
- EMACS_INT pos;
- EMACS_INT *next_boundary_p;
- EMACS_INT to;
- Lisp_Object window;
+skip_invisible (EMACS_INT pos, EMACS_INT *next_boundary_p, EMACS_INT to, Lisp_Object window)
{
Lisp_Object prop, position, overlay_limit, proplimit;
Lisp_Object buffer, tmp;
/* Cancel any recorded value of the horizontal position. */
void
-invalidate_current_column ()
+invalidate_current_column (void)
{
last_known_column_point = 0;
}
double
-current_column ()
+current_column (void)
{
register int col;
register unsigned char *ptr, *stop;
due to text properties or overlays. */
static double
-current_column_1 ()
+current_column_1 (void)
{
EMACS_INT col = MOST_POSITIVE_FIXNUM;
EMACS_INT opoint = PT;
}
static double
-position_indentation (pos_byte)
- register int pos_byte;
+position_indentation (register int pos_byte)
{
register EMACS_INT column = 0;
register EMACS_INT tab_width = XINT (current_buffer->tab_width);
preceding line. */
int
-indented_beyond_p (pos, pos_byte, column)
- int pos, pos_byte;
- double column;
+indented_beyond_p (int pos, int pos_byte, double column)
{
double val;
int opoint = PT, opoint_byte = PT_BYTE;
the scroll bars if they are turned on. */
struct position *
-compute_motion (from, fromvpos, fromhpos, did_motion, to, tovpos, tohpos, width, hscroll, tab_offset, win)
- EMACS_INT from, fromvpos, fromhpos, to, tovpos, tohpos;
- int did_motion;
- EMACS_INT width;
- EMACS_INT hscroll, tab_offset;
- struct window *win;
+compute_motion (EMACS_INT from, EMACS_INT fromvpos, EMACS_INT fromhpos, int did_motion, EMACS_INT to, EMACS_INT tovpos, EMACS_INT tohpos, EMACS_INT width, EMACS_INT hscroll, EMACS_INT tab_offset, struct window *win)
{
register EMACS_INT hpos = fromhpos;
register EMACS_INT vpos = fromvpos;
struct position val_vmotion;
struct position *
-vmotion (from, vtarget, w)
- register EMACS_INT from, vtarget;
- struct window *w;
+vmotion (register EMACS_INT from, register EMACS_INT vtarget, struct window *w)
{
EMACS_INT hscroll = XINT (w->hscroll);
struct position pos;
/* File's initialization. */
void
-syms_of_indent ()
+syms_of_indent (void)
{
DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode,
doc: /* *Indentation can insert tabs if this is non-nil. */);
EMACS_INT, EMACS_INT, EMACS_INT);
static void adjust_point (EMACS_INT nchars, EMACS_INT nbytes);
-Lisp_Object Fcombine_after_change_execute ();
+Lisp_Object Fcombine_after_change_execute (void);
/* Non-nil means don't call the after-change-functions right away,
just record an element in combine_after_change_list. */
else
void
-check_markers ()
+check_markers (void)
{
register struct Lisp_Marker *tail;
int multibyte = ! NILP (current_buffer->enable_multibyte_characters);
NO-ERROR-FLAG is nil if there was an error,
anything else meaning no error (so this function does nothing). */
Lisp_Object
-reset_var_on_error (val)
- Lisp_Object val;
+reset_var_on_error (Lisp_Object val)
{
if (NILP (XCDR (val)))
Fset (XCAR (val), Qnil);
}
Lisp_Object
-Fcombine_after_change_execute_1 (val)
- Lisp_Object val;
+Fcombine_after_change_execute_1 (Lisp_Object val)
{
Vcombine_after_change_calls = val;
return val;
}
\f
void
-syms_of_insdel ()
+syms_of_insdel (void)
{
staticpro (&combine_after_change_list);
staticpro (&combine_after_change_buffer);
#define TMEM(sym, set) (CONSP (set) ? ! NILP (Fmemq (sym, set)) : ! NILP (set))
-Lisp_Object merge_properties_sticky ();
+Lisp_Object merge_properties_sticky (Lisp_Object pleft, Lisp_Object pright);
static INTERVAL reproduce_tree (INTERVAL, INTERVAL);
static INTERVAL reproduce_tree_obj (INTERVAL, Lisp_Object);
\f
/* Create the root interval of some object, a buffer or string. */
INTERVAL
-create_root_interval (parent)
- Lisp_Object parent;
+create_root_interval (Lisp_Object parent)
{
INTERVAL new;
/* Make the interval TARGET have exactly the properties of SOURCE */
void
-copy_properties (source, target)
- register INTERVAL source, target;
+copy_properties (register INTERVAL source, register INTERVAL target)
{
if (DEFAULT_INTERVAL_P (source) && DEFAULT_INTERVAL_P (target))
return;
is added to TARGET if TARGET has no such property as yet. */
static void
-merge_properties (source, target)
- register INTERVAL source, target;
+merge_properties (register INTERVAL source, register INTERVAL target)
{
register Lisp_Object o, sym, val;
0 otherwise. */
int
-intervals_equal (i0, i1)
- INTERVAL i0, i1;
+intervals_equal (INTERVAL i0, INTERVAL i1)
{
register Lisp_Object i0_cdr, i0_sym;
register Lisp_Object i1_cdr, i1_val;
Pass FUNCTION two args: an interval, and ARG. */
void
-traverse_intervals_noorder (tree, function, arg)
- INTERVAL tree;
- void (* function) (INTERVAL, Lisp_Object);
- Lisp_Object arg;
+traverse_intervals_noorder (INTERVAL tree, void (*function) (INTERVAL, Lisp_Object), Lisp_Object arg)
{
/* Minimize stack usage. */
while (!NULL_INTERVAL_P (tree))
Pass FUNCTION two args: an interval, and ARG. */
void
-traverse_intervals (tree, position, function, arg)
- INTERVAL tree;
- int position;
- void (* function) (INTERVAL, Lisp_Object);
- Lisp_Object arg;
+traverse_intervals (INTERVAL tree, int position, void (*function) (INTERVAL, Lisp_Object), Lisp_Object arg)
{
while (!NULL_INTERVAL_P (tree))
{
*/
static INLINE INTERVAL
-rotate_right (interval)
- INTERVAL interval;
+rotate_right (INTERVAL interval)
{
INTERVAL i;
INTERVAL B = interval->left;
*/
static INLINE INTERVAL
-rotate_left (interval)
- INTERVAL interval;
+rotate_left (INTERVAL interval)
{
INTERVAL i;
INTERVAL B = interval->right;
themselves are already balanced. */
static INTERVAL
-balance_an_interval (i)
- INTERVAL i;
+balance_an_interval (INTERVAL i)
{
register int old_diff, new_diff;
Lisp Object. */
static INLINE INTERVAL
-balance_possible_root_interval (interval)
- register INTERVAL interval;
+balance_possible_root_interval (register INTERVAL interval)
{
Lisp_Object parent;
int have_parent = 0;
(the amount of text). */
static INTERVAL
-balance_intervals_internal (tree)
- register INTERVAL tree;
+balance_intervals_internal (register INTERVAL tree)
{
/* Balance within each side. */
if (tree->left)
/* Advertised interface to balance intervals. */
INTERVAL
-balance_intervals (tree)
- INTERVAL tree;
+balance_intervals (INTERVAL tree)
{
if (tree == NULL_INTERVAL)
return NULL_INTERVAL;
it is still a root after this operation. */
INTERVAL
-split_interval_right (interval, offset)
- INTERVAL interval;
- int offset;
+split_interval_right (INTERVAL interval, int offset)
{
INTERVAL new = make_interval ();
int position = interval->position;
it is still a root after this operation. */
INTERVAL
-split_interval_left (interval, offset)
- INTERVAL interval;
- int offset;
+split_interval_left (INTERVAL interval, int offset)
{
INTERVAL new = make_interval ();
int new_length = offset;
of another interval! */
int
-interval_start_pos (source)
- INTERVAL source;
+interval_start_pos (INTERVAL source)
{
Lisp_Object parent;
will update this cache based on the result of find_interval. */
INTERVAL
-find_interval (tree, position)
- register INTERVAL tree;
- register int position;
+find_interval (register INTERVAL tree, register int position)
{
/* The distance from the left edge of the subtree at TREE
to POSITION. */
find_interval). */
INTERVAL
-next_interval (interval)
- register INTERVAL interval;
+next_interval (register INTERVAL interval)
{
register INTERVAL i = interval;
register int next_position;
find_interval). */
INTERVAL
-previous_interval (interval)
- register INTERVAL interval;
+previous_interval (register INTERVAL interval)
{
register INTERVAL i;
To speed up the process, we assume that the ->position of
I and all its parents is already uptodate. */
INTERVAL
-update_interval (i, pos)
- register INTERVAL i;
- int pos;
+update_interval (register INTERVAL i, int pos)
{
if (NULL_INTERVAL_P (i))
return NULL_INTERVAL;
this text, and make it have the merged properties of both ends. */
static INTERVAL
-adjust_intervals_for_insertion (tree, position, length)
- INTERVAL tree;
- int position, length;
+adjust_intervals_for_insertion (INTERVAL tree, int position, int length)
{
register INTERVAL i;
register INTERVAL temp;
*/
Lisp_Object
-merge_properties_sticky (pleft, pright)
- Lisp_Object pleft, pright;
+merge_properties_sticky (Lisp_Object pleft, Lisp_Object pright)
{
register Lisp_Object props, front, rear;
Lisp_Object lfront, lrear, rfront, rrear;
storing the resulting subtree into its parent. */
static INTERVAL
-delete_node (i)
- register INTERVAL i;
+delete_node (register INTERVAL i)
{
register INTERVAL migrate, this;
register int migrate_amt;
for the length of I. */
void
-delete_interval (i)
- register INTERVAL i;
+delete_interval (register INTERVAL i)
{
register INTERVAL parent;
int amt = LENGTH (i);
deleting the appropriate amount of text. */
static int
-interval_deletion_adjustment (tree, from, amount)
- register INTERVAL tree;
- register int from, amount;
+interval_deletion_adjustment (register INTERVAL tree, register int from, register int amount)
{
register int relative_position = from;
buffer position, i.e. origin 1). */
static void
-adjust_intervals_for_deletion (buffer, start, length)
- struct buffer *buffer;
- int start, length;
+adjust_intervals_for_deletion (struct buffer *buffer, int start, int length)
{
register int left_to_delete = length;
register INTERVAL tree = BUF_INTERVALS (buffer);
of LENGTH. */
INLINE void
-offset_intervals (buffer, start, length)
- struct buffer *buffer;
- int start, length;
+offset_intervals (struct buffer *buffer, int start, int length)
{
if (NULL_INTERVAL_P (BUF_INTERVALS (buffer)) || length == 0)
return;
interval. */
INTERVAL
-merge_interval_right (i)
- register INTERVAL i;
+merge_interval_right (register INTERVAL i)
{
register int absorb = LENGTH (i);
register INTERVAL successor;
The caller must verify that this is not the first (leftmost) interval. */
INTERVAL
-merge_interval_left (i)
- register INTERVAL i;
+merge_interval_left (register INTERVAL i)
{
register int absorb = LENGTH (i);
register INTERVAL predecessor;
the pointers of the copy. */
static INTERVAL
-reproduce_tree (source, parent)
- INTERVAL source, parent;
+reproduce_tree (INTERVAL source, INTERVAL parent)
{
register INTERVAL t = make_interval ();
}
static INTERVAL
-reproduce_tree_obj (source, parent)
- INTERVAL source;
- Lisp_Object parent;
+reproduce_tree_obj (INTERVAL source, Lisp_Object parent)
{
register INTERVAL t = make_interval ();
text... */
void
-graft_intervals_into_buffer (source, position, length, buffer, inherit)
- INTERVAL source;
- int position, length;
- struct buffer *buffer;
- int inherit;
+graft_intervals_into_buffer (INTERVAL source, int position, int length, struct buffer *buffer, int inherit)
{
register INTERVAL under, over, this, prev;
register INTERVAL tree;
and for PROP appearing on the default-text-properties list. */
Lisp_Object
-textget (plist, prop)
- Lisp_Object plist;
- register Lisp_Object prop;
+textget (Lisp_Object plist, register Lisp_Object prop)
{
return lookup_char_property (plist, prop, 1);
}
Lisp_Object
-lookup_char_property (plist, prop, textprop)
- Lisp_Object plist;
- register Lisp_Object prop;
- int textprop;
+lookup_char_property (Lisp_Object plist, register Lisp_Object prop, int textprop)
{
register Lisp_Object tail, fallback = Qnil;
if the invisible property comes from an overlay. */
static int
-adjust_for_invis_intang (pos, test_offs, adj, test_intang)
- int pos, test_offs, adj, test_intang;
+adjust_for_invis_intang (int pos, int test_offs, int adj, int test_intang)
{
Lisp_Object invis_propval, invis_overlay;
Lisp_Object test_pos;
segment that reaches all the way to point. */
void
-move_if_not_intangible (position)
- int position;
+move_if_not_intangible (int position)
{
Lisp_Object pos;
Lisp_Object intangible_propval;
nil means the current buffer. */
int
-get_property_and_range (pos, prop, val, start, end, object)
- int pos;
- Lisp_Object prop, *val;
- EMACS_INT *start, *end;
- Lisp_Object object;
+get_property_and_range (int pos, Lisp_Object prop, Lisp_Object *val, EMACS_INT *start, EMACS_INT *end, Lisp_Object object)
{
INTERVAL i, prev, next;
POSITION must be in the accessible part of BUFFER. */
Lisp_Object
-get_local_map (position, buffer, type)
- register int position;
- register struct buffer *buffer;
- Lisp_Object type;
+get_local_map (register int position, register struct buffer *buffer, Lisp_Object type)
{
Lisp_Object prop, lispy_position, lispy_buffer;
int old_begv, old_zv, old_begv_byte, old_zv_byte;
The new interval tree has no parent and has a starting-position of 0. */
INTERVAL
-copy_intervals (tree, start, length)
- INTERVAL tree;
- int start, length;
+copy_intervals (INTERVAL tree, int start, int length)
{
register INTERVAL i, new, t;
register int got, prevlen;
/* Give STRING the properties of BUFFER from POSITION to LENGTH. */
INLINE void
-copy_intervals_to_string (string, buffer, position, length)
- Lisp_Object string;
- struct buffer *buffer;
- int position, length;
+copy_intervals_to_string (Lisp_Object string, struct buffer *buffer, int position, int length)
{
INTERVAL interval_copy = copy_intervals (BUF_INTERVALS (buffer),
position, length);
Assume they have identical characters. */
int
-compare_string_intervals (s1, s2)
- Lisp_Object s1, s2;
+compare_string_intervals (Lisp_Object s1, Lisp_Object s2)
{
INTERVAL i1, i2;
int pos = 0;
START_BYTE ... END_BYTE in bytes. */
static void
-set_intervals_multibyte_1 (i, multi_flag, start, start_byte, end, end_byte)
- INTERVAL i;
- int multi_flag;
- int start, start_byte, end, end_byte;
+set_intervals_multibyte_1 (INTERVAL i, int multi_flag, int start, int start_byte, int end, int end_byte)
{
/* Fix the length of this interval. */
if (multi_flag)
or to fit them as non-multibyte (if MULTI_FLAG is 0). */
void
-set_intervals_multibyte (multi_flag)
- int multi_flag;
+set_intervals_multibyte (int multi_flag)
{
if (BUF_INTERVALS (current_buffer))
set_intervals_multibyte_1 (BUF_INTERVALS (current_buffer), multi_flag,
initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
void
-initial_define_key (keymap, key, defname)
- Lisp_Object keymap;
- int key;
- char *defname;
+initial_define_key (Lisp_Object keymap, int key, char *defname)
{
store_in_keymap (keymap, make_number (key), intern_c_string (defname));
}
void
-initial_define_lispy_key (keymap, keyname, defname)
- Lisp_Object keymap;
- char *keyname;
- char *defname;
+initial_define_lispy_key (Lisp_Object keymap, char *keyname, char *defname)
{
store_in_keymap (keymap, intern_c_string (keyname), intern_c_string (defname));
}
do_autoload which can GC. */
Lisp_Object
-get_keymap (object, error, autoload)
- Lisp_Object object;
- int error, autoload;
+get_keymap (Lisp_Object object, int error, int autoload)
{
Lisp_Object tem;
We assume that KEYMAP is a valid keymap. */
Lisp_Object
-keymap_parent (keymap, autoload)
- Lisp_Object keymap;
- int autoload;
+keymap_parent (Lisp_Object keymap, int autoload)
{
Lisp_Object list;
/* Check whether MAP is one of MAPS parents. */
int
-keymap_memberp (map, maps)
- Lisp_Object map, maps;
+keymap_memberp (Lisp_Object map, Lisp_Object maps)
{
if (NILP (map)) return 0;
while (KEYMAPP (maps) && !EQ (map, maps))
make sure that SUBMAP inherits that definition as its own parent. */
static void
-fix_submap_inheritance (map, event, submap)
- Lisp_Object map, event, submap;
+fix_submap_inheritance (Lisp_Object map, Lisp_Object event, Lisp_Object submap)
{
Lisp_Object map_parent, parent_entry;
If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
Lisp_Object
-access_keymap (map, idx, t_ok, noinherit, autoload)
- Lisp_Object map;
- Lisp_Object idx;
- int t_ok;
- int noinherit;
- int autoload;
+access_keymap (Lisp_Object map, Lisp_Object idx, int t_ok, int noinherit, int autoload)
{
Lisp_Object val;
}
static void
-map_keymap_item (fun, args, key, val, data)
- map_keymap_function_t fun;
- Lisp_Object args, key, val;
- void *data;
+map_keymap_item (map_keymap_function_t fun, Lisp_Object args, Lisp_Object key, Lisp_Object val, void *data)
{
/* We should maybe try to detect bindings shadowed by previous
ones and things like that. */
}
static void
-map_keymap_char_table_item (args, key, val)
- Lisp_Object args, key, val;
+map_keymap_char_table_item (Lisp_Object args, Lisp_Object key, Lisp_Object val)
{
if (!NILP (val))
{
}
static void
-map_keymap_call (key, val, fun, dummy)
- Lisp_Object key, val, fun;
- void *dummy;
+map_keymap_call (Lisp_Object key, Lisp_Object val, Lisp_Object fun, void *dummy)
{
call2 (fun, key, val);
}
/* Same as map_keymap_internal, but doesn't traverses parent keymaps as well.
A non-zero AUTOLOAD indicates that autoloaded keymaps should be loaded. */
void
-map_keymap (map, fun, args, data, autoload)
- map_keymap_function_t fun;
- Lisp_Object map, args;
- void *data;
- int autoload;
+map_keymap (Lisp_Object map, map_keymap_function_t fun, Lisp_Object args, void *data, int autoload)
{
struct gcpro gcpro1;
GCPRO1 (args);
/* Same as map_keymap, but does it right, properly eliminating duplicate
bindings due to inheritance. */
void
-map_keymap_canonical (map, fun, args, data)
- map_keymap_function_t fun;
- Lisp_Object map, args;
- void *data;
+map_keymap_canonical (Lisp_Object map, map_keymap_function_t fun, Lisp_Object args, void *data)
{
struct gcpro gcpro1;
GCPRO1 (args);
This can GC because menu_item_eval_property calls Feval. */
Lisp_Object
-get_keyelt (object, autoload)
- Lisp_Object object;
- int autoload;
+get_keyelt (Lisp_Object object, int autoload)
{
while (1)
{
}
static Lisp_Object
-store_in_keymap (keymap, idx, def)
- Lisp_Object keymap;
- register Lisp_Object idx;
- Lisp_Object def;
+store_in_keymap (Lisp_Object keymap, register Lisp_Object idx, Lisp_Object def)
{
/* Flush any reverse-map cache. */
where_is_cache = Qnil;
EXFUN (Fcopy_keymap, 1);
Lisp_Object
-copy_keymap_item (elt)
- Lisp_Object elt;
+copy_keymap_item (Lisp_Object elt)
{
Lisp_Object res, tem;
}
static void
-copy_keymap_1 (chartable, idx, elt)
- Lisp_Object chartable, idx, elt;
+copy_keymap_1 (Lisp_Object chartable, Lisp_Object idx, Lisp_Object elt)
{
Fset_char_table_range (chartable, idx, copy_keymap_item (elt));
}
Return the keymap. */
static Lisp_Object
-define_as_prefix (keymap, c)
- Lisp_Object keymap, c;
+define_as_prefix (Lisp_Object keymap, Lisp_Object c)
{
Lisp_Object cmd;
/* Append a key to the end of a key sequence. We always make a vector. */
Lisp_Object
-append_key (key_sequence, key)
- Lisp_Object key_sequence, key;
+append_key (Lisp_Object key_sequence, Lisp_Object key)
{
Lisp_Object args[2];
signal an error if is a mistake such as RET or M-RET or C-DEL, etc. */
static void
-silly_event_symbol_error (c)
- Lisp_Object c;
+silly_event_symbol_error (Lisp_Object c)
{
Lisp_Object parsed, base, name, assoc;
int modifiers;
list, let the key sequence be read, and hope some other piece of
code signals the error. */
int
-current_minor_maps (modeptr, mapptr)
- Lisp_Object **modeptr, **mapptr;
+current_minor_maps (Lisp_Object **modeptr, Lisp_Object **mapptr)
{
int i = 0;
int list_number = 0;
};
static void
-accessible_keymaps_1 (key, cmd, args, data)
- Lisp_Object key, cmd, args;
+accessible_keymaps_1 (Lisp_Object key, Lisp_Object cmd, Lisp_Object args, void *data)
+
/* Use void* to be compatible with map_keymap_function_t. */
- void *data;
+
{
struct accessible_keymaps_data *d = data; /* Cast! */
Lisp_Object maps = d->maps;
char *
-push_key_description (c, p, force_multibyte)
- register unsigned int c;
- register char *p;
- int force_multibyte;
+push_key_description (register unsigned int c, register char *p, int force_multibyte)
{
unsigned c2;
}
char *
-push_text_char_description (c, p)
- register unsigned int c;
- register char *p;
+push_text_char_description (register unsigned int c, register char *p)
{
if (c >= 0200)
{
Else, return 2 if SEQ uses the where_is_preferred_modifier,
and 1 otherwise. */
static int
-preferred_sequence_p (seq)
- Lisp_Object seq;
+preferred_sequence_p (Lisp_Object seq)
{
int i;
int len = XINT (Flength (seq));
/* This function can GC because get_keyelt can. */
static void
-where_is_internal_1 (key, binding, args, data)
- Lisp_Object key, binding, args;
- void *data;
+where_is_internal_1 (Lisp_Object key, Lisp_Object binding, Lisp_Object args, void *data)
{
struct where_is_internal_data *d = data; /* Cast! */
Lisp_Object definition = d->definition;
static int previous_description_column;
static void
-describe_command (definition, args)
- Lisp_Object definition, args;
+describe_command (Lisp_Object definition, Lisp_Object args)
{
register Lisp_Object tem1;
int column = (int) current_column (); /* iftc */
}
static void
-describe_translation (definition, args)
- Lisp_Object definition, args;
+describe_translation (Lisp_Object definition, Lisp_Object args)
{
register Lisp_Object tem1;
the event field. */
static int
-describe_map_compare (aa, bb)
- const void *aa, *bb;
+describe_map_compare (const void *aa, const void *bb)
{
const struct describe_map_elt *a = aa, *b = bb;
if (INTEGERP (a->event) && INTEGERP (b->event))
}
static void
-describe_vector_princ (elt, fun)
- Lisp_Object elt, fun;
+describe_vector_princ (Lisp_Object elt, Lisp_Object fun)
{
Findent_to (make_number (16), make_number (1));
call1 (fun, elt);
static Lisp_Object apropos_accumulate;
static void
-apropos_accum (symbol, string)
- Lisp_Object symbol, string;
+apropos_accum (Lisp_Object symbol, Lisp_Object string)
{
register Lisp_Object tem;
}
\f
void
-syms_of_keymap ()
+syms_of_keymap (void)
{
Qkeymap = intern_c_string ("keymap");
staticpro (&Qkeymap);
}
void
-keys_of_keymap ()
+keys_of_keymap (void)
{
initial_define_key (global_map, 033, "ESC-prefix");
initial_define_key (global_map, Ctl ('X'), "Control-X-prefix");
static Lisp_Object load_descriptor_unwind (Lisp_Object);
static void invalid_syntax (const char *, int) NO_RETURN;
-static void end_of_file_error () NO_RETURN;
+static void end_of_file_error (void) NO_RETURN;
\f
/* Functions that read one byte from the current source READCHARFUN
static int unread_char;
static int
-readchar (readcharfun, multibyte)
- Lisp_Object readcharfun;
- int *multibyte;
+readchar (Lisp_Object readcharfun, int *multibyte)
{
Lisp_Object tem;
register int c;
If the stream is a user function, call it with the char as argument. */
static void
-unreadchar (readcharfun, c)
- Lisp_Object readcharfun;
- int c;
+unreadchar (Lisp_Object readcharfun, int c)
{
readchar_count--;
if (c == -1)
}
static int
-readbyte_for_lambda (c, readcharfun)
- int c;
- Lisp_Object readcharfun;
+readbyte_for_lambda (int c, Lisp_Object readcharfun)
{
return read_bytecode_char (c >= 0);
}
static int
-readbyte_from_file (c, readcharfun)
- int c;
- Lisp_Object readcharfun;
+readbyte_from_file (int c, Lisp_Object readcharfun)
{
if (c >= 0)
{
}
static int
-readbyte_from_string (c, readcharfun)
- int c;
- Lisp_Object readcharfun;
+readbyte_from_string (int c, Lisp_Object readcharfun)
{
Lisp_Object string = XCAR (readcharfun);
extern char emacs_mule_bytes[256];
static int
-read_emacs_mule_char (c, readbyte, readcharfun)
- int c;
- int (*readbyte) (int, Lisp_Object);
- Lisp_Object readcharfun;
+read_emacs_mule_char (int c, int (*readbyte) (int, Lisp_Object), Lisp_Object readcharfun)
{
/* Emacs-mule coding uses at most 4-byte for one character. */
unsigned char buf[4];
because of an incompatible change in the byte compiler. */
static int
-safe_to_load_p (fd)
- int fd;
+safe_to_load_p (int fd)
{
char buf[512];
int nbytes, i;
after loading a file successfully. */
static Lisp_Object
-record_load_unwind (old)
- Lisp_Object old;
+record_load_unwind (Lisp_Object old)
{
return Vloads_in_progress = old;
}
/* This handler function is used via internal_condition_case_1. */
static Lisp_Object
-load_error_handler (data)
- Lisp_Object data;
+load_error_handler (Lisp_Object data)
{
return Qnil;
}
static Lisp_Object
-load_warn_old_style_backquotes (file)
- Lisp_Object file;
+load_warn_old_style_backquotes (Lisp_Object file)
{
if (!NILP (Vold_style_backquotes))
{
}
static Lisp_Object
-load_unwind (arg) /* used as unwind-protect function in load */
- Lisp_Object arg;
+load_unwind (Lisp_Object arg) /* used as unwind-protect function in load */
+
{
FILE *stream = (FILE *) XSAVE_VALUE (arg)->pointer;
if (stream != NULL)
}
static Lisp_Object
-load_descriptor_unwind (oldlist)
- Lisp_Object oldlist;
+load_descriptor_unwind (Lisp_Object oldlist)
{
load_descriptor_list = oldlist;
return Qnil;
This is used when starting a subprocess. */
void
-close_load_descs ()
+close_load_descs (void)
{
#ifndef WINDOWSNT
Lisp_Object tail;
}
\f
static int
-complete_filename_p (pathname)
- Lisp_Object pathname;
+complete_filename_p (Lisp_Object pathname)
{
register const unsigned char *s = SDATA (pathname);
return (IS_DIRECTORY_SEP (s[0])
but store the found remote file name in *STOREPTR. */
int
-openp (path, str, suffixes, storeptr, predicate)
- Lisp_Object path, str;
- Lisp_Object suffixes;
- Lisp_Object *storeptr;
- Lisp_Object predicate;
+openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes, Lisp_Object *storeptr, Lisp_Object predicate)
{
register int fd;
int fn_size = 100;
ENTIRE is 1 if loading that entire file, 0 if evaluating part of it. */
static void
-build_load_history (filename, entire)
- Lisp_Object filename;
- int entire;
+build_load_history (Lisp_Object filename, int entire)
{
register Lisp_Object tail, prev, newelt;
register Lisp_Object tem, tem2;
}
Lisp_Object
-unreadpure (junk) /* Used as unwind-protect function in readevalloop */
- Lisp_Object junk;
+unreadpure (Lisp_Object junk) /* Used as unwind-protect function in readevalloop */
+
{
read_pure = 0;
return Qnil;
}
static Lisp_Object
-readevalloop_1 (old)
- Lisp_Object old;
+readevalloop_1 (Lisp_Object old)
{
load_convert_to_unibyte = ! NILP (old);
return Qnil;
information. */
static void
-end_of_file_error ()
+end_of_file_error (void)
{
if (STRINGP (Vload_file_name))
xsignal1 (Qend_of_file, Vload_file_name);
/* Function to set up the global context we need in toplevel read
calls. */
static Lisp_Object
-read_internal_start (stream, start, end)
- Lisp_Object stream;
- Lisp_Object start; /* Only used when stream is a string. */
- Lisp_Object end; /* Only used when stream is a string. */
+read_internal_start (Lisp_Object stream, Lisp_Object start, Lisp_Object end)
+
+ /* Only used when stream is a string. */
+ /* Only used when stream is a string. */
{
Lisp_Object retval;
S is error string of length N (if > 0) */
static void
-invalid_syntax (s, n)
- const char *s;
- int n;
+invalid_syntax (const char *s, int n)
{
if (!n)
n = strlen (s);
are not allowed. */
static Lisp_Object
-read0 (readcharfun)
- Lisp_Object readcharfun;
+read0 (Lisp_Object readcharfun)
{
register Lisp_Object val;
int c;
If the escape sequence forces unibyte, return eight-bit char. */
static int
-read_escape (readcharfun, stringp)
- Lisp_Object readcharfun;
- int stringp;
+read_escape (Lisp_Object readcharfun, int stringp)
{
register int c = READCHAR;
/* \u allows up to four hex digits, \U up to eight. Default to the
range. */
static Lisp_Object
-read_integer (readcharfun, radix)
- Lisp_Object readcharfun;
- int radix;
+read_integer (Lisp_Object readcharfun, int radix)
{
int ndigits = 0, invalid_p, c, sign = 0;
/* We use a floating point number because */
FIRST_IN_LIST is nonzero if this is the first element of a list. */
static Lisp_Object
-read1 (readcharfun, pch, first_in_list)
- register Lisp_Object readcharfun;
- int *pch;
- int first_in_list;
+read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
{
register int c;
int uninterned_symbol = 0;
static Lisp_Object seen_list;
static void
-substitute_object_in_subtree (object, placeholder)
- Lisp_Object object;
- Lisp_Object placeholder;
+substitute_object_in_subtree (Lisp_Object object, Lisp_Object placeholder)
{
Lisp_Object check_object;
} while (0)
static Lisp_Object
-substitute_object_recurse (object, placeholder, subtree)
- Lisp_Object object;
- Lisp_Object placeholder;
- Lisp_Object subtree;
+substitute_object_recurse (Lisp_Object object, Lisp_Object placeholder, Lisp_Object subtree)
{
/* If we find the placeholder, return the target object. */
if (EQ (placeholder, subtree))
/* Helper function for substitute_object_recurse. */
static void
-substitute_in_interval (interval, arg)
- INTERVAL interval;
- Lisp_Object arg;
+substitute_in_interval (INTERVAL interval, Lisp_Object arg)
{
Lisp_Object object = Fcar (arg);
Lisp_Object placeholder = Fcdr (arg);
#define EXP_INT 16
int
-isfloat_string (cp, ignore_trailing)
- register char *cp;
- int ignore_trailing;
+isfloat_string (register char *cp, int ignore_trailing)
{
register int state;
\f
static Lisp_Object
-read_vector (readcharfun, bytecodeflag)
- Lisp_Object readcharfun;
- int bytecodeflag;
+read_vector (Lisp_Object readcharfun, int bytecodeflag)
{
register int i;
register int size;
and make structure pure. */
static Lisp_Object
-read_list (flag, readcharfun)
- int flag;
- register Lisp_Object readcharfun;
+read_list (int flag, register Lisp_Object readcharfun)
{
/* -1 means check next element for defun,
0 means don't check,
int oblookup_last_bucket_number;
-static int hash_string ();
+static int hash_string (const unsigned char *ptr, int len);
/* Get an error if OBARRAY is not an obarray.
If it is one, return it. */
Lisp_Object
-check_obarray (obarray)
- Lisp_Object obarray;
+check_obarray (Lisp_Object obarray)
{
if (!VECTORP (obarray) || XVECTOR (obarray)->size == 0)
{
interned in the current obarray. */
Lisp_Object
-intern (str)
- const char *str;
+intern (const char *str)
{
Lisp_Object tem;
int len = strlen (str);
/* Create an uninterned symbol with name STR. */
Lisp_Object
-make_symbol (str)
- char *str;
+make_symbol (char *str)
{
int len = strlen (str);
Also store the bucket number in oblookup_last_bucket_number. */
Lisp_Object
-oblookup (obarray, ptr, size, size_byte)
- Lisp_Object obarray;
- register const char *ptr;
- int size, size_byte;
+oblookup (Lisp_Object obarray, register const char *ptr, int size, int size_byte)
{
int hash;
int obsize;
}
static int
-hash_string (ptr, len)
- const unsigned char *ptr;
- int len;
+hash_string (const unsigned char *ptr, int len)
{
register const unsigned char *p = ptr;
register const unsigned char *end = p + len;
}
\f
void
-map_obarray (obarray, fn, arg)
- Lisp_Object obarray;
- void (*fn) (Lisp_Object, Lisp_Object);
- Lisp_Object arg;
+map_obarray (Lisp_Object obarray, void (*fn) (Lisp_Object, Lisp_Object), Lisp_Object arg)
{
register int i;
register Lisp_Object tail;
}
void
-mapatoms_1 (sym, function)
- Lisp_Object sym, function;
+mapatoms_1 (Lisp_Object sym, Lisp_Object function)
{
call1 (function, sym);
}
#define OBARRAY_SIZE 1511
void
-init_obarray ()
+init_obarray (void)
{
Lisp_Object oblength;
}
\f
void
-defsubr (sname)
- struct Lisp_Subr *sname;
+defsubr (struct Lisp_Subr *sname)
{
Lisp_Object sym;
sym = intern_c_string (sname->symbol_name);
static Lisp_Object dump_path;
void
-init_lread ()
+init_lread (void)
{
char *normal;
int turn_off_warning = 0;
does not exist. Print it on stderr and put it in *Messages*. */
void
-dir_warning (format, dirname)
- char *format;
- Lisp_Object dirname;
+dir_warning (char *format, Lisp_Object dirname)
{
char *buffer
= (char *) alloca (SCHARS (dirname) + strlen (format) + 5);
}
void
-syms_of_lread ()
+syms_of_lread (void)
{
defsubr (&Sread);
defsubr (&Sread_from_string);
extern Lisp_Object real_this_command;
-Lisp_Object Fexecute_kbd_macro ();
+Lisp_Object Fexecute_kbd_macro (Lisp_Object macro, Lisp_Object count, Lisp_Object loopfunc);
\f
DEFUN ("start-kbd-macro", Fstart_kbd_macro, Sstart_kbd_macro, 1, 2, "P",
doc: /* Record subsequent keyboard input, defining a keyboard macro.
/* Finish defining the current keyboard macro. */
void
-end_kbd_macro ()
+end_kbd_macro (void)
{
current_kboard->defining_kbd_macro = Qnil;
update_mode_lines++;
/* Store character c into kbd macro being defined */
void
-store_kbd_macro_char (c)
- Lisp_Object c;
+store_kbd_macro_char (Lisp_Object c)
{
struct kboard *kb = current_kboard;
really belong to it. This is done in between editor commands. */
void
-finalize_kbd_macro_chars ()
+finalize_kbd_macro_chars (void)
{
current_kboard->kbd_macro_end = current_kboard->kbd_macro_ptr;
}
Called when the unwind-protect in Fexecute_kbd_macro gets invoked. */
static Lisp_Object
-pop_kbd_macro (info)
- Lisp_Object info;
+pop_kbd_macro (Lisp_Object info)
{
Lisp_Object tem;
Vexecuting_kbd_macro = XCAR (info);
}
\f
void
-init_macros ()
+init_macros (void)
{
Vexecuting_kbd_macro = Qnil;
executing_kbd_macro = Qnil;
}
void
-syms_of_macros ()
+syms_of_macros (void)
{
Qexecute_kbd_macro = intern_c_string ("execute-kbd-macro");
staticpro (&Qexecute_kbd_macro);
static int byte_debug_flag;
void
-clear_charpos_cache (b)
- struct buffer *b;
+clear_charpos_cache (struct buffer *b)
{
if (cached_buffer == b)
cached_buffer = 0;
}
static void
-byte_char_debug_check (b, charpos, bytepos)
- struct buffer *b;
- int charpos, bytepos;
+byte_char_debug_check (struct buffer *b, int charpos, int bytepos)
{
int nchars = 0;
}
int
-charpos_to_bytepos (charpos)
- int charpos;
+charpos_to_bytepos (int charpos)
{
return buf_charpos_to_bytepos (current_buffer, charpos);
}
int
-buf_charpos_to_bytepos (b, charpos)
- struct buffer *b;
- int charpos;
+buf_charpos_to_bytepos (struct buffer *b, int charpos)
{
struct Lisp_Marker *tail;
int best_above, best_above_byte;
in the simplest, most reliable way. */
int
-verify_bytepos (charpos)
- int charpos;
+verify_bytepos (int charpos)
{
int below = 1;
int below_byte = 1;
}
int
-bytepos_to_charpos (bytepos)
- int bytepos;
+bytepos_to_charpos (int bytepos)
{
return buf_bytepos_to_charpos (current_buffer, bytepos);
}
int
-buf_bytepos_to_charpos (b, bytepos)
- struct buffer *b;
- int bytepos;
+buf_bytepos_to_charpos (struct buffer *b, int bytepos)
{
struct Lisp_Marker *tail;
int best_above, best_above_byte;
be outside the visible part. */
Lisp_Object
-set_marker_restricted (marker, pos, buffer)
- Lisp_Object marker, pos, buffer;
+set_marker_restricted (Lisp_Object marker, Lisp_Object pos, Lisp_Object buffer)
{
register int charno, bytepos;
register struct buffer *b;
character position and the corresponding byte position. */
Lisp_Object
-set_marker_both (marker, buffer, charpos, bytepos)
- Lisp_Object marker, buffer;
- int charpos, bytepos;
+set_marker_both (Lisp_Object marker, Lisp_Object buffer, int charpos, int bytepos)
{
register struct buffer *b;
register struct Lisp_Marker *m;
be outside the visible part. */
Lisp_Object
-set_marker_restricted_both (marker, buffer, charpos, bytepos)
- Lisp_Object marker, buffer;
- int charpos, bytepos;
+set_marker_restricted_both (Lisp_Object marker, Lisp_Object buffer, int charpos, int bytepos)
{
register struct buffer *b;
register struct Lisp_Marker *m;
including those in chain fields of markers. */
void
-unchain_marker (marker)
- register struct Lisp_Marker *marker;
+unchain_marker (register struct Lisp_Marker *marker)
{
register struct Lisp_Marker *tail, *prev, *next;
register struct buffer *b;
/* Return the char position of marker MARKER, as a C integer. */
int
-marker_position (marker)
- Lisp_Object marker;
+marker_position (Lisp_Object marker)
{
register struct Lisp_Marker *m = XMARKER (marker);
register struct buffer *buf = m->buffer;
/* Return the byte position of marker MARKER, as a C integer. */
int
-marker_byte_position (marker)
- Lisp_Object marker;
+marker_byte_position (Lisp_Object marker)
{
register struct Lisp_Marker *m = XMARKER (marker);
register struct buffer *buf = m->buffer;
/* For debugging -- count the markers in buffer BUF. */
int
-count_markers (buf)
- struct buffer *buf;
+count_markers (struct buffer *buf)
{
int total = 0;
struct Lisp_Marker *tail;
}
\f
void
-syms_of_marker ()
+syms_of_marker (void)
{
defsubr (&Smarker_position);
defsubr (&Smarker_buffer);
/* Initialize structure containing state of computation.
(RFC 1321, 3.3: Step 3) */
void
-md5_init_ctx (ctx)
- struct md5_ctx *ctx;
+md5_init_ctx (struct md5_ctx *ctx)
{
ctx->A = 0x67452301;
ctx->B = 0xefcdab89;
IMPORTANT: On some systems it is required that RESBUF is correctly
aligned for a 32 bits value. */
void *
-md5_read_ctx (ctx, resbuf)
- const struct md5_ctx *ctx;
- void *resbuf;
+md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
{
((md5_uint32 *) resbuf)[0] = SWAP (ctx->A);
((md5_uint32 *) resbuf)[1] = SWAP (ctx->B);
IMPORTANT: On some systems it is required that RESBUF is correctly
aligned for a 32 bits value. */
void *
-md5_finish_ctx (ctx, resbuf)
- struct md5_ctx *ctx;
- void *resbuf;
+md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
{
/* Take yet unprocessed bytes into account. */
md5_uint32 bytes = ctx->buflen;
resulting message digest number will be written into the 16 bytes
beginning at RESBLOCK. */
int
-md5_stream (stream, resblock)
- FILE *stream;
- void *resblock;
+md5_stream (FILE *stream, void *resblock)
{
/* Important: BLOCKSIZE must be a multiple of 64. */
#define BLOCKSIZE 4096
output yields to the wanted ASCII representation of the message
digest. */
void *
-md5_buffer (buffer, len, resblock)
- const char *buffer;
- size_t len;
- void *resblock;
+md5_buffer (const char *buffer, size_t len, void *resblock)
{
struct md5_ctx ctx;
void
-md5_process_bytes (buffer, len, ctx)
- const void *buffer;
- size_t len;
- struct md5_ctx *ctx;
+md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
{
/* const void aligned_buffer = buffer; */
It is assumed that LEN % 64 == 0. */
void
-md5_process_block (buffer, len, ctx)
- const void *buffer;
- size_t len;
- struct md5_ctx *ctx;
+md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
{
md5_uint32 correct_words[16];
const md5_uint32 *words = buffer;
static int menu_items_submenu_depth;
void
-init_menu_items ()
+init_menu_items (void)
{
if (!NILP (menu_items_inuse))
error ("Trying to use a menu from within a menu-entry");
/* Call at the end of generating the data in menu_items. */
void
-finish_menu_items ()
+finish_menu_items (void)
{
}
Lisp_Object
-unuse_menu_items (dummy)
- Lisp_Object dummy;
+unuse_menu_items (Lisp_Object dummy)
{
return menu_items_inuse = Qnil;
}
in menu_items. */
void
-discard_menu_items ()
+discard_menu_items (void)
{
/* Free the structure if it is especially large.
Otherwise, hold on to it, to save time. */
mechanism. */
static Lisp_Object
-restore_menu_items (saved)
- Lisp_Object saved;
+restore_menu_items (Lisp_Object saved)
{
menu_items = XCAR (saved);
menu_items_inuse = (! NILP (menu_items) ? Qt : Qnil);
It will be restored when the specpdl is unwound. */
void
-save_menu_items ()
+save_menu_items (void)
{
Lisp_Object saved = list4 (!NILP (menu_items_inuse) ? menu_items : Qnil,
make_number (menu_items_used),
/* Make the menu_items vector twice as large. */
static void
-grow_menu_items ()
+grow_menu_items (void)
{
menu_items_allocated *= 2;
menu_items = larger_vector (menu_items, menu_items_allocated, Qnil);
/* Begin a submenu. */
static void
-push_submenu_start ()
+push_submenu_start (void)
{
if (menu_items_used + 1 > menu_items_allocated)
grow_menu_items ();
/* End a submenu. */
static void
-push_submenu_end ()
+push_submenu_end (void)
{
if (menu_items_used + 1 > menu_items_allocated)
grow_menu_items ();
/* Indicate boundary between left and right. */
static void
-push_left_right_boundary ()
+push_left_right_boundary (void)
{
if (menu_items_used + 1 > menu_items_allocated)
grow_menu_items ();
NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
static void
-push_menu_pane (name, prefix_vec)
- Lisp_Object name, prefix_vec;
+push_menu_pane (Lisp_Object name, Lisp_Object prefix_vec)
{
if (menu_items_used + MENU_ITEMS_PANE_LENGTH > menu_items_allocated)
grow_menu_items ();
item, one of nil, `toggle' or `radio'. */
static void
-push_menu_item (name, enable, key, def, equiv, type, selected, help)
- Lisp_Object name, enable, key, def, equiv, type, selected, help;
+push_menu_item (Lisp_Object name, Lisp_Object enable, Lisp_Object key, Lisp_Object def, Lisp_Object equiv, Lisp_Object type, Lisp_Object selected, Lisp_Object help)
{
if (menu_items_used + MENU_ITEMS_ITEM_LENGTH > menu_items_allocated)
grow_menu_items ();
If we encounter submenus deeper than SKP->MAXDEPTH levels, ignore them. */
static void
-single_menu_item (key, item, dummy, skp_v)
- Lisp_Object key, item, dummy;
- void *skp_v;
+single_menu_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy, void *skp_v)
{
Lisp_Object map, item_string, enabled;
struct gcpro gcpro1, gcpro2;
and generate menu panes for them in menu_items. */
static void
-keymap_panes (keymaps, nmaps)
- Lisp_Object *keymaps;
- int nmaps;
+keymap_panes (Lisp_Object *keymaps, int nmaps)
{
int mapno;
/* Push the items in a single pane defined by the alist PANE. */
static void
-list_of_items (pane)
- Lisp_Object pane;
+list_of_items (Lisp_Object pane)
{
Lisp_Object tail, item, item1;
alist-of-alists MENU.
This handles old-fashioned calls to x-popup-menu. */
void
-list_of_panes (menu)
- Lisp_Object menu;
+list_of_panes (Lisp_Object menu)
{
Lisp_Object tail;
whose event type is ITEM_KEY (with string ITEM_NAME)
and whose contents come from the list of keymaps MAPS. */
int
-parse_single_submenu (item_key, item_name, maps)
- Lisp_Object item_key, item_name, maps;
+parse_single_submenu (Lisp_Object item_key, Lisp_Object item_name, Lisp_Object maps)
{
Lisp_Object length;
int len;
/* Allocate a widget_value, blocking input. */
widget_value *
-xmalloc_widget_value ()
+xmalloc_widget_value (void)
{
widget_value *value;
must be left alone. */
void
-free_menubar_widget_value_tree (wv)
- widget_value *wv;
+free_menubar_widget_value_tree (widget_value *wv)
{
if (! wv) return;
in menu_items starting at index START, up to index END. */
widget_value *
-digest_single_submenu (start, end, top_level_items)
- int start, end, top_level_items;
+digest_single_submenu (int start, int end, int top_level_items)
{
widget_value *wv, *prev_wv, *save_wv, *first_wv;
int i;
tree is constructed, and small strings are relocated. So we must wait
until no GC can happen before storing pointers into lisp values. */
void
-update_submenu_strings (first_wv)
- widget_value *first_wv;
+update_submenu_strings (widget_value *first_wv)
{
widget_value *wv;
VECTOR is an array of menu events for the whole menu. */
void
-find_and_call_menu_selection (f, menu_bar_items_used, vector, client_data)
- FRAME_PTR f;
- int menu_bar_items_used;
- Lisp_Object vector;
- void *client_data;
+find_and_call_menu_selection (FRAME_PTR f, int menu_bar_items_used, Lisp_Object vector, void *client_data)
{
Lisp_Object prefix, entry;
Lisp_Object *subprefix_stack;
}
void
-syms_of_menu ()
+syms_of_menu (void)
{
staticpro (&menu_items);
menu_items = Qnil;
or when a minibuffer exits. */
void
-choose_minibuf_frame ()
+choose_minibuf_frame (void)
{
if (FRAMEP (selected_frame)
&& FRAME_LIVE_P (XFRAME (selected_frame))
}
Lisp_Object
-choose_minibuf_frame_1 (ignore)
- Lisp_Object ignore;
+choose_minibuf_frame_1 (Lisp_Object ignore)
{
choose_minibuf_frame ();
return Qnil;
string, and DEFALT is a string, read from DEFALT instead of VAL. */
static Lisp_Object
-string_to_object (val, defalt)
- Lisp_Object val, defalt;
+string_to_object (Lisp_Object val, Lisp_Object defalt)
{
struct gcpro gcpro1, gcpro2;
Lisp_Object expr_and_pos;
used for nonrecursive minibuffer invocations */
Lisp_Object
-get_minibuffer (depth)
- int depth;
+get_minibuffer (int depth)
{
Lisp_Object tail, num, buf;
char name[24];
- extern Lisp_Object nconc2 ();
+ extern Lisp_Object nconc2 (Lisp_Object, Lisp_Object);
XSETFASTINT (num, depth);
tail = Fnthcdr (num, Vminibuffer_list);
}
static Lisp_Object
-run_exit_minibuf_hook (data)
- Lisp_Object data;
+run_exit_minibuf_hook (Lisp_Object data)
{
if (!NILP (Vminibuffer_exit_hook) && !EQ (Vminibuffer_exit_hook, Qunbound)
&& !NILP (Vrun_hooks))
not, and it restores the current window, buffer, etc. */
static Lisp_Object
-read_minibuf_unwind (data)
- Lisp_Object data;
+read_minibuf_unwind (Lisp_Object data)
{
Lisp_Object old_deactivate_mark;
Lisp_Object window;
}
\f
static Lisp_Object
-minibuf_conform_representation (string, basis)
- Lisp_Object string, basis;
+minibuf_conform_representation (Lisp_Object string, Lisp_Object basis)
{
if (STRING_MULTIBYTE (string) == STRING_MULTIBYTE (basis))
return string;
RETURN_UNGCPRO (unbind_to (count, val));
}
\f
-Lisp_Object Fassoc_string ();
+Lisp_Object Fassoc_string (register Lisp_Object key, Lisp_Object list, Lisp_Object case_fold);
/* Test whether TXT is an exact completion. */
DEFUN ("test-completion", Ftest_completion, Stest_completion, 2, 3, 0,
\f
void
-init_minibuf_once ()
+init_minibuf_once (void)
{
Vminibuffer_list = Qnil;
staticpro (&Vminibuffer_list);
}
void
-syms_of_minibuf ()
+syms_of_minibuf (void)
{
minibuf_level = 0;
minibuf_prompt = Qnil;
#include <stdlib.h>
int
-main (argc, argv)
- int argc;
- char **argv;
+main (int argc, char **argv)
{
char *progname;
char *prefix;
extern int minibuffer_auto_raise;
-void print_interval ();
+void print_interval (INTERVAL interval, Lisp_Object printcharfun);
/* GDB resets this to zero on W32 to disable OutputDebugString calls. */
int print_output_debug_flag = 1;
when there is a recursive call to print. */
static Lisp_Object
-print_unwind (saved_text)
- Lisp_Object saved_text;
+print_unwind (Lisp_Object saved_text)
{
bcopy (SDATA (saved_text), print_buffer, SCHARS (saved_text));
return Qnil;
argument. */
static void
-printchar (ch, fun)
- unsigned int ch;
- Lisp_Object fun;
+printchar (unsigned int ch, Lisp_Object fun)
{
if (!NILP (fun) && !EQ (fun, Qt))
call1 (fun, make_number (ch));
to data in a Lisp string. Otherwise that is not safe. */
static void
-strout (ptr, size, size_byte, printcharfun, multibyte)
- char *ptr;
- int size, size_byte;
- Lisp_Object printcharfun;
- int multibyte;
+strout (char *ptr, int size, int size_byte, Lisp_Object printcharfun, int multibyte)
{
if (size < 0)
size_byte = size = strlen (ptr);
because printing one char can relocate. */
static void
-print_string (string, printcharfun)
- Lisp_Object string;
- Lisp_Object printcharfun;
+print_string (Lisp_Object string, Lisp_Object printcharfun)
{
if (EQ (printcharfun, Qt) || NILP (printcharfun))
{
Do not use this on the contents of a Lisp string. */
void
-write_string (data, size)
- char *data;
- int size;
+write_string (char *data, int size)
{
PRINTDECLARE;
Lisp_Object printcharfun;
Do not use this on the contents of a Lisp string. */
void
-write_string_1 (data, size, printcharfun)
- char *data;
- int size;
- Lisp_Object printcharfun;
+write_string_1 (char *data, int size, Lisp_Object printcharfun)
{
PRINTDECLARE;
void
-temp_output_buffer_setup (bufname)
- const char *bufname;
+temp_output_buffer_setup (const char *bufname)
{
int count = SPECPDL_INDEX ();
register struct buffer *old = current_buffer;
}
Lisp_Object
-internal_with_output_to_temp_buffer (bufname, function, args)
- const char *bufname;
- Lisp_Object (*function) (Lisp_Object);
- Lisp_Object args;
+internal_with_output_to_temp_buffer (const char *bufname, Lisp_Object (*function) (Lisp_Object), Lisp_Object args)
{
int count = SPECPDL_INDEX ();
Lisp_Object buf, val;
}
\f
-static void print ();
-static void print_preprocess ();
-static void print_preprocess_string ();
-static void print_object ();
+static void print (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag);
+static void print_preprocess (Lisp_Object obj);
+static void print_preprocess_string (INTERVAL interval, Lisp_Object arg);
+static void print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag);
DEFUN ("terpri", Fterpri, Sterpri, 0, 1, 0,
doc: /* Output a newline to stream PRINTCHARFUN.
print_output_debug_flag from being optimized away. */
void
-debug_output_compilation_hack (x)
- int x;
+debug_output_compilation_hack (int x)
{
print_output_debug_flag = x;
}
/* This is the interface for debugging printing. */
void
-debug_print (arg)
- Lisp_Object arg;
+debug_print (Lisp_Object arg)
{
Fprin1 (arg, Qexternal_debugging_output);
fprintf (stderr, "\r\n");
}
void
-safe_debug_print (arg)
- Lisp_Object arg;
+safe_debug_print (Lisp_Object arg)
{
int valid = valid_lisp_object_p (arg);
CALLER is the Lisp function inside which the error was signaled. */
void
-print_error_message (data, stream, context, caller)
- Lisp_Object data, stream;
- char *context;
- Lisp_Object caller;
+print_error_message (Lisp_Object data, Lisp_Object stream, char *context, Lisp_Object caller)
{
Lisp_Object errname, errmsg, file_error, tail;
struct gcpro gcpro1;
*/
void
-float_to_string (buf, data)
- unsigned char *buf;
- double data;
+float_to_string (unsigned char *buf, double data)
{
unsigned char *cp;
int width;
\f
static void
-print (obj, printcharfun, escapeflag)
- Lisp_Object obj;
- register Lisp_Object printcharfun;
- int escapeflag;
+print (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag)
{
new_backquote_output = 0;
The status fields of Vprint_number_table mean whether each object appears
more than once in OBJ: Qnil at the first time, and Qt after that . */
static void
-print_preprocess (obj)
- Lisp_Object obj;
+print_preprocess (Lisp_Object obj)
{
int i;
EMACS_INT size;
}
static void
-print_preprocess_string (interval, arg)
- INTERVAL interval;
- Lisp_Object arg;
+print_preprocess_string (INTERVAL interval, Lisp_Object arg)
{
print_preprocess (interval->plist);
}
Lisp_Object Vprint_charset_text_property;
extern Lisp_Object Qdefault;
-static void print_check_string_charset_prop ();
+static void print_check_string_charset_prop (INTERVAL interval, Lisp_Object string);
#define PRINT_STRING_NON_CHARSET_FOUND 1
#define PRINT_STRING_UNSAFE_CHARSET_FOUND 2
static int print_check_string_result;
static void
-print_check_string_charset_prop (interval, string)
- INTERVAL interval;
- Lisp_Object string;
+print_check_string_charset_prop (INTERVAL interval, Lisp_Object string)
{
Lisp_Object val;
static Lisp_Object print_prune_charset_plist;
static Lisp_Object
-print_prune_string_charset (string)
- Lisp_Object string;
+print_prune_string_charset (Lisp_Object string)
{
print_check_string_result = 0;
traverse_intervals (STRING_INTERVALS (string), 0,
}
static void
-print_object (obj, printcharfun, escapeflag)
- Lisp_Object obj;
- register Lisp_Object printcharfun;
- int escapeflag;
+print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag)
{
char buf[40];
This is part of printing a string that has text properties. */
void
-print_interval (interval, printcharfun)
- INTERVAL interval;
- Lisp_Object printcharfun;
+print_interval (INTERVAL interval, Lisp_Object printcharfun)
{
if (NILP (interval->plist))
return;
\f
void
-syms_of_print ()
+syms_of_print (void)
{
Qtemp_buffer_setup_hook = intern_c_string ("temp-buffer-setup-hook");
staticpro (&Qtemp_buffer_setup_hook);
/* Declared in dispnew.c, this version doesn't screw up if regions
overlap. */
-extern void safe_bcopy ();
+extern void safe_bcopy (const char *, char *, int);
#ifdef DOUG_LEA_MALLOC
#define M_TOP_PAD -2
-extern int mallopt ();
+extern int mallopt (int, int);
#else /* not DOUG_LEA_MALLOC */
#ifndef SYSTEM_MALLOC
extern size_t __malloc_extra_blocks;
static int r_alloc_initialized = 0;
-static void r_alloc_init ();
+static void r_alloc_init (void);
\f
/* Declarations for working with the malloc, ralloc, and system breaks. */
/* Find the heap that ADDRESS falls within. */
static heap_ptr
-find_heap (address)
- POINTER address;
+find_heap (POINTER address)
{
heap_ptr heap;
allocate the memory. */
static POINTER
-obtain (address, size)
- POINTER address;
- SIZE size;
+obtain (POINTER address, SIZE size)
{
heap_ptr heap;
SIZE already_available;
it can also eliminate the last heap entirely. */
static void
-relinquish ()
+relinquish (void)
{
register heap_ptr h;
long excess = 0;
above where malloc gets space. */
long
-r_alloc_size_in_use ()
+r_alloc_size_in_use (void)
{
return (char *) break_value - (char *) virtual_break_value;
}
to that block. */
static bloc_ptr
-find_bloc (ptr)
- POINTER *ptr;
+find_bloc (POINTER *ptr)
{
register bloc_ptr p = first_bloc;
memory for the new block. */
static bloc_ptr
-get_bloc (size)
- SIZE size;
+get_bloc (SIZE size)
{
register bloc_ptr new_bloc;
register heap_ptr heap;
Do not touch the contents of blocs or break_value. */
static int
-relocate_blocs (bloc, heap, address)
- bloc_ptr bloc;
- heap_ptr heap;
- POINTER address;
+relocate_blocs (bloc_ptr bloc, heap_ptr heap, POINTER address)
{
register bloc_ptr b = bloc;
before that of BEFORE. */
static void
-reorder_bloc (bloc, before)
- bloc_ptr bloc, before;
+reorder_bloc (bloc_ptr bloc, bloc_ptr before)
{
bloc_ptr prev, next;
with heap HEAP and bloc BLOC. */
static void
-update_heap_bloc_correspondence (bloc, heap)
- bloc_ptr bloc;
- heap_ptr heap;
+update_heap_bloc_correspondence (bloc_ptr bloc, heap_ptr heap)
{
register bloc_ptr b;
that come after BLOC in memory. */
static int
-resize_bloc (bloc, size)
- bloc_ptr bloc;
- SIZE size;
+resize_bloc (bloc_ptr bloc, SIZE size)
{
register bloc_ptr b;
heap_ptr heap;
This may return space to the system. */
static void
-free_bloc (bloc)
- bloc_ptr bloc;
+free_bloc (bloc_ptr bloc)
{
heap_ptr heap = bloc->heap;
GNU malloc package. */
POINTER
-r_alloc_sbrk (size)
- long size;
+r_alloc_sbrk (long int size)
{
register bloc_ptr b;
POINTER address;
return zero. */
POINTER
-r_alloc (ptr, size)
- POINTER *ptr;
- SIZE size;
+r_alloc (POINTER *ptr, SIZE size)
{
register bloc_ptr new_bloc;
Store 0 in *PTR to show there's no block allocated. */
void
-r_alloc_free (ptr)
- register POINTER *ptr;
+r_alloc_free (register POINTER *ptr)
{
register bloc_ptr dead_bloc;
return zero. */
POINTER
-r_re_alloc (ptr, size)
- POINTER *ptr;
- SIZE size;
+r_re_alloc (POINTER *ptr, SIZE size)
{
register bloc_ptr bloc;
malloc must return a null pointer. */
void
-r_alloc_freeze (size)
- long size;
+r_alloc_freeze (long int size)
{
if (! r_alloc_initialized)
r_alloc_init ();
}
void
-r_alloc_thaw ()
+r_alloc_thaw (void)
{
if (! r_alloc_initialized)
/* Reinitialize the morecore hook variables after restarting a dumped
Emacs. This is needed when using Doug Lea's malloc from GNU libc. */
void
-r_alloc_reinit ()
+r_alloc_reinit (void)
{
/* Only do this if the hook has been reset, so that we don't get an
infinite loop, in case Emacs was linked statically. */
is checked to ensure that memory corruption does not occur due to
misuse. */
void
-r_alloc_reset_variable (old, new)
- POINTER *old, *new;
+r_alloc_reset_variable (POINTER *old, POINTER *new)
{
bloc_ptr bloc = first_bloc;
/* Initialize various things for memory allocation. */
static void
-r_alloc_init ()
+r_alloc_init (void)
{
if (r_alloc_initialized)
return;
defined in regex.h. We return the old syntax. */
reg_syntax_t
-re_set_syntax (syntax)
- reg_syntax_t syntax;
+re_set_syntax (reg_syntax_t syntax)
{
reg_syntax_t ret = re_syntax_options;
static re_char *whitespace_regexp;
void
-re_set_whitespace_regexp (regexp)
- const char *regexp;
+re_set_whitespace_regexp (const char *regexp)
{
whitespace_regexp = (re_char *) regexp;
}
/* Map a string to the char class it names (if any). */
re_wctype_t
-re_wctype (str)
- re_char *str;
+re_wctype (const re_char *str)
{
const char *string = str;
if (STREQ (string, "alnum")) return RECC_ALNUM;
/* True if CH is in the char class CC. */
boolean
-re_iswctype (ch, cc)
- int ch;
- re_wctype_t cc;
+re_iswctype (int ch, re_wctype_t cc)
{
switch (cc)
{
/* Return a bit-pattern to use in the range-table bits to match multibyte
chars of class CC. */
static int
-re_wctype_to_bit (cc)
- re_wctype_t cc;
+re_wctype_to_bit (re_wctype_t cc)
{
switch (cc)
{
/* Actually extend the space in WORK_AREA. */
static void
-extend_range_table_work_area (work_area)
- struct range_table_work_area *work_area;
+extend_range_table_work_area (struct range_table_work_area *work_area)
{
work_area->allocated += 16 * sizeof (int);
if (work_area->table)
} while (0)
static reg_errcode_t
-regex_compile (pattern, size, syntax, bufp)
- re_char *pattern;
- size_t size;
- reg_syntax_t syntax;
- struct re_pattern_buffer *bufp;
+regex_compile (const re_char *pattern, size_t size, reg_syntax_t syntax, struct re_pattern_buffer *bufp)
{
/* We fetch characters from PATTERN here. */
register re_wchar_t c, c1;
/* Store OP at LOC followed by two-byte integer parameter ARG. */
static void
-store_op1 (op, loc, arg)
- re_opcode_t op;
- unsigned char *loc;
- int arg;
+store_op1 (re_opcode_t op, unsigned char *loc, int arg)
{
*loc = (unsigned char) op;
STORE_NUMBER (loc + 1, arg);
/* Like `store_op1', but for two two-byte parameters ARG1 and ARG2. */
static void
-store_op2 (op, loc, arg1, arg2)
- re_opcode_t op;
- unsigned char *loc;
- int arg1, arg2;
+store_op2 (re_opcode_t op, unsigned char *loc, int arg1, int arg2)
{
*loc = (unsigned char) op;
STORE_NUMBER (loc + 1, arg1);
for OP followed by two-byte integer parameter ARG. */
static void
-insert_op1 (op, loc, arg, end)
- re_opcode_t op;
- unsigned char *loc;
- int arg;
- unsigned char *end;
+insert_op1 (re_opcode_t op, unsigned char *loc, int arg, unsigned char *end)
{
register unsigned char *pfrom = end;
register unsigned char *pto = end + 3;
/* Like `insert_op1', but for two two-byte parameters ARG1 and ARG2. */
static void
-insert_op2 (op, loc, arg1, arg2, end)
- re_opcode_t op;
- unsigned char *loc;
- int arg1, arg2;
- unsigned char *end;
+insert_op2 (re_opcode_t op, unsigned char *loc, int arg1, int arg2, unsigned char *end)
{
register unsigned char *pfrom = end;
register unsigned char *pto = end + 5;
least one character before the ^. */
static boolean
-at_begline_loc_p (pattern, p, syntax)
- re_char *pattern, *p;
- reg_syntax_t syntax;
+at_begline_loc_p (const re_char *pattern, const re_char *p, reg_syntax_t syntax)
{
re_char *prev = p - 2;
boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\';
at least one character after the $, i.e., `P < PEND'. */
static boolean
-at_endline_loc_p (p, pend, syntax)
- re_char *p, *pend;
- reg_syntax_t syntax;
+at_endline_loc_p (const re_char *p, const re_char *pend, reg_syntax_t syntax)
{
re_char *next = p;
boolean next_backslash = *next == '\\';
false if it's not. */
static boolean
-group_in_compile_stack (compile_stack, regnum)
- compile_stack_type compile_stack;
- regnum_t regnum;
+group_in_compile_stack (compile_stack_type compile_stack, regnum_t regnum)
{
int this_element;
Return -1 if fastmap was not updated accurately. */
static int
-analyse_first (p, pend, fastmap, multibyte)
- re_char *p, *pend;
- char *fastmap;
- const int multibyte;
+analyse_first (const re_char *p, const re_char *pend, char *fastmap, const const int multibyte)
{
int j, k;
boolean not;
Returns 0 if we succeed, -2 if an internal error. */
int
-re_compile_fastmap (bufp)
- struct re_pattern_buffer *bufp;
+re_compile_fastmap (struct re_pattern_buffer *bufp)
{
char *fastmap = bufp->fastmap;
int analysis;
freeing the old data. */
void
-re_set_registers (bufp, regs, num_regs, starts, ends)
- struct re_pattern_buffer *bufp;
- struct re_registers *regs;
- unsigned num_regs;
- regoff_t *starts, *ends;
+re_set_registers (struct re_pattern_buffer *bufp, struct re_registers *regs, unsigned int num_regs, regoff_t *starts, regoff_t *ends)
{
if (num_regs)
{
doesn't let you say where to stop matching. */
int
-re_search (bufp, string, size, startpos, range, regs)
- struct re_pattern_buffer *bufp;
- const char *string;
- int size, startpos, range;
- struct re_registers *regs;
+re_search (struct re_pattern_buffer *bufp, const char *string, int size, int startpos, int range, struct re_registers *regs)
{
return re_search_2 (bufp, NULL, 0, string, size, startpos, range,
regs, size);
stack overflow). */
int
-re_search_2 (bufp, str1, size1, str2, size2, startpos, range, regs, stop)
- struct re_pattern_buffer *bufp;
- const char *str1, *str2;
- int size1, size2;
- int startpos;
- int range;
- struct re_registers *regs;
- int stop;
+re_search_2 (struct re_pattern_buffer *bufp, const char *str1, int size1, const char *str2, int size2, int startpos, int range, struct re_registers *regs, int stop)
{
int val;
re_char *string1 = (re_char*) str1;
/* If the operation is a match against one or more chars,
return a pointer to the next operation, else return NULL. */
static re_char *
-skip_one_char (p)
- re_char *p;
+skip_one_char (const re_char *p)
{
switch (SWITCH_ENUM_CAST (*p++))
{
/* Jump over non-matching operations. */
static re_char *
-skip_noops (p, pend)
- re_char *p, *pend;
+skip_noops (const re_char *p, const re_char *pend)
{
int mcnt;
while (p < pend)
/* Non-zero if "p1 matches something" implies "p2 fails". */
static int
-mutually_exclusive_p (bufp, p1, p2)
- struct re_pattern_buffer *bufp;
- re_char *p1, *p2;
+mutually_exclusive_p (struct re_pattern_buffer *bufp, const re_char *p1, const re_char *p2)
{
re_opcode_t op2;
const boolean multibyte = RE_MULTIBYTE_P (bufp);
matched substring. */
int
-re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
- struct re_pattern_buffer *bufp;
- const char *string1, *string2;
- int size1, size2;
- int pos;
- struct re_registers *regs;
- int stop;
+re_match_2 (struct re_pattern_buffer *bufp, const char *string1, int size1, const char *string2, int size2, int pos, struct re_registers *regs, int stop)
{
int result;
/* This is a separate function so that we can force an alloca cleanup
afterwards. */
static int
-re_match_2_internal (bufp, string1, size1, string2, size2, pos, regs, stop)
- struct re_pattern_buffer *bufp;
- re_char *string1, *string2;
- int size1, size2;
- int pos;
- struct re_registers *regs;
- int stop;
+re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1, int size1, const re_char *string2, int size2, int pos, struct re_registers *regs, int stop)
{
/* General temporaries. */
int mcnt;
bytes; nonzero otherwise. */
static int
-bcmp_translate (s1, s2, len, translate, target_multibyte)
- re_char *s1, *s2;
- register int len;
- RE_TRANSLATE_TYPE translate;
- const int target_multibyte;
+bcmp_translate (const re_char *s1, const re_char *s2, register int len, Lisp_Object translate, const const int target_multibyte)
{
register re_char *p1 = s1, *p2 = s2;
re_char *p1_end = s1 + len;
We call regex_compile to do the actual compilation. */
const char *
-re_compile_pattern (pattern, length, bufp)
- const char *pattern;
- size_t length;
- struct re_pattern_buffer *bufp;
+re_compile_pattern (const char *pattern, size_t length, struct re_pattern_buffer *bufp)
{
reg_errcode_t ret;
preserve that information, instead of throwing it away. */
#define PRESERVE_THRESHOLD (500)
-static void revalidate_region_cache ();
+static void revalidate_region_cache (struct buffer *buf, struct region_cache *c);
\f
/* Interface: Allocating, initializing, and disposing of region caches. */
struct region_cache *
-new_region_cache ()
+new_region_cache (void)
{
struct region_cache *c
= (struct region_cache *) xmalloc (sizeof (struct region_cache));
}
void
-free_region_cache (c)
- struct region_cache *c;
+free_region_cache (struct region_cache *c)
{
xfree (c->boundaries);
xfree (c);
entries. It would be nice if it took advantage of locality of
reference, too, by searching entries near the last entry found. */
static int
-find_cache_boundary (c, pos)
- struct region_cache *c;
- int pos;
+find_cache_boundary (struct region_cache *c, int pos)
{
int low = 0, high = c->cache_len;
/* Move the gap of cache C to index POS, and make sure it has space
for at least MIN_SIZE boundaries. */
static void
-move_cache_gap (c, pos, min_size)
- struct region_cache *c;
- int pos;
- int min_size;
+move_cache_gap (struct region_cache *c, int pos, int min_size)
{
/* Copy these out of the cache and into registers. */
int gap_start = c->gap_start;
/* Insert a new boundary in cache C; it will have cache index INDEX,
and have the specified POS and VALUE. */
static void
-insert_cache_boundary (c, index, pos, value)
- struct region_cache *c;
- int index;
- int pos, value;
+insert_cache_boundary (struct region_cache *c, int index, int pos, int value)
{
/* index must be a valid cache index. */
if (index < 0 || index > c->cache_len)
/* Delete the i'th entry from cache C if START <= i < END. */
static void
-delete_cache_boundaries (c, start, end)
- struct region_cache *c;
- int start, end;
+delete_cache_boundaries (struct region_cache *c, int start, int end)
{
int len = end - start;
/* Set the value in cache C for the region START..END to VALUE. */
static void
-set_cache_region (c, start, end, value)
- struct region_cache *c;
- int start, end;
- int value;
+set_cache_region (struct region_cache *c, int start, int end, int value)
{
if (start > end)
abort ();
buffer positions in the presence of insertions and deletions; the
args to pass are the same before and after such an operation.) */
void
-invalidate_region_cache (buf, c, head, tail)
- struct buffer *buf;
- struct region_cache *c;
- int head, tail;
+invalidate_region_cache (struct buffer *buf, struct region_cache *c, int head, int tail)
{
/* Let chead = c->beg_unchanged, and
ctail = c->end_unchanged.
the cache, and causes cache gap motion. */
static void
-revalidate_region_cache (buf, c)
- struct buffer *buf;
- struct region_cache *c;
+revalidate_region_cache (struct buffer *buf, struct region_cache *c)
{
/* The boundaries now in the cache are expressed relative to the
buffer_beg and buffer_end values stored in the cache. Now,
buffer positions) is "known," for the purposes of CACHE (e.g. "has
no newlines", in the case of the line cache). */
void
-know_region_cache (buf, c, start, end)
- struct buffer *buf;
- struct region_cache *c;
- int start, end;
+know_region_cache (struct buffer *buf, struct region_cache *c, int start, int end)
{
revalidate_region_cache (buf, c);
the purposes of CACHE. If NEXT is non-zero, set *NEXT to the nearest
position after POS where the knownness changes. */
int
-region_cache_forward (buf, c, pos, next)
- struct buffer *buf;
- struct region_cache *c;
- int pos;
- int *next;
+region_cache_forward (struct buffer *buf, struct region_cache *c, int pos, int *next)
{
revalidate_region_cache (buf, c);
/* Return true if the text immediately before POS in BUF is known, for
the purposes of CACHE. If NEXT is non-zero, set *NEXT to the nearest
position before POS where the knownness changes. */
-int region_cache_backward (buf, c, pos, next)
- struct buffer *buf;
- struct region_cache *c;
- int pos;
- int *next;
+int region_cache_backward (struct buffer *buf, struct region_cache *c, int pos, int *next)
{
revalidate_region_cache (buf, c);
/* Debugging: pretty-print a cache to the standard error output. */
void
-pp_cache (c)
- struct region_cache *c;
+pp_cache (struct region_cache *c)
{
int i;
int beg_u = c->buffer_beg + c->beg_unchanged;
of lines. */
static void
-do_scrolling (frame, current_matrix, matrix, window_size, unchanged_at_top)
- struct frame *frame;
- struct glyph_matrix *current_matrix;
- struct matrix_elt *matrix;
- int window_size;
- int unchanged_at_top;
+do_scrolling (struct frame *frame, struct glyph_matrix *current_matrix, struct matrix_elt *matrix, int window_size, int unchanged_at_top)
{
struct matrix_elt *p;
int i, j, k;
such a line will have little weight. */
int
-scrolling_max_lines_saved (start, end, oldhash, newhash, cost)
- int start, end;
- int *oldhash, *newhash, *cost;
+scrolling_max_lines_saved (int start, int end, int *oldhash, int *newhash, int *cost)
{
struct { int hash; int count; } lines[01000];
register int i, h;
to scroll_frame_lines to perform this scrolling. */
int
-scroll_cost (frame, from, to, amount)
- FRAME_PTR frame;
- int from, to, amount;
+scroll_cost (FRAME_PTR frame, int from, int to, int amount)
{
/* Compute how many lines, at bottom of frame,
will not be involved in actual motion. */
overhead and multiply factor values */
static void
-line_ins_del (frame, ov1, pf1, ovn, pfn, ov, mf)
- FRAME_PTR frame;
- int ov1, ovn;
- int pf1, pfn;
- register int *ov, *mf;
+line_ins_del (FRAME_PTR frame, int ov1, int pf1, int ovn, int pfn, register int *ov, register int *mf)
{
register int i;
register int frame_lines = FRAME_LINES (frame);
static EMACS_INT search_buffer (Lisp_Object, EMACS_INT, EMACS_INT,
EMACS_INT, EMACS_INT, int, int,
Lisp_Object, Lisp_Object, int);
-static void matcher_overflow () NO_RETURN;
+static void matcher_overflow (void) NO_RETURN;
static void
-matcher_overflow ()
+matcher_overflow (void)
{
error ("Stack overflow in regexp matcher");
}
The behavior also depends on Vsearch_spaces_regexp. */
static void
-compile_pattern_1 (cp, pattern, translate, regp, posix)
- struct regexp_cache *cp;
- Lisp_Object pattern;
- Lisp_Object translate;
- struct re_registers *regp;
- int posix;
+compile_pattern_1 (struct regexp_cache *cp, Lisp_Object pattern, Lisp_Object translate, struct re_registers *regp, int posix)
{
char *val;
reg_syntax_t old;
This is called from garbage collection. */
void
-shrink_regexp_cache ()
+shrink_regexp_cache (void)
{
struct regexp_cache *cp;
automagically manages the memory in each re_pattern_buffer struct,
based on its `allocated' and `buffer' values. */
void
-clear_regexp_cache ()
+clear_regexp_cache (void)
{
int i;
for this pattern. 0 means backtrack only enough to get a valid match. */
struct re_pattern_buffer *
-compile_pattern (pattern, regp, translate, posix, multibyte)
- Lisp_Object pattern;
- struct re_registers *regp;
- Lisp_Object translate;
- int posix, multibyte;
+compile_pattern (Lisp_Object pattern, struct re_registers *regp, Lisp_Object translate, int posix, int multibyte)
{
struct regexp_cache *cp, **cpp;
\f
static Lisp_Object
-looking_at_1 (string, posix)
- Lisp_Object string;
- int posix;
+looking_at_1 (Lisp_Object string, int posix)
{
Lisp_Object val;
unsigned char *p1, *p2;
}
\f
static Lisp_Object
-string_match_1 (regexp, string, start, posix)
- Lisp_Object regexp, string, start;
- int posix;
+string_match_1 (Lisp_Object regexp, Lisp_Object string, Lisp_Object start, int posix)
{
int val;
struct re_pattern_buffer *bufp;
This does not clobber the match data. */
int
-fast_string_match (regexp, string)
- Lisp_Object regexp, string;
+fast_string_match (Lisp_Object regexp, Lisp_Object string)
{
int val;
struct re_pattern_buffer *bufp;
extern Lisp_Object Vascii_downcase_table;
int
-fast_c_string_match_ignore_case (regexp, string)
- Lisp_Object regexp;
- const char *string;
+fast_c_string_match_ignore_case (Lisp_Object regexp, const char *string)
{
int val;
struct re_pattern_buffer *bufp;
/* Like fast_string_match but ignore case. */
int
-fast_string_match_ignore_case (regexp, string)
- Lisp_Object regexp, string;
+fast_string_match_ignore_case (Lisp_Object regexp, Lisp_Object string)
{
int val;
struct re_pattern_buffer *bufp;
data. */
EMACS_INT
-fast_looking_at (regexp, pos, pos_byte, limit, limit_byte, string)
- Lisp_Object regexp;
- EMACS_INT pos, pos_byte, limit, limit_byte;
- Lisp_Object string;
+fast_looking_at (Lisp_Object regexp, EMACS_INT pos, EMACS_INT pos_byte, EMACS_INT limit, EMACS_INT limit_byte, Lisp_Object string)
{
int multibyte;
struct re_pattern_buffer *buf;
This is our cheezy way of associating an action with the change of
state of a buffer-local variable. */
static void
-newline_cache_on_off (buf)
- struct buffer *buf;
+newline_cache_on_off (struct buffer *buf)
{
if (NILP (buf->cache_long_line_scans))
{
except when inside redisplay. */
int
-scan_buffer (target, start, end, count, shortage, allow_quit)
- register int target;
- EMACS_INT start, end;
- int count;
- int *shortage;
- int allow_quit;
+scan_buffer (register int target, EMACS_INT start, EMACS_INT end, int count, int *shortage, int allow_quit)
{
struct region_cache *newline_cache;
int direction;
except in special cases. */
int
-scan_newline (start, start_byte, limit, limit_byte, count, allow_quit)
- EMACS_INT start, start_byte;
- EMACS_INT limit, limit_byte;
- register int count;
- int allow_quit;
+scan_newline (EMACS_INT start, EMACS_INT start_byte, EMACS_INT limit, EMACS_INT limit_byte, register int count, int allow_quit)
{
int direction = ((count > 0) ? 1 : -1);
}
int
-find_next_newline_no_quit (from, cnt)
- EMACS_INT from;
- int cnt;
+find_next_newline_no_quit (EMACS_INT from, int cnt)
{
return scan_buffer ('\n', from, 0, cnt, (int *) 0, 0);
}
find_next_newline (...)-1, because you might hit TO. */
int
-find_before_next_newline (from, to, cnt)
- EMACS_INT from, to;
- int cnt;
+find_before_next_newline (EMACS_INT from, EMACS_INT to, int cnt)
{
int shortage;
int pos = scan_buffer ('\n', from, to, cnt, &shortage, 1);
/* Subroutines of Lisp buffer search functions. */
static Lisp_Object
-search_command (string, bound, noerror, count, direction, RE, posix)
- Lisp_Object string, bound, noerror, count;
- int direction;
- int RE;
- int posix;
+search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror, Lisp_Object count, int direction, int RE, int posix)
{
register int np;
int lim, lim_byte;
/* Return 1 if REGEXP it matches just one constant string. */
static int
-trivial_regexp_p (regexp)
- Lisp_Object regexp;
+trivial_regexp_p (Lisp_Object regexp)
{
int len = SBYTES (regexp);
unsigned char *s = SDATA (regexp);
boyer_moore cannot work. */
static EMACS_INT
-simple_search (n, pat, len, len_byte, trt, pos, pos_byte, lim, lim_byte)
- int n;
- unsigned char *pat;
- int len, len_byte;
- Lisp_Object trt;
- EMACS_INT pos, pos_byte;
- EMACS_INT lim, lim_byte;
+simple_search (int n, unsigned char *pat, int len, int len_byte, Lisp_Object trt, EMACS_INT pos, EMACS_INT pos_byte, EMACS_INT lim, EMACS_INT lim_byte)
{
int multibyte = ! NILP (current_buffer->enable_multibyte_characters);
int forward = n > 0;
Also clear out the match data for registers 1 and up. */
static void
-set_search_regs (beg_byte, nbytes)
- EMACS_INT beg_byte, nbytes;
+set_search_regs (EMACS_INT beg_byte, EMACS_INT nbytes)
{
int i;
need not match a word boundary unless it ends in whitespace. */
static Lisp_Object
-wordify (string, lax)
- Lisp_Object string;
- int lax;
+wordify (Lisp_Object string, int lax)
{
register unsigned char *p, *o;
register int i, i_byte, len, punct_count = 0, word_count = 0;
}
\f
static Lisp_Object
-match_limit (num, beginningp)
- Lisp_Object num;
- int beginningp;
+match_limit (Lisp_Object num, int beginningp)
{
register int n;
/* Called from Flooking_at, Fstring_match, search_buffer, Fstore_match_data
if asynchronous code (filter or sentinel) is running. */
static void
-save_search_regs ()
+save_search_regs (void)
{
if (!search_regs_saved)
{
/* Called upon exit from filters and sentinels. */
void
-restore_search_regs ()
+restore_search_regs (void)
{
if (search_regs_saved)
{
}
static Lisp_Object
-unwind_set_match_data (list)
- Lisp_Object list;
+unwind_set_match_data (Lisp_Object list)
{
/* It is NOT ALWAYS safe to free (evaporate) the markers immediately. */
return Fset_match_data (list, Qt);
/* Called to unwind protect the match data. */
void
-record_unwind_save_match_data ()
+record_unwind_save_match_data (void)
{
record_unwind_protect (unwind_set_match_data,
Fmatch_data (Qnil, Qnil, Qnil));
}
\f
void
-syms_of_search ()
+syms_of_search (void)
{
register int i;
/* Like perror, but signals an error. */
static void
-sound_perror (msg)
- char *msg;
+sound_perror (char *msg)
{
int saved_errno = errno;
/* Display a warning message. */
static void
-sound_warning (msg)
- char *msg;
+sound_warning (char *msg)
{
message (msg);
}
range [0, 1]. */
static int
-parse_sound (sound, attrs)
- Lisp_Object sound;
- Lisp_Object *attrs;
+parse_sound (Lisp_Object sound, Lisp_Object *attrs)
{
/* SOUND must be a list starting with the symbol `sound'. */
if (!CONSP (sound) || !EQ (XCAR (sound), Qsound))
S is the sound file structure to fill in. */
static void
-find_sound_type (s)
- struct sound *s;
+find_sound_type (struct sound *s)
{
if (!wav_init (s) && !au_init (s))
error ("Unknown sound format");
/* Function installed by play-sound-internal with record_unwind_protect. */
static Lisp_Object
-sound_cleanup (arg)
- Lisp_Object arg;
+sound_cleanup (Lisp_Object arg)
{
if (current_sound_device->close)
current_sound_device->close (current_sound_device);
to host byte-order. */
static u_int32_t
-le2hl (value)
- u_int32_t value;
+le2hl (u_int32_t value)
{
#ifdef WORDS_BIG_ENDIAN
unsigned char *p = (unsigned char *) &value;
to host byte-order. */
static u_int16_t
-le2hs (value)
- u_int16_t value;
+le2hs (u_int16_t value)
{
#ifdef WORDS_BIG_ENDIAN
unsigned char *p = (unsigned char *) &value;
to host byte-order. */
static u_int32_t
-be2hl (value)
- u_int32_t value;
+be2hl (u_int32_t value)
{
#ifndef WORDS_BIG_ENDIAN
unsigned char *p = (unsigned char *) &value;
Value is non-zero if the file is a WAV file. */
static int
-wav_init (s)
- struct sound *s;
+wav_init (struct sound *s)
{
struct wav_header *header = (struct wav_header *) s->header;
/* Play RIFF-WAVE audio file S on sound device SD. */
static void
-wav_play (s, sd)
- struct sound *s;
- struct sound_device *sd;
+wav_play (struct sound *s, struct sound_device *sd)
{
struct wav_header *header = (struct wav_header *) s->header;
Value is non-zero if the file is an AU file. */
static int
-au_init (s)
- struct sound *s;
+au_init (struct sound *s)
{
struct au_header *header = (struct au_header *) s->header;
/* Play Sun audio file S on sound device SD. */
static void
-au_play (s, sd)
- struct sound *s;
- struct sound_device *sd;
+au_play (struct sound *s, struct sound_device *sd)
{
struct au_header *header = (struct au_header *) s->header;
otherwise use a default device name. */
static void
-vox_open (sd)
- struct sound_device *sd;
+vox_open (struct sound_device *sd)
{
char *file;
/* Configure device SD from parameters in it. */
static void
-vox_configure (sd)
- struct sound_device *sd;
+vox_configure (struct sound_device *sd)
{
int val;
/* Close device SD if it is open. */
static void
-vox_close (sd)
- struct sound_device *sd;
+vox_close (struct sound_device *sd)
{
if (sd->fd >= 0)
{
/* Choose device-dependent format for device SD from sound file S. */
static void
-vox_choose_format (sd, s)
- struct sound_device *sd;
- struct sound *s;
+vox_choose_format (struct sound_device *sd, struct sound *s)
{
if (s->type == RIFF)
{
structure. */
static int
-vox_init (sd)
- struct sound_device *sd;
+vox_init (struct sound_device *sd)
{
char *file;
int fd;
/* Write NBYTES bytes from BUFFER to device SD. */
static void
-vox_write (sd, buffer, nbytes)
- struct sound_device *sd;
- const char *buffer;
- int nbytes;
+vox_write (struct sound_device *sd, const char *buffer, int nbytes)
{
int nwritten = emacs_write (sd->fd, buffer, nbytes);
if (nwritten < 0)
/* This driver is available on GNU/Linux. */
static void
-alsa_sound_perror (msg, err)
- char *msg;
- int err;
+alsa_sound_perror (char *msg, int err)
{
error ("%s: %s", msg, snd_strerror (err));
}
otherwise use a default device name. */
static void
-alsa_open (sd)
- struct sound_device *sd;
+alsa_open (struct sound_device *sd)
{
char *file;
struct alsa_params *p;
}
static int
-alsa_period_size (sd)
- struct sound_device *sd;
+alsa_period_size (struct sound_device *sd)
{
struct alsa_params *p = (struct alsa_params *) sd->data;
int fact = snd_pcm_format_size (sd->format, 1) * sd->channels;
}
static void
-alsa_configure (sd)
- struct sound_device *sd;
+alsa_configure (struct sound_device *sd)
{
int val, err, dir;
unsigned uval;
/* Close device SD if it is open. */
static void
-alsa_close (sd)
- struct sound_device *sd;
+alsa_close (struct sound_device *sd)
{
struct alsa_params *p = (struct alsa_params *) sd->data;
if (p)
/* Choose device-dependent format for device SD from sound file S. */
static void
-alsa_choose_format (sd, s)
- struct sound_device *sd;
- struct sound *s;
+alsa_choose_format (struct sound_device *sd, struct sound *s)
{
struct alsa_params *p = (struct alsa_params *) sd->data;
if (s->type == RIFF)
/* Write NBYTES bytes from BUFFER to device SD. */
static void
-alsa_write (sd, buffer, nbytes)
- struct sound_device *sd;
- const char *buffer;
- int nbytes;
+alsa_write (struct sound_device *sd, const char *buffer, int nbytes)
{
struct alsa_params *p = (struct alsa_params *) sd->data;
}
static void
-snd_error_quiet (file, line, function, err, fmt)
- const char *file;
- int line;
- const char *function;
- int err;
- const char *fmt;
+snd_error_quiet (const char *file, int line, const char *function, int err, const char *fmt)
{
}
structure. */
static int
-alsa_init (sd)
- struct sound_device *sd;
+alsa_init (struct sound_device *sd)
{
char *file;
snd_pcm_t *handle;
***********************************************************************/
void
-syms_of_sound ()
+syms_of_sound (void)
{
QCdevice = intern_c_string(":device");
staticpro (&QCdevice);
void
-init_sound ()
+init_sound (void)
{
}
size_t len LOCALE_PARAM_PROTO);
static CHAR_T *
-memcpy_lowcase (dest, src, len LOCALE_PARAM)
- CHAR_T *dest;
- const CHAR_T *src;
- size_t len;
- LOCALE_PARAM_DECL
+memcpy_lowcase (char *dest, const char *src, size_t len)
{
while (len-- > 0)
dest[len] = TOLOWER ((UCHAR_T) src[len], loc);
size_t len LOCALE_PARAM_PROTO);
static CHAR_T *
-memcpy_uppcase (dest, src, len LOCALE_PARAM)
- CHAR_T *dest;
- const CHAR_T *src;
- size_t len;
- LOCALE_PARAM_DECL
+memcpy_uppcase (char *dest, const char *src, size_t len)
{
while (len-- > 0)
dest[len] = TOUPPER ((UCHAR_T) src[len], loc);
__inline__
#endif
static int
-iso_week_days (yday, wday)
- int yday;
- int wday;
+iso_week_days (int yday, int wday)
{
/* Add enough to the first operand of % to make it nonnegative. */
int big_enough_multiple_of_7 = (-YDAY_MINIMUM / 7 + 2) * 7;
/* For Emacs we have a separate interface which corresponds to the normal
strftime function plus the ut argument, but without the ns argument. */
size_t
-emacs_strftimeu (s, maxsize, format, tp, ut)
- char *s;
- size_t maxsize;
- const char *format;
- const struct tm *tp;
- int ut;
+emacs_strftimeu (char *s, size_t maxsize, const char *format, const struct tm *tp, int ut)
{
return my_strftime (s, maxsize, format, tp, ut, 0);
}
struct gl_state_s gl_state; /* Global state of syntax parser. */
-INTERVAL interval_of ();
+INTERVAL interval_of (int, Lisp_Object);
#define INTERVALS_AT_ONCE 10 /* 1 + max-number of intervals
to scan to property-change. */
start/end of OBJECT. */
void
-update_syntax_table (charpos, count, init, object)
- int charpos, count, init;
- Lisp_Object object;
+update_syntax_table (int charpos, int count, int init, Lisp_Object object)
{
Lisp_Object tmp_table;
int cnt = 0, invalidate = 1;
We assume that BYTEPOS is not at the end of the buffer. */
INLINE EMACS_INT
-inc_bytepos (bytepos)
- EMACS_INT bytepos;
+inc_bytepos (EMACS_INT bytepos)
{
if (NILP (current_buffer->enable_multibyte_characters))
return bytepos + 1;
We assume that BYTEPOS is not at the start of the buffer. */
INLINE EMACS_INT
-dec_bytepos (bytepos)
- EMACS_INT bytepos;
+dec_bytepos (EMACS_INT bytepos)
{
if (NILP (current_buffer->enable_multibyte_characters))
return bytepos - 1;
update the global data. */
static EMACS_INT
-find_defun_start (pos, pos_byte)
- EMACS_INT pos, pos_byte;
+find_defun_start (EMACS_INT pos, EMACS_INT pos_byte)
{
EMACS_INT opoint = PT, opoint_byte = PT_BYTE;
/* Return the SYNTAX_COMEND_FIRST of the character before POS, POS_BYTE. */
static int
-prev_char_comend_first (pos, pos_byte)
- int pos, pos_byte;
+prev_char_comend_first (int pos, int pos_byte)
{
int c, val;
the returned value (or at FROM, if the search was not successful). */
static int
-back_comment (from, from_byte, stop, comnested, comstyle, charpos_ptr, bytepos_ptr)
- EMACS_INT from, from_byte, stop;
- int comnested, comstyle;
- EMACS_INT *charpos_ptr, *bytepos_ptr;
+back_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop, int comnested, int comstyle, EMACS_INT *charpos_ptr, EMACS_INT *bytepos_ptr)
{
/* Look back, counting the parity of string-quotes,
and recording the comment-starters seen.
}
static void
-check_syntax_table (obj)
- Lisp_Object obj;
+check_syntax_table (Lisp_Object obj)
{
CHECK_TYPE (CHAR_TABLE_P (obj) && EQ (XCHAR_TABLE (obj)->purpose, Qsyntax_table),
Qsyntax_table_p, obj);
COUNT negative means scan backward and stop at word beginning. */
int
-scan_words (from, count)
- register int from, count;
+scan_words (register int from, register int count)
{
register int beg = BEGV;
register int end = ZV;
}
static Lisp_Object
-skip_chars (forwardp, string, lim, handle_iso_classes)
- int forwardp;
- Lisp_Object string, lim;
- int handle_iso_classes;
+skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_classes)
{
register unsigned int c;
unsigned char fastmap[0400];
static Lisp_Object
-skip_syntaxes (forwardp, string, lim)
- int forwardp;
- Lisp_Object string, lim;
+skip_syntaxes (int forwardp, Lisp_Object string, Lisp_Object lim)
{
register unsigned int c;
unsigned char fastmap[0400];
integer which is its type according to re_wctype. */
static int
-in_classes (c, iso_classes)
- int c;
- Lisp_Object iso_classes;
+in_classes (int c, Lisp_Object iso_classes)
{
int fits_class = 0;
? SYNTAX (c) : Ssymbol)
static Lisp_Object
-scan_lists (from, count, depth, sexpflag)
- register EMACS_INT from;
- EMACS_INT count, depth;
- int sexpflag;
+scan_lists (register EMACS_INT from, EMACS_INT count, EMACS_INT depth, int sexpflag)
{
Lisp_Object val;
register EMACS_INT stop = count > 0 ? ZV : BEGV;
}
\f
void
-init_syntax_once ()
+init_syntax_once (void)
{
register int i, c;
Lisp_Object temp;
}
void
-syms_of_syntax ()
+syms_of_syntax (void)
{
Qsyntax_table_p = intern_c_string ("syntax-table-p");
staticpro (&Qsyntax_table_p);
/* Discard pending input on all input descriptors. */
void
-discard_tty_input ()
+discard_tty_input (void)
{
#ifndef WINDOWSNT
struct emacs_tty buf;
\f
/*ARGSUSED*/
void
-set_exclusive_use (fd)
- int fd;
+set_exclusive_use (int fd)
{
#ifdef FIOCLEX
ioctl (fd, FIOCLEX, 0);
(at least for bsd). */
SIGTYPE
-wait_for_termination_signal ()
+wait_for_termination_signal (void)
{}
/* Wait for subprocess with process id `pid' to terminate and
make sure it will get eliminated (not remain forever as a zombie) */
void
-wait_for_termination (pid)
- int pid;
+wait_for_termination (int pid)
{
while (1)
{
*/
void
-flush_pending_output (channel)
- int channel;
+flush_pending_output (int channel)
{
#ifdef HAVE_TERMIOS
/* If we try this, we get hit with SIGTTIN, because
in Emacs. No padding needed for insertion into an Emacs buffer. */
void
-child_setup_tty (out)
- int out;
+child_setup_tty (int out)
{
#ifndef DOS_NT
struct emacs_tty s;
/* Suspend the Emacs process; give terminal to its superior. */
void
-sys_suspend ()
+sys_suspend (void)
{
#if defined (SIGTSTP) && !defined (MSDOS)
/* Fork a subshell. */
void
-sys_subshell ()
+sys_subshell (void)
{
#ifdef DOS_NT /* Demacs 1.1.2 91/10/20 Manabu Higashida */
int st;
}
static void
-save_signal_handlers (saved_handlers)
- struct save_signal *saved_handlers;
+save_signal_handlers (struct save_signal *saved_handlers)
{
while (saved_handlers->code)
{
}
static void
-restore_signal_handlers (saved_handlers)
- struct save_signal *saved_handlers;
+restore_signal_handlers (struct save_signal *saved_handlers)
{
while (saved_handlers->code)
{
int old_fcntl_flags[MAXDESC];
void
-init_sigio (fd)
- int fd;
+init_sigio (int fd)
{
#ifdef FASYNC
old_fcntl_flags[fd] = fcntl (fd, F_GETFL, 0) & ~FASYNC;
}
void
-reset_sigio (fd)
- int fd;
+reset_sigio (int fd)
{
#ifdef FASYNC
fcntl (fd, F_SETFL, old_fcntl_flags[fd]);
/* XXX Yeah, but you need it for SIGIO, don't you? */
void
-request_sigio ()
+request_sigio (void)
{
if (noninteractive)
return;
Return zero if all's well, or -1 if we ran into an error we
couldn't deal with. */
int
-emacs_get_tty (fd, settings)
- int fd;
- struct emacs_tty *settings;
+emacs_get_tty (int fd, struct emacs_tty *settings)
{
/* Retrieve the primary parameters - baud rate, character size, etcetera. */
#ifdef HAVE_TCATTR
Return 0 if all went well, and -1 if anything failed. */
int
-emacs_set_tty (fd, settings, flushp)
- int fd;
- struct emacs_tty *settings;
- int flushp;
+emacs_set_tty (int fd, struct emacs_tty *settings, int flushp)
{
/* Set the primary parameters - baud rate, character size, etcetera. */
#ifdef HAVE_TCATTR
/* Initialize the terminal mode on the given tty device. */
void
-init_sys_modes (tty_out)
- struct tty_display_info *tty_out;
+init_sys_modes (struct tty_display_info *tty_out)
{
struct emacs_tty tty;
to HEIGHT and WIDTH. This is used mainly with ptys. */
int
-set_window_size (fd, height, width)
- int fd, height, width;
+set_window_size (int fd, int height, int width)
{
#ifdef TIOCSWINSZ
bottom of the frame, turn off interrupt-driven I/O, etc. */
void
-reset_sys_modes (tty_out)
- struct tty_display_info *tty_out;
+reset_sys_modes (struct tty_display_info *tty_out)
{
if (noninteractive)
{
/* Set up the proper status flags for use of a pty. */
void
-setup_pty (fd)
- int fd;
+setup_pty (int fd)
{
/* I'm told that TOICREMOTE does not mean control chars
"can't be sent" but rather that they don't have
#if !(defined (__NetBSD__) && defined (__ELF__))
#ifndef HAVE_TEXT_START
char *
-start_of_text ()
+start_of_text (void)
{
#ifdef TEXT_START
return ((char *) TEXT_START);
#ifndef start_of_data
char *
-start_of_data ()
+start_of_data (void)
{
#ifdef DATA_START
return ((char *) DATA_START);
#endif /* TRY_AGAIN */
void
-init_system_name ()
+init_system_name (void)
{
#ifndef HAVE_GETHOSTNAME
struct utsname uts;
#endif
void
-init_signals ()
+init_signals (void)
{
sigemptyset (&empty_mask);
sigfillset (&full_mask);
#endif /* !RAND_BITS */
void
-seed_random (arg)
- long arg;
+seed_random (long int arg)
{
#ifdef HAVE_RANDOM
srandom ((unsigned int)arg);
* This suffices even for a 64-bit architecture with a 15-bit rand.
*/
long
-get_random ()
+get_random (void)
{
long val = random ();
#if VALBITS > RAND_BITS
#endif /* ! HAVE_STRERROR */
\f
int
-emacs_open (path, oflag, mode)
- const char *path;
- int oflag, mode;
+emacs_open (const char *path, int oflag, int mode)
{
register int rtnval;
}
int
-emacs_close (fd)
- int fd;
+emacs_close (int fd)
{
int did_retry = 0;
register int rtnval;
}
int
-emacs_read (fildes, buf, nbyte)
- int fildes;
- char *buf;
- unsigned int nbyte;
+emacs_read (int fildes, char *buf, unsigned int nbyte)
{
register int rtnval;
}
int
-emacs_write (fildes, buf, nbyte)
- int fildes;
- const char *buf;
- unsigned int nbyte;
+emacs_write (int fildes, const char *buf, unsigned int nbyte)
{
register int rtnval, bytes_written;
*/
void
-croak (badfunc)
- char *badfunc;
+croak (char *badfunc)
{
printf ("%s not yet implemented\r\n", badfunc);
reset_all_sys_modes ();
\f
int
-set_file_times (filename, atime, mtime)
- const char *filename;
- EMACS_TIME atime, mtime;
+set_file_times (const char *filename, struct timeval atime, struct timeval mtime)
{
#ifdef HAVE_UTIMES
struct timeval tv[2];
/* Process enumeration and access via /proc. */
Lisp_Object
-list_system_processes ()
+list_system_processes (void)
{
Lisp_Object procdir, match, proclist, next;
struct gcpro gcpro1, gcpro2;
for tgetnum, tgetflag and tgetstr to find. */
static char *term_entry;
-static char *tgetst1 ();
+static char *tgetst1 (char *ptr, char **area);
/* Search entry BP for capability CAP.
Return a pointer to the capability (in BP) if found,
0 if not found. */
static char *
-find_capability (bp, cap)
- register char *bp, *cap;
+find_capability (register char *bp, register char *cap)
{
for (; *bp; bp++)
if (bp[0] == ':'
}
int
-tgetnum (cap)
- char *cap;
+tgetnum (char *cap)
{
register char *ptr = find_capability (term_entry, cap);
if (!ptr || ptr[-1] != '#')
}
int
-tgetflag (cap)
- char *cap;
+tgetflag (char *cap)
{
register char *ptr = find_capability (term_entry, cap);
return ptr && ptr[-1] == ':';
If AREA is null, space is allocated with `malloc'. */
char *
-tgetstr (cap, area)
- char *cap;
- char **area;
+tgetstr (char *cap, char **area)
{
register char *ptr = find_capability (term_entry, cap);
if (!ptr || (ptr[-1] != '=' && ptr[-1] != '~'))
or NULL if PTR is NULL. */
static char *
-tgetst1 (ptr, area)
- char *ptr;
- char **area;
+tgetst1 (char *ptr, char **area)
{
register char *p, *r;
register int c;
#endif /* not emacs */
void
-tputs (str, nlines, outfun)
- register char *str;
- int nlines;
- register int (*outfun) ();
+tputs (register char *str, int nlines, register int (*outfun) (/* ??? */))
{
register int padcount = 0;
register int speed;
/* Forward declarations of static functions. */
-static int scan_file ();
-static char *gobble_line ();
-static int compare_contin ();
-static int name_match ();
+static int scan_file (char *str, int fd, register struct termcap_buffer *bufp);
+static char *gobble_line (int fd, register struct termcap_buffer *bufp, char *append_end);
+static int compare_contin (register char *str1, register char *str2);
+static int name_match (char *line, char *name);
#ifdef MSDOS /* MW, May 1993 */
static int
in it, and some other value otherwise. */
int
-tgetent (bp, name)
- char *bp, *name;
+tgetent (char *bp, char *name)
{
register char *termcap_name;
register int fd;
or 0 if no entry is found in the file. */
static int
-scan_file (str, fd, bufp)
- char *str;
- int fd;
- register struct termcap_buffer *bufp;
+scan_file (char *str, int fd, register struct termcap_buffer *bufp)
{
register char *end;
by termcap entry LINE. */
static int
-name_match (line, name)
- char *line, *name;
+name_match (char *line, char *name)
{
register char *tem;
}
static int
-compare_contin (str1, str2)
- register char *str1, *str2;
+compare_contin (register char *str1, register char *str2)
{
register int c1, c2;
while (1)
thing as one line. The caller decides when a line is continued. */
static char *
-gobble_line (fd, bufp, append_end)
- int fd;
- register struct termcap_buffer *bufp;
- char *append_end;
+gobble_line (int fd, register struct termcap_buffer *bufp, char *append_end)
{
register char *end;
register int nread;
\f
/* Return the value of terminal parameter PARAM in terminal T. */
Lisp_Object
-get_terminal_param (t, param)
- struct terminal *t;
- Lisp_Object param;
+get_terminal_param (struct terminal *t, Lisp_Object param)
{
Lisp_Object tem = Fassq (param, t->param_alist);
if (EQ (tem, Qnil))
Return the previous value. */
Lisp_Object
-store_terminal_param (t, parameter, value)
- struct terminal *t;
- Lisp_Object parameter;
- Lisp_Object value;
+store_terminal_param (struct terminal *t, Lisp_Object parameter, Lisp_Object value)
{
Lisp_Object old_alist_elt = Fassq (parameter, t->param_alist);
if (EQ (old_alist_elt, Qnil))
}
void
-syms_of_terminal ()
+syms_of_terminal (void)
{
DEFVAR_LISP ("ring-bell-function", &Vring_bell_function,
*/
char *
-tparam (string, outstring, len, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
- char *string;
- char *outstring;
- int len, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9;
+tparam (char *string, char *outstring, int len, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9)
{
char *temp;
- extern char *tparm();
+ extern char *tparm(/* ??? */);
temp = tparm (string, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
if (outstring == 0)
to capture that error in GDB by putting a breakpoint on it. */
static void
-text_read_only (propval)
- Lisp_Object propval;
+text_read_only (Lisp_Object propval)
{
if (STRINGP (propval))
xsignal1 (Qtext_read_only, propval);
#define hard 1
INTERVAL
-validate_interval_range (object, begin, end, force)
- Lisp_Object object, *begin, *end;
- int force;
+validate_interval_range (Lisp_Object object, Lisp_Object *begin, Lisp_Object *end, int force)
{
register INTERVAL i;
int searchpos;
is even numbered and thus suitable as a plist. */
static Lisp_Object
-validate_plist (list)
- Lisp_Object list;
+validate_plist (Lisp_Object list)
{
if (NILP (list))
return Qnil;
with the same values, of list PLIST. */
static int
-interval_has_all_properties (plist, i)
- Lisp_Object plist;
- INTERVAL i;
+interval_has_all_properties (Lisp_Object plist, INTERVAL i)
{
register Lisp_Object tail1, tail2, sym1;
register int found;
properties of PLIST, regardless of their values. */
static INLINE int
-interval_has_some_properties (plist, i)
- Lisp_Object plist;
- INTERVAL i;
+interval_has_some_properties (Lisp_Object plist, INTERVAL i)
{
register Lisp_Object tail1, tail2, sym;
property names in LIST, regardless of their values. */
static INLINE int
-interval_has_some_properties_list (list, i)
- Lisp_Object list;
- INTERVAL i;
+interval_has_some_properties_list (Lisp_Object list, INTERVAL i)
{
register Lisp_Object tail1, tail2, sym;
/* Return the value of PROP in property-list PLIST, or Qunbound if it
has none. */
static Lisp_Object
-property_value (plist, prop)
- Lisp_Object plist, prop;
+property_value (Lisp_Object plist, Lisp_Object prop)
{
Lisp_Object value;
OBJECT is the string or buffer that INTERVAL belongs to. */
static void
-set_properties (properties, interval, object)
- Lisp_Object properties, object;
- INTERVAL interval;
+set_properties (Lisp_Object properties, INTERVAL interval, Lisp_Object object)
{
Lisp_Object sym, value;
are actually added to I's plist) */
static int
-add_properties (plist, i, object)
- Lisp_Object plist;
- INTERVAL i;
- Lisp_Object object;
+add_properties (Lisp_Object plist, INTERVAL i, Lisp_Object object)
{
Lisp_Object tail1, tail2, sym1, val1;
register int changed = 0;
OBJECT is the string or buffer containing I. */
static int
-remove_properties (plist, list, i, object)
- Lisp_Object plist, list;
- INTERVAL i;
- Lisp_Object object;
+remove_properties (Lisp_Object plist, Lisp_Object list, INTERVAL i, Lisp_Object object)
{
register Lisp_Object tail1, tail2, sym, current_plist;
register int changed = 0;
POSITION is BEG-based. */
INTERVAL
-interval_of (position, object)
- int position;
- Lisp_Object object;
+interval_of (int position, Lisp_Object object)
{
register INTERVAL i;
int beg, end;
window-specific overlays are considered only if they are associated
with OBJECT. */
Lisp_Object
-get_char_property_and_overlay (position, prop, object, overlay)
- Lisp_Object position, object;
- register Lisp_Object prop;
- Lisp_Object *overlay;
+get_char_property_and_overlay (Lisp_Object position, register Lisp_Object prop, Lisp_Object object, Lisp_Object *overlay)
{
struct window *w = 0;
/* Return 1 if there's a change in some property between BEG and END. */
int
-property_change_between_p (beg, end)
- int beg, end;
+property_change_between_p (int beg, int end)
{
register INTERVAL i, next;
Lisp_Object object, pos;
otherwise. */
Lisp_Object
-set_text_properties (start, end, properties, object, coherent_change_p)
- Lisp_Object start, end, properties, object, coherent_change_p;
+set_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object object, Lisp_Object coherent_change_p)
{
register INTERVAL i;
Lisp_Object ostart, oend;
START and END can be in any order. */
void
-set_text_properties_1 (start, end, properties, buffer, i)
- Lisp_Object start, end, properties, buffer;
- INTERVAL i;
+set_text_properties_1 (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object buffer, INTERVAL i)
{
register INTERVAL prev_changed = NULL_INTERVAL;
register int s, len;
BUFFER can be either a buffer or nil (meaning current buffer). */
int
-text_property_stickiness (prop, pos, buffer)
- Lisp_Object prop, pos, buffer;
+text_property_stickiness (Lisp_Object prop, Lisp_Object pos, Lisp_Object buffer)
{
Lisp_Object prev_pos, front_sticky;
int is_rear_sticky = 1, is_front_sticky = 0; /* defaults */
/* Note this can GC when DEST is a buffer. */
Lisp_Object
-copy_text_properties (start, end, src, pos, dest, prop)
- Lisp_Object start, end, src, pos, dest, prop;
+copy_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object src, Lisp_Object pos, Lisp_Object dest, Lisp_Object prop)
{
INTERVAL i;
Lisp_Object res;
doesn't contain text properties between START and END. */
Lisp_Object
-text_property_list (object, start, end, prop)
- Lisp_Object object, start, end, prop;
+text_property_list (Lisp_Object object, Lisp_Object start, Lisp_Object end, Lisp_Object prop)
{
struct interval *i;
Lisp_Object result;
non-zero if OBJECT was modified. */
int
-add_text_properties_from_list (object, list, delta)
- Lisp_Object object, list, delta;
+add_text_properties_from_list (Lisp_Object object, Lisp_Object list, Lisp_Object delta)
{
struct gcpro gcpro1, gcpro2;
int modified_p = 0;
end-points to NEW_END. */
Lisp_Object
-extend_property_ranges (list, new_end)
- Lisp_Object list, new_end;
+extend_property_ranges (Lisp_Object list, Lisp_Object new_end)
{
Lisp_Object prev = Qnil, head = list;
int max = XINT (new_end);
/* Call the modification hook functions in LIST, each with START and END. */
static void
-call_mod_hooks (list, start, end)
- Lisp_Object list, start, end;
+call_mod_hooks (Lisp_Object list, Lisp_Object start, Lisp_Object end)
{
struct gcpro gcpro1;
GCPRO1 (list);
those hooks in order, with START and END - 1 as arguments. */
void
-verify_interval_modification (buf, start, end)
- struct buffer *buf;
- int start, end;
+verify_interval_modification (struct buffer *buf, int start, int end)
{
register INTERVAL intervals = BUF_INTERVALS (buf);
register INTERVAL i;
so it can indicate the range of inserted text. */
void
-report_interval_modification (start, end)
- Lisp_Object start, end;
+report_interval_modification (Lisp_Object start, Lisp_Object end)
{
if (! NILP (interval_insert_behind_hooks))
call_mod_hooks (interval_insert_behind_hooks, start, end);
}
\f
void
-syms_of_textprop ()
+syms_of_textprop (void)
{
DEFVAR_LISP ("default-text-properties", &Vdefault_text_properties,
doc: /* Property-list used as default values.
The fourth and following args to tparam serve as the parameter values. */
-static char *tparam1 ();
+static char *tparam1 (char *string, char *outstring, int len, char *up, char *left, register int *argp);
/* VARARGS 2 */
char *
-tparam (string, outstring, len, arg0, arg1, arg2, arg3)
- char *string;
- char *outstring;
- int len;
- int arg0, arg1, arg2, arg3;
+tparam (char *string, char *outstring, int len, int arg0, int arg1, int arg2, int arg3)
{
int arg[4];
static char tgoto_buf[50];
char *
-tgoto (cm, hpos, vpos)
- char *cm;
- int hpos, vpos;
+tgoto (char *cm, int hpos, int vpos)
{
int args[2];
if (!cm)
}
static char *
-tparam1 (string, outstring, len, up, left, argp)
- char *string;
- char *outstring;
- int len;
- char *up, *left;
- register int *argp;
+tparam1 (char *string, char *outstring, int len, char *up, char *left, register int *argp)
{
register int c;
register char *p = string;
undo record that will be added just after this command terminates. */
static void
-record_point (pt)
- int pt;
+record_point (int pt)
{
int at_boundary;
because we don't need to record the contents.) */
void
-record_insert (beg, length)
- int beg, length;
+record_insert (int beg, int length)
{
Lisp_Object lbeg, lend;
of the characters in STRING, at location BEG. */
void
-record_delete (beg, string)
- int beg;
- Lisp_Object string;
+record_delete (int beg, Lisp_Object string)
{
Lisp_Object sbeg;
won't be inverted automatically by undoing the buffer modification. */
void
-record_marker_adjustment (marker, adjustment)
- Lisp_Object marker;
- int adjustment;
+record_marker_adjustment (Lisp_Object marker, int adjustment)
{
if (EQ (current_buffer->undo_list, Qt))
return;
The replacement must not change the number of characters. */
void
-record_change (beg, length)
- int beg, length;
+record_change (int beg, int length)
{
record_delete (beg, make_buffer_string (beg, beg + length, 1));
record_insert (beg, length);
we can tell whether it is obsolete because the file was saved again. */
void
-record_first_change ()
+record_first_change (void)
{
Lisp_Object high, low;
struct buffer *base_buffer = current_buffer;
for LENGTH characters starting at position BEG in BUFFER. */
void
-record_property_change (beg, length, prop, value, buffer)
- int beg, length;
- Lisp_Object prop, value, buffer;
+record_property_change (int beg, int length, Lisp_Object prop, Lisp_Object value, Lisp_Object buffer)
{
Lisp_Object lbeg, lend, entry;
struct buffer *obuf = current_buffer, *buf = XBUFFER (buffer);
In some cases this works by calling undo-outer-limit-function. */
void
-truncate_undo_list (b)
- struct buffer *b;
+truncate_undo_list (struct buffer *b)
{
Lisp_Object list;
Lisp_Object prev, next, last_boundary;
}
\f
void
-syms_of_undo ()
+syms_of_undo (void)
{
Qinhibit_read_only = intern_c_string ("inhibit-read-only");
staticpro (&Qinhibit_read_only);
/* Round X up to a multiple of Y. */
static ElfW(Addr)
-round_up (x, y)
- ElfW(Addr) x, y;
+round_up (Elf32_Addr x, Elf32_Addr y)
{
int rem = x % y;
if (rem == 0)
if NOERROR is 0; we return -1 if NOERROR is nonzero. */
static int
-find_section (name, section_names, file_name, old_file_h, old_section_h, noerror)
- char *name;
- char *section_names;
- char *file_name;
- ElfW(Ehdr) *old_file_h;
- ElfW(Shdr) *old_section_h;
- int noerror;
+find_section (char *name, char *section_names, char *file_name, Elf32_Ehdr *old_file_h, Elf32_Shdr *old_section_h, int noerror)
{
int idx;
*
*/
void
-unexec (new_name, old_name, data_start, bss_start, entry_address)
- char *new_name, *old_name;
- unsigned data_start, bss_start, entry_address;
+unexec (char *new_name, char *old_name, unsigned int data_start, unsigned int bss_start, unsigned int entry_address)
{
int new_file, old_file, new_file_size;
}
Lisp_Object
-make_window ()
+make_window (void)
{
Lisp_Object val;
register struct window *p;
\f
static struct window *
-decode_window (window)
- register Lisp_Object window;
+decode_window (register Lisp_Object window)
{
if (NILP (window))
return XWINDOW (selected_window);
}
static struct window *
-decode_any_window (window)
- register Lisp_Object window;
+decode_any_window (register Lisp_Object window)
{
if (NILP (window))
return XWINDOW (selected_window);
X and Y are frame relative pixel coordinates. */
static enum window_part
-coordinates_in_window (w, x, y)
- register struct window *w;
- register int *x, *y;
+coordinates_in_window (register struct window *w, register int *x, register int *y)
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
int left_x, right_x, top_y, bottom_y;
};
static int
-check_window_containing (w, user_data)
- struct window *w;
- void *user_data;
+check_window_containing (struct window *w, void *user_data)
{
struct check_window_data *cw = (struct check_window_data *) user_data;
enum window_part found;
case. */
Lisp_Object
-window_from_coordinates (f, x, y, part, wx, wy, tool_bar_p)
- struct frame *f;
- int x, y;
- enum window_part *part;
- int *wx, *wy;
- int tool_bar_p;
+window_from_coordinates (struct frame *f, int x, int y, enum window_part *part, int *wx, int *wy, int tool_bar_p)
{
Lisp_Object window;
struct check_window_data cw;
return 0. */
struct Lisp_Char_Table *
-window_display_table (w)
- struct window *w;
+window_display_table (struct window *w)
{
struct Lisp_Char_Table *dp = NULL;
/* Record info on buffer window w is displaying
when it is about to cease to display that buffer. */
static void
-unshow_buffer (w)
- register struct window *w;
+unshow_buffer (register struct window *w)
{
Lisp_Object buf;
struct buffer *b;
/* Put replacement into the window structure in place of old. */
static void
-replace_window (old, replacement)
- Lisp_Object old, replacement;
+replace_window (Lisp_Object old, Lisp_Object replacement)
{
register Lisp_Object tem;
register struct window *o = XWINDOW (old), *p = XWINDOW (replacement);
}
void
-delete_window (window)
- register Lisp_Object window;
+delete_window (register Lisp_Object window)
{
register Lisp_Object tem, parent, sib;
register struct window *p;
function window_list. */
static int
-add_window_to_list (w, user_data)
- struct window *w;
- void *user_data;
+add_window_to_list (struct window *w, void *user_data)
{
Lisp_Object *list = (Lisp_Object *) user_data;
Lisp_Object window;
list, cache it in Vwindow_list, and return that. */
static Lisp_Object
-window_list ()
+window_list (void)
{
if (!CONSP (Vwindow_list))
{
a frame means consider windows on that frame, only. */
static int
-candidate_window_p (window, owindow, minibuf, all_frames)
- Lisp_Object window, owindow, minibuf, all_frames;
+candidate_window_p (Lisp_Object window, Lisp_Object owindow, Lisp_Object minibuf, Lisp_Object all_frames)
{
struct window *w = XWINDOW (window);
struct frame *f = XFRAME (w->frame);
ALL_FRAMES. */
static void
-decode_next_window_args (window, minibuf, all_frames)
- Lisp_Object *window, *minibuf, *all_frames;
+decode_next_window_args (Lisp_Object *window, Lisp_Object *minibuf, Lisp_Object *all_frames)
{
if (NILP (*window))
*window = selected_window;
ALL_FRAMES. */
static Lisp_Object
-next_window (window, minibuf, all_frames, next_p)
- Lisp_Object window, minibuf, all_frames;
- int next_p;
+next_window (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames, int next_p)
{
decode_next_window_args (&window, &minibuf, &all_frames);
for `next-window'. */
static Lisp_Object
-window_list_1 (window, minibuf, all_frames)
- Lisp_Object window, minibuf, all_frames;
+window_list_1 (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames)
{
Lisp_Object tail, list, rest;
};
static Lisp_Object
-window_loop (type, obj, mini, frames)
- enum window_loop type;
- Lisp_Object obj, frames;
- int mini;
+window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frames)
{
Lisp_Object window, windows, best_window, frame_arg;
struct frame *f;
/* Used for debugging. Abort if any window has a dead buffer. */
void
-check_all_windows ()
+check_all_windows (void)
{
window_loop (CHECK_ALL_WINDOWS, Qnil, 1, Qt);
}
of all frames, even those on other keyboards. */
void
-replace_buffer_in_all_windows (buffer)
- Lisp_Object buffer;
+replace_buffer_in_all_windows (Lisp_Object buffer)
{
Lisp_Object tail, frame;
minimum allowable size. */
void
-check_frame_size (frame, rows, cols)
- FRAME_PTR frame;
- int *rows, *cols;
+check_frame_size (FRAME_PTR frame, int *rows, int *cols)
{
/* For height, we have to see:
how many windows the frame has at minimum (one or two),
either. */
static int
-window_fixed_size_p (w, width_p, check_siblings_p)
- struct window *w;
- int width_p, check_siblings_p;
+window_fixed_size_p (struct window *w, int width_p, int check_siblings_p)
{
int fixed_p;
struct window *c;
minibuffer window, always return 1. */
static int
-window_min_size_2 (w, width_p, safe_p)
- struct window *w;
- int width_p, safe_p;
+window_min_size_2 (struct window *w, int width_p, int safe_p)
{
/* We should consider buffer-local values of window_min_height and
window_min_width here. */
sizes of W's children. */
static int
-window_min_size_1 (w, width_p, safe_p)
- struct window *w;
- int width_p, safe_p;
+window_min_size_1 (struct window *w, int width_p, int safe_p)
{
struct window *c;
int size;
to 1 if W is fixed-size unless FIXED is null. */
static int
-window_min_size (w, width_p, safe_p, ignore_fixed_p, fixed)
- struct window *w;
- int width_p, safe_p, ignore_fixed_p, *fixed;
+window_min_size (struct window *w, int width_p, int safe_p, int ignore_fixed_p, int *fixed)
{
int size, fixed_p;
is still too narrow. */
static int
-adjust_window_margins (w)
- struct window *w;
+adjust_window_margins (struct window *w)
{
int box_cols = (WINDOW_TOTAL_COLS (w)
- WINDOW_FRINGE_COLS (w)
This should give better behavior when resizing frames. */
static void
-size_window (window, size, width_p, nodelete_p, first_only, last_only)
- Lisp_Object window;
- int size, width_p, nodelete_p;
- int first_only, last_only;
+size_window (Lisp_Object window, int size, int width_p, int nodelete_p, int first_only, int last_only)
{
struct window *w = XWINDOW (window);
struct window *c;
displayed correctly. */
void
-set_window_height (window, height, nodelete)
- Lisp_Object window;
- int height;
- int nodelete;
+set_window_height (Lisp_Object window, int height, int nodelete)
{
size_window (window, height, 0, nodelete, 0, 0);
}
displayed correctly. */
void
-set_window_width (window, width, nodelete)
- Lisp_Object window;
- int width;
- int nodelete;
+set_window_width (Lisp_Object window, int width, int nodelete)
{
size_window (window, width, 1, nodelete, 0, 0);
}
/* Change window heights in windows rooted in WINDOW by N lines. */
void
-change_window_heights (window, n)
- Lisp_Object window;
- int n;
+change_window_heights (Lisp_Object window, int n)
{
struct window *w = XWINDOW (window);
reset from the buffer's local settings. */
void
-set_window_buffer (window, buffer, run_hooks_p, keep_margins_p)
- Lisp_Object window, buffer;
- int run_hooks_p, keep_margins_p;
+set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int keep_margins_p)
{
struct window *w = XWINDOW (window);
struct buffer *b = XBUFFER (buffer);
}
static Lisp_Object
-select_window_norecord (window)
- Lisp_Object window;
+select_window_norecord (Lisp_Object window)
{
return WINDOW_LIVE_P (window)
? Fselect_window (window, Qt) : selected_window;
}
static Lisp_Object
-select_frame_norecord (frame)
- Lisp_Object frame;
+select_frame_norecord (Lisp_Object frame)
{
return FRAME_LIVE_P (XFRAME (frame))
? Fselect_frame (frame, Qt) : selected_frame;
}
\f
Lisp_Object
-display_buffer (buffer, not_this_window_p, override_frame)
- Lisp_Object buffer, not_this_window_p, override_frame;
+display_buffer (Lisp_Object buffer, Lisp_Object not_this_window_p, Lisp_Object override_frame)
{
return call3 (Qdisplay_buffer, buffer, not_this_window_p, override_frame);
}
void
-temp_output_buffer_show (buf)
- register Lisp_Object buf;
+temp_output_buffer_show (register Lisp_Object buf)
{
register struct buffer *old = current_buffer;
register Lisp_Object window;
}
\f
static void
-make_dummy_parent (window)
- Lisp_Object window;
+make_dummy_parent (Lisp_Object window)
{
Lisp_Object new;
register struct window *o, *p;
}
int
-window_height (window)
- Lisp_Object window;
+window_height (Lisp_Object window)
{
register struct window *p = XWINDOW (window);
return WINDOW_TOTAL_LINES (p);
}
int
-window_width (window)
- Lisp_Object window;
+window_width (Lisp_Object window)
{
register struct window *p = XWINDOW (window);
return WINDOW_TOTAL_COLS (p);
deleted. */
static void
-enlarge_window (window, delta, horiz_flag)
- Lisp_Object window;
- int delta, horiz_flag;
+enlarge_window (Lisp_Object window, int delta, int horiz_flag)
{
Lisp_Object parent, next, prev;
struct window *p;
are not deleted; instead, we signal an error. */
static void
-adjust_window_trailing_edge (window, delta, horiz_flag)
- Lisp_Object window;
- int delta, horiz_flag;
+adjust_window_trailing_edge (Lisp_Object window, int delta, int horiz_flag)
{
Lisp_Object parent, child;
struct window *p;
from lowest windows first. */
static void
-shrink_window_lowest_first (w, height)
- struct window *w;
- int height;
+shrink_window_lowest_first (struct window *w, int height)
{
struct window *c;
Lisp_Object child;
stored in orig_top_line and orig_total_lines for all windows. */
static int
-save_restore_orig_size (w, action)
- struct window *w;
- enum save_restore_action action;
+save_restore_orig_size (struct window *w, enum save_restore_action action)
{
int success_p = 1;
without deleting other windows. */
void
-grow_mini_window (w, delta)
- struct window *w;
- int delta;
+grow_mini_window (struct window *w, int delta)
{
struct frame *f = XFRAME (w->frame);
struct window *root;
line. */
void
-shrink_mini_window (w)
- struct window *w;
+shrink_mini_window (struct window *w)
{
struct frame *f = XFRAME (w->frame);
struct window *root = XWINDOW (FRAME_ROOT_WINDOW (f));
the frame are cleared. */
void
-mark_window_cursors_off (w)
- struct window *w;
+mark_window_cursors_off (struct window *w)
{
while (w)
{
/* Return number of lines of text (not counting mode lines) in W. */
int
-window_internal_height (w)
- struct window *w;
+window_internal_height (struct window *w)
{
int ht = XFASTINT (w->total_lines);
separating W from the sibling to its right. */
int
-window_box_text_cols (w)
- struct window *w;
+window_box_text_cols (struct window *w)
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
int width = XINT (w->total_cols);
respectively. */
static void
-window_scroll (window, n, whole, noerror)
- Lisp_Object window;
- int n;
- int whole;
- int noerror;
+window_scroll (Lisp_Object window, int n, int whole, int noerror)
{
immediate_quit = 1;
descriptions. */
static void
-window_scroll_pixel_based (window, n, whole, noerror)
- Lisp_Object window;
- int n;
- int whole;
- int noerror;
+window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
{
struct it it;
struct window *w = XWINDOW (window);
See the comment of window_scroll for parameter descriptions. */
static void
-window_scroll_line_based (window, n, whole, noerror)
- Lisp_Object window;
- int n;
- int whole;
- int noerror;
+window_scroll_line_based (Lisp_Object window, int n, int whole, int noerror)
{
register struct window *w = XWINDOW (window);
register int opoint = PT, opoint_byte = PT_BYTE;
up. This is the guts of Fscroll_up and Fscroll_down. */
static void
-scroll_command (n, direction)
- Lisp_Object n;
- int direction;
+scroll_command (Lisp_Object n, int direction)
{
int count = SPECPDL_INDEX ();
as opposed to its height. */
static int
-displayed_window_lines (w)
- struct window *w;
+displayed_window_lines (struct window *w)
{
struct it it;
struct text_pos start;
by setting their buffers to nil. */
void
-delete_all_subwindows (w)
- register struct window *w;
+delete_all_subwindows (register struct window *w)
{
if (!NILP (w->next))
delete_all_subwindows (XWINDOW (w->next));
}
\f
static int
-count_windows (window)
- register struct window *window;
+count_windows (register struct window *window)
{
register int count = 1;
if (!NILP (window->next))
Value is last index + 1. */
static int
-get_leaf_windows (w, flat, i)
- struct window *w;
- struct window **flat;
- int i;
+get_leaf_windows (struct window *w, struct window **flat, int i)
{
while (w)
{
can be returned. */
struct glyph *
-get_phys_cursor_glyph (w)
- struct window *w;
+get_phys_cursor_glyph (struct window *w)
{
struct glyph_row *row;
struct glyph *glyph;
static int
-save_window_save (window, vector, i)
- Lisp_Object window;
- struct Lisp_Vector *vector;
- int i;
+save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
{
register struct saved_window *p;
register struct window *w;
***********************************************************************/
static Lisp_Object
-window_tree (w)
- struct window *w;
+window_tree (struct window *w)
{
Lisp_Object tail = Qnil;
Lisp_Object result = Qnil;
additional argument USER_DATA. Stops when FN returns 0. */
void
-foreach_window (f, fn, user_data)
- struct frame *f;
- int (* fn) (struct window *, void *);
- void *user_data;
+foreach_window (struct frame *f, int (*fn) (struct window *, void *), void *user_data)
{
/* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
if (WINDOWP (FRAME_ROOT_WINDOW (f)))
Stop when FN returns 0. Value is 0 if stopped by FN. */
static int
-foreach_window_1 (w, fn, user_data)
- struct window *w;
- int (* fn) (struct window *, void *);
- void *user_data;
+foreach_window_1 (struct window *w, int (*fn) (struct window *, void *), void *user_data)
{
int cont;
the window start. */
static int
-freeze_window_start (w, freeze_p)
- struct window *w;
- void *freeze_p;
+freeze_window_start (struct window *w, void *freeze_p)
{
if (MINI_WINDOW_P (w)
|| (WINDOWP (selected_window) /* Can be nil in corner cases. */
means freeze the window start. */
void
-freeze_window_starts (f, freeze_p)
- struct frame *f;
- int freeze_p;
+freeze_window_starts (struct frame *f, int freeze_p)
{
foreach_window (f, freeze_window_start, (void *) (freeze_p ? f : 0));
}
describe the same state of affairs. This is used by Fequal. */
int
-compare_window_configurations (c1, c2, ignore_positions)
- Lisp_Object c1, c2;
- int ignore_positions;
+compare_window_configurations (Lisp_Object c1, Lisp_Object c2, int ignore_positions)
{
register struct save_window_data *d1, *d2;
struct Lisp_Vector *sw1, *sw2;
}
\f
void
-init_window_once ()
+init_window_once (void)
{
struct frame *f = make_initial_frame ();
XSETFRAME (selected_frame, f);
}
void
-init_window ()
+init_window (void)
{
Vwindow_list = Qnil;
}
void
-syms_of_window ()
+syms_of_window (void)
{
Qscroll_up = intern_c_string ("scroll-up");
staticpro (&Qscroll_up);
}
void
-keys_of_window ()
+keys_of_window (void)
{
initial_define_key (control_x_map, '1', "delete-other-windows");
initial_define_key (control_x_map, '2', "split-window");
is called. */
void
-x_free_colors (f, pixels, npixels)
- struct frame *f;
- unsigned long *pixels;
- int npixels;
+x_free_colors (struct frame *f, long unsigned int *pixels, int npixels)
{
int class = FRAME_X_DISPLAY_INFO (f)->visual->class;
is called. */
void
-x_free_dpy_colors (dpy, screen, cmap, pixels, npixels)
- Display *dpy;
- Screen *screen;
- Colormap cmap;
- unsigned long *pixels;
- int npixels;
+x_free_dpy_colors (Display *dpy, Screen *screen, Colormap cmap, long unsigned int *pixels, int npixels)
{
struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
int class = dpyinfo->visual->class;
are given by XGCV and MASK. */
static INLINE GC
-x_create_gc (f, mask, xgcv)
- struct frame *f;
- unsigned long mask;
- XGCValues *xgcv;
+x_create_gc (struct frame *f, long unsigned int mask, XGCValues *xgcv)
{
GC gc;
BLOCK_INPUT;
/* Free GC which was used on frame F. */
static INLINE void
-x_free_gc (f, gc)
- struct frame *f;
- GC gc;
+x_free_gc (struct frame *f, GC gc)
{
eassert (interrupt_input_blocked);
IF_DEBUG (xassert (--ngcs >= 0));
are in ISO8859-1. */
int
-xstrcasecmp (s1, s2)
- const unsigned char *s1, *s2;
+xstrcasecmp (const unsigned char *s1, const unsigned char *s2)
{
while (*s1 && *s2)
{
Lisp function definitions. */
static INLINE struct frame *
-frame_or_selected_frame (frame, nparam)
- Lisp_Object frame;
- int nparam;
+frame_or_selected_frame (Lisp_Object frame, int nparam)
{
if (NILP (frame))
frame = selected_frame;
/* Initialize face cache and basic faces for frame F. */
void
-init_frame_faces (f)
- struct frame *f;
+init_frame_faces (struct frame *f)
{
/* Make a face cache, if F doesn't have one. */
if (FRAME_FACE_CACHE (f) == NULL)
/* Free face cache of frame F. Called from delete_frame. */
void
-free_frame_faces (f)
- struct frame *f;
+free_frame_faces (struct frame *f)
{
struct face_cache *face_cache = FRAME_FACE_CACHE (f);
of named faces. */
void
-recompute_basic_faces (f)
- struct frame *f;
+recompute_basic_faces (struct frame *f)
{
if (FRAME_FACE_CACHE (f))
{
try to free unused fonts, too. */
void
-clear_face_cache (clear_fonts_p)
- int clear_fonts_p;
+clear_face_cache (int clear_fonts_p)
{
#ifdef HAVE_WINDOW_SYSTEM
Lisp_Object tail, frame;
if these pointers are not null. */
static int
-load_pixmap (f, name, w_ptr, h_ptr)
- FRAME_PTR f;
- Lisp_Object name;
- unsigned int *w_ptr, *h_ptr;
+load_pixmap (FRAME_PTR f, Lisp_Object name, unsigned int *w_ptr, unsigned int *h_ptr)
{
int bitmap_id;
Return 0 if there's a problem with RGB_LIST, otherwise return 1. */
static int
-parse_rgb_list (rgb_list, color)
- Lisp_Object rgb_list;
- XColor *color;
+parse_rgb_list (Lisp_Object rgb_list, XColor *color)
{
#define PARSE_RGB_LIST_FIELD(field) \
if (CONSP (rgb_list) && INTEGERP (XCAR (rgb_list))) \
returned in it. */
static int
-tty_lookup_color (f, color, tty_color, std_color)
- struct frame *f;
- Lisp_Object color;
- XColor *tty_color, *std_color;
+tty_lookup_color (struct frame *f, Lisp_Object color, XColor *tty_color, XColor *std_color)
{
Lisp_Object frame, color_desc;
/* A version of defined_color for non-X frames. */
int
-tty_defined_color (f, color_name, color_def, alloc)
- struct frame *f;
- char *color_name;
- XColor *color_def;
- int alloc;
+tty_defined_color (struct frame *f, char *color_name, XColor *color_def, int alloc)
{
int status = 1;
This does the right thing for any type of frame. */
int
-defined_color (f, color_name, color_def, alloc)
- struct frame *f;
- char *color_name;
- XColor *color_def;
- int alloc;
+defined_color (struct frame *f, char *color_name, XColor *color_def, int alloc)
{
if (!FRAME_WINDOW_P (f))
return tty_defined_color (f, color_name, color_def, alloc);
Lisp string. */
Lisp_Object
-tty_color_name (f, idx)
- struct frame *f;
- int idx;
+tty_color_name (struct frame *f, int idx)
{
if (idx >= 0 && !NILP (Ffboundp (Qtty_color_by_index)))
{
The criterion implemented here is not a terribly sophisticated one. */
static int
-face_color_gray_p (f, color_name)
- struct frame *f;
- char *color_name;
+face_color_gray_p (struct frame *f, char *color_name)
{
XColor color;
int gray_p;
color. */
static int
-face_color_supported_p (f, color_name, background_p)
- struct frame *f;
- char *color_name;
- int background_p;
+face_color_supported_p (struct frame *f, char *color_name, int background_p)
{
Lisp_Object frame;
XColor not_used;
these colors. */
unsigned long
-load_color (f, face, name, target_index)
- struct frame *f;
- struct face *face;
- Lisp_Object name;
- enum lface_attribute_index target_index;
+load_color (struct frame *f, struct face *face, Lisp_Object name, enum lface_attribute_index target_index)
{
XColor color;
try to emulate gray colors with a stipple from Vface_default_stipple. */
static void
-load_face_colors (f, face, attrs)
- struct frame *f;
- struct face *face;
- Lisp_Object *attrs;
+load_face_colors (struct frame *f, struct face *face, Lisp_Object *attrs)
{
Lisp_Object fg, bg;
/* Free color PIXEL on frame F. */
void
-unload_color (f, pixel)
- struct frame *f;
- unsigned long pixel;
+unload_color (struct frame *f, long unsigned int pixel)
{
#ifdef HAVE_X_WINDOWS
if (pixel != -1)
/* Free colors allocated for FACE. */
static void
-free_face_colors (f, face)
- struct frame *f;
- struct face *face;
+free_face_colors (struct frame *f, struct face *face)
{
/* PENDING(NS): need to do something here? */
#ifdef HAVE_X_WINDOWS
static enum font_property_index font_props_for_sorting[FONT_SIZE_INDEX];
static int
-compare_fonts_by_sort_order (v1, v2)
- const void *v1, *v2;
+compare_fonts_by_sort_order (const void *v1, const void *v2)
{
Lisp_Object font1 = *(Lisp_Object *) v1;
Lisp_Object font2 = *(Lisp_Object *) v2;
Return default face in case of errors. */
static Lisp_Object
-resolve_face_name (face_name, signal_p)
- Lisp_Object face_name;
- int signal_p;
+resolve_face_name (Lisp_Object face_name, int signal_p)
{
Lisp_Object orig_face;
Lisp_Object tortoise, hare;
signal an error if FACE_NAME is not a valid face name. If SIGNAL_P
is zero, value is nil if FACE_NAME is not a valid face name. */
static INLINE Lisp_Object
-lface_from_face_name_no_resolve (f, face_name, signal_p)
- struct frame *f;
- Lisp_Object face_name;
- int signal_p;
+lface_from_face_name_no_resolve (struct frame *f, Lisp_Object face_name, int signal_p)
{
Lisp_Object lface;
If SIGNAL_P is zero, value is nil if FACE_NAME is not a valid face
name. */
static INLINE Lisp_Object
-lface_from_face_name (f, face_name, signal_p)
- struct frame *f;
- Lisp_Object face_name;
- int signal_p;
+lface_from_face_name (struct frame *f, Lisp_Object face_name, int signal_p)
{
face_name = resolve_face_name (face_name, signal_p);
return lface_from_face_name_no_resolve (f, face_name, signal_p);
Otherwise, value is zero if FACE_NAME is not a face. */
static INLINE int
-get_lface_attributes_no_remap (f, face_name, attrs, signal_p)
- struct frame *f;
- Lisp_Object face_name;
- Lisp_Object *attrs;
- int signal_p;
+get_lface_attributes_no_remap (struct frame *f, Lisp_Object face_name, Lisp_Object *attrs, int signal_p)
{
Lisp_Object lface;
Otherwise, value is zero if FACE_NAME is not a face. */
static INLINE int
-get_lface_attributes (f, face_name, attrs, signal_p, named_merge_points)
- struct frame *f;
- Lisp_Object face_name;
- Lisp_Object *attrs;
- int signal_p;
- struct named_merge_point *named_merge_points;
+get_lface_attributes (struct frame *f, Lisp_Object face_name, Lisp_Object *attrs, int signal_p, struct named_merge_point *named_merge_points)
{
Lisp_Object face_remapping;
specified, i.e. are non-nil. */
static int
-lface_fully_specified_p (attrs)
- Lisp_Object *attrs;
+lface_fully_specified_p (Lisp_Object *attrs)
{
int i;
of FORCE_P. */
static int
-set_lface_from_font (f, lface, font_object, force_p)
- struct frame *f;
- Lisp_Object lface, font_object;
- int force_p;
+set_lface_from_font (struct frame *f, Lisp_Object lface, Lisp_Object font_object, int force_p)
{
Lisp_Object val;
struct font *font = XFONT_OBJECT (font_object);
unless both FROM and TO are relative. */
Lisp_Object
-merge_face_heights (from, to, invalid)
- Lisp_Object from, to, invalid;
+merge_face_heights (Lisp_Object from, Lisp_Object to, Lisp_Object invalid)
{
Lisp_Object result = invalid;
other places. */
static INLINE void
-merge_face_vectors (f, from, to, named_merge_points)
- struct frame *f;
- Lisp_Object *from, *to;
- struct named_merge_point *named_merge_points;
+merge_face_vectors (struct frame *f, Lisp_Object *from, Lisp_Object *to, struct named_merge_point *named_merge_points)
{
int i;
merging succeeded. */
static int
-merge_named_face (f, face_name, to, named_merge_points)
- struct frame *f;
- Lisp_Object face_name;
- Lisp_Object *to;
- struct named_merge_point *named_merge_points;
+merge_named_face (struct frame *f, Lisp_Object face_name, Lisp_Object *to, struct named_merge_point *named_merge_points)
{
struct named_merge_point named_merge_point;
specifications. */
static int
-merge_face_ref (f, face_ref, to, err_msgs, named_merge_points)
- struct frame *f;
- Lisp_Object face_ref;
- Lisp_Object *to;
- int err_msgs;
- struct named_merge_point *named_merge_points;
+merge_face_ref (struct frame *f, Lisp_Object face_ref, Lisp_Object *to, int err_msgs, struct named_merge_point *named_merge_points)
{
int ok = 1; /* Succeed without an error? */
has been assigned the value NEW_VALUE. */
void
-update_face_from_frame_parameter (f, param, new_value)
- struct frame *f;
- Lisp_Object param, new_value;
+update_face_from_frame_parameter (struct frame *f, Lisp_Object param, Lisp_Object new_value)
{
Lisp_Object face = Qnil;
Lisp_Object lface;
font-object set in `default' face attributes LFACE. */
static void
-set_font_frame_param (frame, lface)
- Lisp_Object frame, lface;
+set_font_frame_param (Lisp_Object frame, Lisp_Object lface)
{
struct frame *f = XFRAME (frame);
Lisp_Object font;
error; if SIGNAL_P is zero, return 0. */
static Lisp_Object
-face_boolean_x_resource_value (value, signal_p)
- Lisp_Object value;
- int signal_p;
+face_boolean_x_resource_value (Lisp_Object value, int signal_p)
{
Lisp_Object result = make_number (0);
is called quite often. */
static INLINE int
-face_attr_equal_p (v1, v2)
- Lisp_Object v1, v2;
+face_attr_equal_p (Lisp_Object v1, Lisp_Object v2)
{
/* Type can differ, e.g. when one attribute is unspecified, i.e. nil,
and the other is specified. */
is called quite often. */
static INLINE int
-lface_equal_p (v1, v2)
- Lisp_Object *v1, *v2;
+lface_equal_p (Lisp_Object *v1, Lisp_Object *v2)
{
int i, equal_p = 1;
below in computing a hash value for a Lisp face. */
static INLINE unsigned
-hash_string_case_insensitive (string)
- Lisp_Object string;
+hash_string_case_insensitive (Lisp_Object string)
{
const unsigned char *s;
unsigned hash = 0;
/* Return a hash code for face attribute vector V. */
static INLINE unsigned
-lface_hash (v)
- Lisp_Object *v;
+lface_hash (Lisp_Object *v)
{
return (hash_string_case_insensitive (v[LFACE_FAMILY_INDEX])
^ hash_string_case_insensitive (v[LFACE_FOUNDRY_INDEX])
LFACE1 and LFACE2 must be fully-specified. */
static INLINE int
-lface_same_font_attributes_p (lface1, lface2)
- Lisp_Object *lface1, *lface2;
+lface_same_font_attributes_p (Lisp_Object *lface1, Lisp_Object *lface2)
{
xassert (lface_fully_specified_p (lface1)
&& lface_fully_specified_p (lface2));
vector ATTR. */
static struct face *
-make_realized_face (attr)
- Lisp_Object *attr;
+make_realized_face (Lisp_Object *attr)
{
struct face *face = (struct face *) xmalloc (sizeof *face);
bzero (face, sizeof *face);
be null. */
void
-free_realized_face (f, face)
- struct frame *f;
- struct face *face;
+free_realized_face (struct frame *f, struct face *face)
{
if (face)
{
by clearing the face cache. */
void
-prepare_face_for_display (f, face)
- struct frame *f;
- struct face *face;
+prepare_face_for_display (struct frame *f, struct face *face)
{
#ifdef HAVE_WINDOW_SYSTEM
xassert (FRAME_WINDOW_P (f));
/* Returns the `distance' between the colors X and Y. */
static int
-color_distance (x, y)
- XColor *x, *y;
+color_distance (XColor *x, XColor *y)
{
/* This formula is from a paper title `Colour metric' by Thiadmer Riemersma.
Quoting from that paper:
/* Return a new face cache for frame F. */
static struct face_cache *
-make_face_cache (f)
- struct frame *f;
+make_face_cache (struct frame *f)
{
struct face_cache *c;
int size;
keeping too many graphics contexts that are no longer needed. */
static void
-clear_face_gcs (c)
- struct face_cache *c;
+clear_face_gcs (struct face_cache *c)
{
if (c && FRAME_WINDOW_P (c->f))
{
event doesn't try to use faces we destroyed. */
static void
-free_realized_faces (c)
- struct face_cache *c;
+free_realized_faces (struct face_cache *c)
{
if (c && c->used)
{
/* Free all realized faces that are using FONTSET on frame F. */
void
-free_realized_faces_for_fontset (f, fontset)
- struct frame *f;
- int fontset;
+free_realized_faces_for_fontset (struct frame *f, int fontset)
{
struct face_cache *cache = FRAME_FACE_CACHE (f);
struct face *face;
because we can't tell which realized faces depend on that face. */
void
-free_all_realized_faces (frame)
- Lisp_Object frame;
+free_all_realized_faces (Lisp_Object frame)
{
if (NILP (frame))
{
/* Free face cache C and faces in it, including their X resources. */
static void
-free_face_cache (c)
- struct face_cache *c;
+free_face_cache (struct face_cache *c)
{
if (c)
{
that a requested face is not cached. */
static void
-cache_face (c, face, hash)
- struct face_cache *c;
- struct face *face;
- unsigned hash;
+cache_face (struct face_cache *c, struct face *face, unsigned int hash)
{
int i = hash % FACE_CACHE_BUCKETS_SIZE;
/* Remove face FACE from cache C. */
static void
-uncache_face (c, face)
- struct face_cache *c;
- struct face *face;
+uncache_face (struct face_cache *c, struct face *face)
{
int i = face->hash % FACE_CACHE_BUCKETS_SIZE;
realize a new one. */
INLINE int
-lookup_face (f, attr)
- struct frame *f;
- Lisp_Object *attr;
+lookup_face (struct frame *f, Lisp_Object *attr)
{
struct face_cache *cache = FRAME_FACE_CACHE (f);
unsigned hash;
suitable face is found, realize a new one. */
int
-face_for_font (f, font_object, base_face)
- struct frame *f;
- Lisp_Object font_object;
- struct face *base_face;
+face_for_font (struct frame *f, Lisp_Object font_object, struct face *base_face)
{
struct face_cache *cache = FRAME_FACE_CACHE (f);
unsigned hash;
face isn't realized and cannot be realized. */
int
-lookup_named_face (f, symbol, signal_p)
- struct frame *f;
- Lisp_Object symbol;
- int signal_p;
+lookup_named_face (struct frame *f, Lisp_Object symbol, int signal_p)
{
Lisp_Object attrs[LFACE_VECTOR_SIZE];
Lisp_Object symbol_attrs[LFACE_VECTOR_SIZE];
rather than signal an error. */
int
-lookup_basic_face (f, face_id)
- struct frame *f;
- int face_id;
+lookup_basic_face (struct frame *f, int face_id)
{
Lisp_Object name, mapping;
int remapped_face_id;
LFACE_ID on frame F. Value is -1 if LFACE_ID isn't valid. */
int
-ascii_face_of_lisp_face (f, lface_id)
- struct frame *f;
- int lface_id;
+ascii_face_of_lisp_face (struct frame *f, int lface_id)
{
int face_id;
STEPS < 0 means larger. Value is the id of the face. */
int
-smaller_face (f, face_id, steps)
- struct frame *f;
- int face_id, steps;
+smaller_face (struct frame *f, int face_id, int steps)
{
#ifdef HAVE_WINDOW_SYSTEM
struct face *face;
FACE_ID on frame F, but has height HEIGHT. */
int
-face_with_height (f, face_id, height)
- struct frame *f;
- int face_id;
- int height;
+face_with_height (struct frame *f, int face_id, int height)
{
#ifdef HAVE_WINDOW_SYSTEM
struct face *face;
default face. FACE_ID is assumed to be already realized. */
int
-lookup_derived_face (f, symbol, face_id, signal_p)
- struct frame *f;
- Lisp_Object symbol;
- int face_id;
- int signal_p;
+lookup_derived_face (struct frame *f, Lisp_Object symbol, int face_id, int signal_p)
{
Lisp_Object attrs[LFACE_VECTOR_SIZE];
Lisp_Object symbol_attrs[LFACE_VECTOR_SIZE];
\(2) `close in spirit' to what the attributes specify, if not exact. */
static int
-x_supports_face_attributes_p (f, attrs, def_face)
- struct frame *f;
- Lisp_Object *attrs;
- struct face *def_face;
+x_supports_face_attributes_p (struct frame *f, Lisp_Object *attrs, struct face *def_face)
{
Lisp_Object *def_attrs = def_face->lface;
substitution of a `dim' face for italic. */
static int
-tty_supports_face_attributes_p (f, attrs, def_face)
- struct frame *f;
- Lisp_Object *attrs;
- struct face *def_face;
+tty_supports_face_attributes_p (struct frame *f, Lisp_Object *attrs, struct face *def_face)
{
int weight;
Lisp_Object val, fg, bg;
attribute of ATTRS doesn't name a fontset. */
static int
-face_fontset (attrs)
- Lisp_Object *attrs;
+face_fontset (Lisp_Object *attrs)
{
Lisp_Object name;
face. */
static int
-realize_basic_faces (f)
- struct frame *f;
+realize_basic_faces (struct frame *f)
{
int success_p = 0;
int count = SPECPDL_INDEX ();
that are not explicitly specified are taken from frame parameters. */
static int
-realize_default_face (f)
- struct frame *f;
+realize_default_face (struct frame *f)
{
struct face_cache *c = FRAME_FACE_CACHE (f);
Lisp_Object lface;
have. The default face must have been realized already. */
static void
-realize_named_face (f, symbol, id)
- struct frame *f;
- Lisp_Object symbol;
- int id;
+realize_named_face (struct frame *f, Lisp_Object symbol, int id)
{
struct face_cache *c = FRAME_FACE_CACHE (f);
Lisp_Object lface = lface_from_face_name (f, symbol, 0);
face. Value is a pointer to the newly created realized face. */
static struct face *
-realize_face (cache, attrs, former_face_id)
- struct face_cache *cache;
- Lisp_Object *attrs;
- int former_face_id;
+realize_face (struct face_cache *cache, Lisp_Object *attrs, int former_face_id)
{
struct face *face;
no-font. */
static struct face *
-realize_non_ascii_face (f, font_object, base_face)
- struct frame *f;
- Lisp_Object font_object;
- struct face *base_face;
+realize_non_ascii_face (struct frame *f, Lisp_Object font_object, struct face *base_face)
{
struct face_cache *cache = FRAME_FACE_CACHE (f);
struct face *face;
created realized face. */
static struct face *
-realize_x_face (cache, attrs)
- struct face_cache *cache;
- Lisp_Object *attrs;
+realize_x_face (struct face_cache *cache, Lisp_Object *attrs)
{
struct face *face = NULL;
#ifdef HAVE_WINDOW_SYSTEM
default foreground/background colors. */
static void
-map_tty_color (f, face, idx, defaulted)
- struct frame *f;
- struct face *face;
- enum lface_attribute_index idx;
- int *defaulted;
+map_tty_color (struct frame *f, struct face *face, enum lface_attribute_index idx, int *defaulted)
{
Lisp_Object frame, color, def;
int foreground_p = idx == LFACE_FOREGROUND_INDEX;
Value is a pointer to the newly created realized face. */
static struct face *
-realize_tty_face (cache, attrs)
- struct face_cache *cache;
- Lisp_Object *attrs;
+realize_tty_face (struct face_cache *cache, Lisp_Object *attrs)
{
struct face *face;
int weight, slant;
property PROP on frame F in current_buffer. */
int
-compute_char_face (f, ch, prop)
- struct frame *f;
- int ch;
- Lisp_Object prop;
+compute_char_face (struct frame *f, int ch, Lisp_Object prop)
{
int face_id;
*/
int
-merge_faces (f, face_name, face_id, base_face_id)
- struct frame *f;
- Lisp_Object face_name;
- int face_id, base_face_id;
+merge_faces (struct frame *f, Lisp_Object face_name, int face_id, int base_face_id)
{
Lisp_Object attrs[LFACE_VECTOR_SIZE];
struct face *base_face;
***********************************************************************/
void
-syms_of_xfaces ()
+syms_of_xfaces (void)
{
Qface = intern_c_string ("face");
staticpro (&Qface);
/* Error if we are not connected to X. */
void
-check_x ()
+check_x (void)
{
if (! x_in_use)
error ("X windows are not in use or not initialized");
You should not call this unless HAVE_MENUS is defined. */
int
-have_menus_p ()
+have_menus_p (void)
{
return x_in_use;
}
and checking validity for X. */
FRAME_PTR
-check_x_frame (frame)
- Lisp_Object frame;
+check_x_frame (Lisp_Object frame)
{
FRAME_PTR f;
the first X display on the list. */
struct x_display_info *
-check_x_display_info (object)
- Lisp_Object object;
+check_x_display_info (Lisp_Object object)
{
struct x_display_info *dpyinfo = NULL;
/* This function can be called during GC, so use GC_xxx type test macros. */
struct frame *
-x_window_to_frame (dpyinfo, wdesc)
- struct x_display_info *dpyinfo;
- int wdesc;
+x_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
{
Lisp_Object tail, frame;
struct frame *f;
windows. */
struct frame *
-x_any_window_to_frame (dpyinfo, wdesc)
- struct x_display_info *dpyinfo;
- int wdesc;
+x_any_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
{
Lisp_Object tail, frame;
struct frame *f, *found;
/* Likewise, but consider only the menu bar widget. */
struct frame *
-x_menubar_window_to_frame (dpyinfo, wdesc)
- struct x_display_info *dpyinfo;
- int wdesc;
+x_menubar_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
{
Lisp_Object tail, frame;
struct frame *f;
If WDESC is some other (smaller) window, we return 0. */
struct frame *
-x_top_window_to_frame (dpyinfo, wdesc)
- struct x_display_info *dpyinfo;
- int wdesc;
+x_top_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
{
Lisp_Object tail, frame;
struct frame *f;
not Emacs's own window. */
void
-x_real_positions (f, xptr, yptr)
- FRAME_PTR f;
- int *xptr, *yptr;
+x_real_positions (FRAME_PTR f, int *xptr, int *yptr)
{
int win_x, win_y, outer_x, outer_y;
int real_x = 0, real_y = 0;
/* Gamma-correct COLOR on frame F. */
void
-gamma_correct (f, color)
- struct frame *f;
- XColor *color;
+gamma_correct (struct frame *f, XColor *color)
{
if (f->gamma)
{
no color could be allocated. */
int
-x_defined_color (f, color_name, color, alloc_p)
- struct frame *f;
- char *color_name;
- XColor *color;
- int alloc_p;
+x_defined_color (struct frame *f, char *color_name, XColor *color, int alloc_p)
{
int success_p;
Display *dpy = FRAME_X_DISPLAY (f);
Signal an error if color can't be allocated. */
int
-x_decode_color (f, color_name, mono_color)
- FRAME_PTR f;
- Lisp_Object color_name;
- int mono_color;
+x_decode_color (FRAME_PTR f, Lisp_Object color_name, int mono_color)
{
XColor cdef;
See also the comment of wait_for_wm in struct x_output. */
static void
-x_set_wait_for_wm (f, new_value, old_value)
- struct frame *f;
- Lisp_Object new_value, old_value;
+x_set_wait_for_wm (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
{
f->output_data.x->wait_for_wm = !NILP (new_value);
}
may be any format that GdkPixbuf knows about, i.e. not just bitmaps. */
int
-xg_set_icon (f, file)
- FRAME_PTR f;
- Lisp_Object file;
+xg_set_icon (FRAME_PTR f, Lisp_Object file)
{
int result = 0;
Lisp_Object found;
}
int
-xg_set_icon_from_xpm_data (f, data)
- FRAME_PTR f;
- char **data;
+xg_set_icon_from_xpm_data (FRAME_PTR f, char **data)
{
int result = 0;
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) data);
in the standard place; do not attempt to change the window. */
void
-x_set_foreground_color (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_foreground_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
struct x_output *x = f->output_data.x;
unsigned long fg, old_fg;
}
void
-x_set_background_color (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_background_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
struct x_output *x = f->output_data.x;
unsigned long bg;
}
static Cursor
-make_invisible_cursor (f)
- struct frame *f;
+make_invisible_cursor (struct frame *f)
{
Display *dpy = FRAME_X_DISPLAY (f);
static char const no_data[] = { 0 };
}
void
-x_set_mouse_color (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
struct x_output *x = f->output_data.x;
Display *dpy = FRAME_X_DISPLAY (f);
}
void
-x_set_cursor_color (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_cursor_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
unsigned long fore_pixel, pixel;
int fore_pixel_allocated_p = 0, pixel_allocated_p = 0;
F has an x-window. */
void
-x_set_border_pixel (f, pix)
- struct frame *f;
- int pix;
+x_set_border_pixel (struct frame *f, int pix)
{
unload_color (f, f->output_data.x->border_pixel);
f->output_data.x->border_pixel = pix;
and so emacs' border colors may be overridden. */
void
-x_set_border_color (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_border_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
int pix;
void
-x_set_cursor_type (f, arg, oldval)
- FRAME_PTR f;
- Lisp_Object arg, oldval;
+x_set_cursor_type (FRAME_PTR f, Lisp_Object arg, Lisp_Object oldval)
{
set_frame_cursor_types (f, arg);
}
\f
void
-x_set_icon_type (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_icon_type (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
int result;
}
void
-x_set_icon_name (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_icon_name (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
int result;
\f
void
-x_set_menu_bar_lines (f, value, oldval)
- struct frame *f;
- Lisp_Object value, oldval;
+x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
{
int nlines;
#if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
The frame's height doesn't change. */
void
-x_set_tool_bar_lines (f, value, oldval)
- struct frame *f;
- Lisp_Object value, oldval;
+x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
{
int delta, nlines, root_height;
Lisp_Object root_window;
the frame parameter. */
void
-x_set_scroll_bar_foreground (f, value, oldval)
- struct frame *f;
- Lisp_Object value, oldval;
+x_set_scroll_bar_foreground (struct frame *f, Lisp_Object value, Lisp_Object oldval)
{
unsigned long pixel;
parameter. */
void
-x_set_scroll_bar_background (f, value, oldval)
- struct frame *f;
- Lisp_Object value, oldval;
+x_set_scroll_bar_background (struct frame *f, Lisp_Object value, Lisp_Object oldval)
{
unsigned long pixel;
the result should be `COMPOUND_TEXT'. */
static unsigned char *
-x_encode_text (string, coding_system, selectionp, text_bytes, stringp, freep)
- Lisp_Object string, coding_system;
- int *text_bytes, *stringp;
- int selectionp;
- int *freep;
+x_encode_text (Lisp_Object string, Lisp_Object coding_system, int selectionp, int *text_bytes, int *stringp, int *freep)
{
int result = string_xstring_p (string);
struct coding_system coding;
icon name to NAME. */
static void
-x_set_name_internal (f, name)
- FRAME_PTR f;
- Lisp_Object name;
+x_set_name_internal (FRAME_PTR f, Lisp_Object name)
{
if (FRAME_X_WINDOW (f))
{
F->explicit_name is set, ignore the new name; otherwise, set it. */
void
-x_set_name (f, name, explicit)
- struct frame *f;
- Lisp_Object name;
- int explicit;
+x_set_name (struct frame *f, Lisp_Object name, int explicit)
{
/* Make sure that requests from lisp code override requests from
Emacs redisplay code. */
specified a name for the frame; the name will override any set by the
redisplay code. */
void
-x_explicitly_set_name (f, arg, oldval)
- FRAME_PTR f;
- Lisp_Object arg, oldval;
+x_explicitly_set_name (FRAME_PTR f, Lisp_Object arg, Lisp_Object oldval)
{
x_set_name (f, arg, 1);
}
name; names set this way will never override names set by the user's
lisp code. */
void
-x_implicitly_set_name (f, arg, oldval)
- FRAME_PTR f;
- Lisp_Object arg, oldval;
+x_implicitly_set_name (FRAME_PTR f, Lisp_Object arg, Lisp_Object oldval)
{
x_set_name (f, arg, 0);
}
If NAME is nil, use the frame name as the title. */
void
-x_set_title (f, name, old_name)
- struct frame *f;
- Lisp_Object name, old_name;
+x_set_title (struct frame *f, Lisp_Object name, Lisp_Object old_name)
{
/* Don't change the title if it's already NAME. */
if (EQ (name, f->title))
}
void
-x_set_scroll_bar_default_width (f)
- struct frame *f;
+x_set_scroll_bar_default_width (struct frame *f)
{
int wid = FRAME_COLUMN_WIDTH (f);
/* Create an Xt fontset spec from the name of a base font.
If `motif' is True use the Motif syntax. */
char *
-xic_create_fontsetname (base_fontname, motif)
- char *base_fontname;
- Bool motif;
+xic_create_fontsetname (char *base_fontname, int motif)
{
const char *sep = motif ? ";" : ",";
char *fontsetname;
#endif
static XFontSet
-xic_create_xfontset (f)
- struct frame *f;
+xic_create_xfontset (struct frame *f)
{
XFontSet xfs = NULL;
struct font *font = FRAME_FONT (f);
/* Free the X fontset of frame F if it is the last frame using it. */
void
-xic_free_xfontset (f)
- struct frame *f;
+xic_free_xfontset (struct frame *f)
{
Lisp_Object rest, frame;
int shared_p = 0;
input method XIM. */
static XIMStyle
-best_xim_style (user, xim)
- XIMStyles *user;
- XIMStyles *xim;
+best_xim_style (XIMStyles *user, XIMStyles *xim)
{
int i, j;
static XIMStyle xic_style;
void
-create_frame_xic (f)
- struct frame *f;
+create_frame_xic (struct frame *f)
{
XIM xim;
XIC xic = NULL;
/* Destroy XIC and free XIC fontset of frame F, if any. */
void
-free_frame_xic (f)
- struct frame *f;
+free_frame_xic (struct frame *f)
{
if (FRAME_XIC (f) == NULL)
return;
pixel position X/Y. X and Y are relative to window W. */
void
-xic_set_preeditarea (w, x, y)
- struct window *w;
- int x, y;
+xic_set_preeditarea (struct window *w, int x, int y)
{
struct frame *f = XFRAME (w->frame);
XVaNestedList attr;
/* Place status area for XIC in bottom right corner of frame F.. */
void
-xic_set_statusarea (f)
- struct frame *f;
+xic_set_statusarea (struct frame *f)
{
XIC xic = FRAME_XIC (f);
XVaNestedList attr;
BASE_FONTNAME. Called when a new Emacs fontset is chosen. */
void
-xic_set_xfontset (f, base_fontname)
- struct frame *f;
- char *base_fontname;
+xic_set_xfontset (struct frame *f, char *base_fontname)
{
XVaNestedList attr;
XFontSet xfs;
#else /* not USE_X_TOOLKIT */
#ifdef USE_GTK
void
-x_window (f)
- FRAME_PTR f;
+x_window (FRAME_PTR f)
{
if (! xg_create_frame_widgets (f))
error ("Unable to create window");
/* Verify that the icon position args for this window are valid. */
static void
-x_icon_verify (f, parms)
- struct frame *f;
- Lisp_Object parms;
+x_icon_verify (struct frame *f, Lisp_Object parms)
{
Lisp_Object icon_x, icon_y;
well. */
static void
-x_icon (f, parms)
- struct frame *f;
- Lisp_Object parms;
+x_icon (struct frame *f, Lisp_Object parms)
{
Lisp_Object icon_x, icon_y;
#if 0
mouse cursor and the gray border tile. */
static void
-x_make_gc (f)
- struct frame *f;
+x_make_gc (struct frame *f)
{
XGCValues gc_values;
/* Free what was allocated in x_make_gc. */
void
-x_free_gcs (f)
- struct frame *f;
+x_free_gcs (struct frame *f)
{
Display *dpy = FRAME_X_DISPLAY (f);
constructed. */
static Lisp_Object
-unwind_create_frame (frame)
- Lisp_Object frame;
+unwind_create_frame (Lisp_Object frame)
{
struct frame *f = XFRAME (frame);
static void
-x_default_font_parameter (f, parms)
- struct frame *f;
- Lisp_Object parms;
+x_default_font_parameter (struct frame *f, Lisp_Object parms)
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
Lisp_Object font_param = x_get_arg (dpyinfo, parms, Qfont, NULL, NULL,
know about that structure. */
Lisp_Object
-x_get_focus_frame (frame)
- struct frame *frame;
+x_get_focus_frame (struct frame *frame)
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (frame);
Lisp_Object xfocus;
}
\f
int
-x_pixel_width (f)
- register struct frame *f;
+x_pixel_width (register struct frame *f)
{
return FRAME_PIXEL_WIDTH (f);
}
int
-x_pixel_height (f)
- register struct frame *f;
+x_pixel_height (register struct frame *f)
{
return FRAME_PIXEL_HEIGHT (f);
}
int
-x_char_width (f)
- register struct frame *f;
+x_char_width (register struct frame *f)
{
return FRAME_COLUMN_WIDTH (f);
}
int
-x_char_height (f)
- register struct frame *f;
+x_char_height (register struct frame *f)
{
return FRAME_LINE_HEIGHT (f);
}
int
-x_screen_planes (f)
- register struct frame *f;
+x_screen_planes (register struct frame *f)
{
return FRAME_X_DISPLAY_INFO (f)->n_planes;
}
members of DPYINFO appropriately. Called from x_term_init. */
void
-select_visual (dpyinfo)
- struct x_display_info *dpyinfo;
+select_visual (struct x_display_info *dpyinfo)
{
Display *dpy = dpyinfo->display;
Screen *screen = dpyinfo->screen;
Open a new connection if necessary. */
struct x_display_info *
-x_display_info_for_name (name)
- Lisp_Object name;
+x_display_info_for_name (Lisp_Object name)
{
Lisp_Object names;
struct x_display_info *dpyinfo;
/* Wait for responses to all X commands issued so far for frame F. */
void
-x_sync (f)
- FRAME_PTR f;
+x_sync (FRAME_PTR f)
{
BLOCK_INPUT;
XSync (FRAME_X_DISPLAY (f), False);
shown on the frames. */
void
-show_hourglass (timer)
- struct atimer *timer;
+show_hourglass (struct atimer *timer)
{
/* The timer implementation will cancel this timer automatically
after this function has run. Set hourglass_atimer to null
shown. */
void
-hide_hourglass ()
+hide_hourglass (void)
{
if (hourglass_shown_p)
{
static Lisp_Object
-unwind_create_tip_frame (frame)
- Lisp_Object frame;
+unwind_create_tip_frame (Lisp_Object frame)
{
Lisp_Object deleted;
when this happens. */
static Lisp_Object
-x_create_tip_frame (dpyinfo, parms, text)
- struct x_display_info *dpyinfo;
- Lisp_Object parms, text;
+x_create_tip_frame (struct x_display_info *dpyinfo, Lisp_Object parms, Lisp_Object text)
{
struct frame *f;
Lisp_Object frame, tem;
the display in *ROOT_X, and *ROOT_Y. */
static void
-compute_tip_xy (f, parms, dx, dy, width, height, root_x, root_y)
- struct frame *f;
- Lisp_Object parms, dx, dy;
- int width, height;
- int *root_x, *root_y;
+compute_tip_xy (struct frame *f, Lisp_Object parms, Lisp_Object dx, Lisp_Object dy, int width, int height, int *root_x, int *root_y)
{
Lisp_Object left, top;
int win_x, win_y;
#ifdef USE_GTK
static Lisp_Object
-clean_up_dialog (arg)
- Lisp_Object arg;
+clean_up_dialog (Lisp_Object arg)
{
x_menu_set_in_use (0);
};
void
-syms_of_xfns ()
+syms_of_xfns (void)
{
/* This is zero if not using X windows. */
x_in_use = 0;
is not contained in the font. */
static XCharStruct *
-xfont_get_pcm (xfont, char2b)
- XFontStruct *xfont;
- XChar2b *char2b;
+xfont_get_pcm (XFontStruct *xfont, XChar2b *char2b)
{
/* The result metric information. */
XCharStruct *pcm = NULL;
extern Lisp_Object QCname;
static Lisp_Object
-xfont_get_cache (f)
- FRAME_PTR f;
+xfont_get_cache (FRAME_PTR f)
{
Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
}
static Lisp_Object
-xfont_list (frame, spec)
- Lisp_Object frame, spec;
+xfont_list (Lisp_Object frame, Lisp_Object spec)
{
FRAME_PTR f = XFRAME (frame);
Display *display = FRAME_X_DISPLAY_INFO (f)->display;
}
static Lisp_Object
-xfont_match (frame, spec)
- Lisp_Object frame, spec;
+xfont_match (Lisp_Object frame, Lisp_Object spec)
{
FRAME_PTR f = XFRAME (frame);
Display *display = FRAME_X_DISPLAY_INFO (f)->display;
}
static Lisp_Object
-xfont_list_family (frame)
- Lisp_Object frame;
+xfont_list_family (Lisp_Object frame)
{
FRAME_PTR f = XFRAME (frame);
Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
extern Lisp_Object QCavgwidth;
static Lisp_Object
-xfont_open (f, entity, pixel_size)
- FRAME_PTR f;
- Lisp_Object entity;
- int pixel_size;
+xfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
{
Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
Display *display = dpyinfo->display;
}
static void
-xfont_close (f, font)
- FRAME_PTR f;
- struct font *font;
+xfont_close (FRAME_PTR f, struct font *font)
{
BLOCK_INPUT;
XFreeFont (FRAME_X_DISPLAY (f), ((struct xfont_info *) font)->xfont);
}
static int
-xfont_prepare_face (f, face)
- FRAME_PTR f;
- struct face *face;
+xfont_prepare_face (FRAME_PTR f, struct face *face)
{
BLOCK_INPUT;
XSetFont (FRAME_X_DISPLAY (f), face->gc,
}
static int
-xfont_has_char (font, c)
- Lisp_Object font;
- int c;
+xfont_has_char (Lisp_Object font, int c)
{
Lisp_Object registry = AREF (font, FONT_REGISTRY_INDEX);
struct charset *encoding;
}
static unsigned
-xfont_encode_char (font, c)
- struct font *font;
- int c;
+xfont_encode_char (struct font *font, int c)
{
XFontStruct *xfont = ((struct xfont_info *) font)->xfont;
struct charset *charset;
}
static int
-xfont_text_extents (font, code, nglyphs, metrics)
- struct font *font;
- unsigned *code;
- int nglyphs;
- struct font_metrics *metrics;
+xfont_text_extents (struct font *font, unsigned int *code, int nglyphs, struct font_metrics *metrics)
{
XFontStruct *xfont = ((struct xfont_info *) font)->xfont;
int width = 0;
}
static int
-xfont_draw (s, from, to, x, y, with_background)
- struct glyph_string *s;
- int from, to, x, y, with_background;
+xfont_draw (struct glyph_string *s, int from, int to, int x, int y, int with_background)
{
XFontStruct *xfont = ((struct xfont_info *) s->font)->xfont;
int len = to - from;
}
static int
-xfont_check (f, font)
- FRAME_PTR f;
- struct font *font;
+xfont_check (FRAME_PTR f, struct font *font)
{
struct xfont_info *xfont = (struct xfont_info *) font;
\f
void
-syms_of_xfont ()
+syms_of_xfont (void)
{
staticpro (&xfont_scripts_cache);
{ /* Here we rely on the fact that syms_of_xfont (via syms_of_font)
may be NULL. */
static void
-xftfont_get_colors (f, face, gc, xftface_info, fg, bg)
- FRAME_PTR f;
- struct face *face;
- GC gc;
- struct xftface_info *xftface_info;
- XftColor *fg, *bg;
+xftfont_get_colors (FRAME_PTR f, struct face *face, GC gc, struct xftface_info *xftface_info, XftColor *fg, XftColor *bg)
{
if (xftface_info && face->gc == gc)
{
struct font_driver xftfont_driver;
static Lisp_Object
-xftfont_list (frame, spec)
- Lisp_Object frame;
- Lisp_Object spec;
+xftfont_list (Lisp_Object frame, Lisp_Object spec)
{
Lisp_Object list = ftfont_driver.list (frame, spec), tail;
}
static Lisp_Object
-xftfont_match (frame, spec)
- Lisp_Object frame;
- Lisp_Object spec;
+xftfont_match (Lisp_Object frame, Lisp_Object spec)
{
Lisp_Object entity = ftfont_driver.match (frame, spec);
static FcChar8 ascii_printable[95];
static void
-xftfont_fix_match (pat, match)
- FcPattern *pat, *match;
+xftfont_fix_match (FcPattern *pat, FcPattern *match)
{
/* These values are not used for matching (except antialias), but for
rendering, so make sure they are carried over to the match.
}
static void
-xftfont_add_rendering_parameters (pat, entity)
- FcPattern *pat;
- Lisp_Object entity;
+xftfont_add_rendering_parameters (FcPattern *pat, Lisp_Object entity)
{
Lisp_Object tail;
int ival;
}
static Lisp_Object
-xftfont_open (f, entity, pixel_size)
- FRAME_PTR f;
- Lisp_Object entity;
- int pixel_size;
+xftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
{
FcResult result;
Display *display = FRAME_X_DISPLAY (f);
}
static void
-xftfont_close (f, font)
- FRAME_PTR f;
- struct font *font;
+xftfont_close (FRAME_PTR f, struct font *font)
{
struct xftfont_info *xftfont_info = (struct xftfont_info *) font;
}
static int
-xftfont_prepare_face (f, face)
- FRAME_PTR f;
- struct face *face;
+xftfont_prepare_face (FRAME_PTR f, struct face *face)
{
struct xftface_info *xftface_info;
}
static void
-xftfont_done_face (f, face)
- FRAME_PTR f;
- struct face *face;
+xftfont_done_face (FRAME_PTR f, struct face *face)
{
struct xftface_info *xftface_info;
extern Lisp_Object Qja, Qko;
static int
-xftfont_has_char (font, c)
- Lisp_Object font;
- int c;
+xftfont_has_char (Lisp_Object font, int c)
{
struct xftfont_info *xftfont_info;
struct charset *cs = NULL;
}
static unsigned
-xftfont_encode_char (font, c)
- struct font *font;
- int c;
+xftfont_encode_char (struct font *font, int c)
{
struct xftfont_info *xftfont_info = (struct xftfont_info *) font;
unsigned code = XftCharIndex (xftfont_info->display, xftfont_info->xftfont,
}
static int
-xftfont_text_extents (font, code, nglyphs, metrics)
- struct font *font;
- unsigned *code;
- int nglyphs;
- struct font_metrics *metrics;
+xftfont_text_extents (struct font *font, unsigned int *code, int nglyphs, struct font_metrics *metrics)
{
struct xftfont_info *xftfont_info = (struct xftfont_info *) font;
XGlyphInfo extents;
}
static XftDraw *
-xftfont_get_xft_draw (f)
- FRAME_PTR f;
+xftfont_get_xft_draw (FRAME_PTR f)
{
XftDraw *xft_draw = font_get_frame_data (f, &xftfont_driver);
}
static int
-xftfont_draw (s, from, to, x, y, with_background)
- struct glyph_string *s;
- int from, to, x, y, with_background;
+xftfont_draw (struct glyph_string *s, int from, int to, int x, int y, int with_background)
{
FRAME_PTR f = s->f;
struct face *face = s->face;
}
static int
-xftfont_end_for_frame (f)
- FRAME_PTR f;
+xftfont_end_for_frame (FRAME_PTR f)
{
XftDraw *xft_draw;
}
static int
-xftfont_cached_font_ok (f, font_object, entity)
- struct frame *f;
- Lisp_Object font_object;
- Lisp_Object entity;
-
+xftfont_cached_font_ok (struct frame *f, Lisp_Object font_object, Lisp_Object entity)
{
struct xftfont_info *info = (struct xftfont_info *) XFONT_OBJECT (font_object);
FcPattern *oldpat = info->xftfont->pattern;
}
void
-syms_of_xftfont ()
+syms_of_xftfont (void)
{
DEFSYM (Qxft, "xft");
DEFSYM (QChinting, ":hinting");
static int gfds_size;
int
-xg_select (max_fds, rfds, wfds, efds, timeout)
- int max_fds;
- SELECT_TYPE *rfds;
- SELECT_TYPE *wfds;
- SELECT_TYPE *efds;
- EMACS_TIME *timeout;
+xg_select (int max_fds, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *timeout)
{
SELECT_TYPE all_rfds, all_wfds;
EMACS_TIME tmo, *tmop = timeout;
#endif /* defined (USE_GTK) || defined (HAVE_GCONF) */
void
-xgselect_initialize ()
+xgselect_initialize (void)
{
#if defined (USE_GTK) || defined (HAVE_GCONF)
gfds_size = 128;
the scroll bar or the edit window. Fx_popup_menu needs to be
sure it is the edit window. */
void
-mouse_position_for_popup (f, x, y)
- FRAME_PTR f;
- int *x;
- int *y;
+mouse_position_for_popup (FRAME_PTR f, int *x, int *y)
{
Window root, dummy_window;
int dummy;
/* Set menu_items_inuse so no other popup menu or dialog is created. */
void
-x_menu_set_in_use (in_use)
- int in_use;
+x_menu_set_in_use (int in_use)
{
menu_items_inuse = in_use ? Qt : Qnil;
popup_activated_flag = in_use;
Used for popup menus and dialogs. */
static void
-popup_widget_loop (do_timers, widget)
- int do_timers;
- GtkWidget *widget;
+popup_widget_loop (int do_timers, GtkWidget *widget)
{
++popup_activated_flag;
execute Lisp code. */
void
-x_activate_menubar (f)
- FRAME_PTR f;
+x_activate_menubar (FRAME_PTR f)
{
if (! FRAME_X_P (f))
abort ();
#ifdef USE_GTK
static void
-popup_deactivate_callback (widget, client_data)
- GtkWidget *widget;
- gpointer client_data;
+popup_deactivate_callback (GtkWidget *widget, gpointer client_data)
{
popup_activated_flag = 0;
}
for that widget.
F is the frame if known, or NULL if not known. */
static void
-show_help_event (f, widget, help)
- FRAME_PTR f;
- xt_or_gtk_widget widget;
- Lisp_Object help;
+show_help_event (FRAME_PTR f, xt_or_gtk_widget widget, Lisp_Object help)
{
Lisp_Object frame;
#ifdef USE_GTK
void
-menu_highlight_callback (widget, call_data)
- GtkWidget *widget;
- gpointer call_data;
+menu_highlight_callback (GtkWidget *widget, gpointer call_data)
{
xg_menu_item_cb_data *cb_data;
Lisp_Object help;
Figure out what the user chose
and put the appropriate events into the keyboard buffer. */
static void
-menubar_selection_callback (widget, client_data)
- GtkWidget *widget;
- gpointer client_data;
+menubar_selection_callback (GtkWidget *widget, gpointer client_data)
{
xg_menu_item_cb_data *cb_data = (xg_menu_item_cb_data*) client_data;
changed. Value is non-zero if widgets were updated. */
static int
-update_frame_menubar (f)
- FRAME_PTR f;
+update_frame_menubar (FRAME_PTR f)
{
#ifdef USE_GTK
return xg_update_frame_menubar (f);
it is set the first time this is called, from initialize_frame_menubar. */
void
-set_frame_menubar (f, first_time, deep_p)
- FRAME_PTR f;
- int first_time;
- int deep_p;
+set_frame_menubar (FRAME_PTR f, int first_time, int deep_p)
{
xt_or_gtk_widget menubar_widget;
#ifdef USE_X_TOOLKIT
is visible. */
void
-initialize_frame_menubar (f)
- FRAME_PTR f;
+initialize_frame_menubar (FRAME_PTR f)
{
/* This function is called before the first chance to redisplay
the frame. It has to be, so the frame will have the right size. */
Here only X and Y are used. */
static void
-menu_position_func (menu, x, y, push_in, user_data)
- GtkMenu *menu;
- gint *x;
- gint *y;
- gboolean *push_in;
- gpointer user_data;
+menu_position_func (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer user_data)
{
struct next_popup_x_y* data = (struct next_popup_x_y*)user_data;
GtkRequisition req;
}
static void
-popup_selection_callback (widget, client_data)
- GtkWidget *widget;
- gpointer client_data;
+popup_selection_callback (GtkWidget *widget, gpointer client_data)
{
xg_menu_item_cb_data *cb_data = (xg_menu_item_cb_data*) client_data;
}
static Lisp_Object
-pop_down_menu (arg)
- Lisp_Object arg;
+pop_down_menu (Lisp_Object arg)
{
struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
menu pops down.
menu_item_selection will be set to the selection. */
static void
-create_and_show_popup_menu (f, first_wv, x, y, for_click, timestamp)
- FRAME_PTR f;
- widget_value *first_wv;
- int x;
- int y;
- int for_click;
- EMACS_UINT timestamp;
+create_and_show_popup_menu (FRAME_PTR f, widget_value *first_wv, int x, int y, int for_click, EMACS_UINT timestamp)
{
int i;
GtkWidget *menu;
\f
#ifdef USE_GTK
static void
-dialog_selection_callback (widget, client_data)
- GtkWidget *widget;
- gpointer client_data;
+dialog_selection_callback (GtkWidget *widget, gpointer client_data)
{
/* The EMACS_INT cast avoids a warning. There's no problem
as long as pointers have enough bits to hold small integers. */
dialog pops down.
menu_item_selection will be set to the selection. */
static void
-create_and_show_dialog (f, first_wv)
- FRAME_PTR f;
- widget_value *first_wv;
+create_and_show_dialog (FRAME_PTR f, widget_value *first_wv)
{
GtkWidget *menu;
"button6", "button7", "button8", "button9", "button10" };
static Lisp_Object
-xdialog_show (f, keymaps, title, header, error_name)
- FRAME_PTR f;
- int keymaps;
- Lisp_Object title, header;
- char **error_name;
+xdialog_show (FRAME_PTR f, int keymaps, Lisp_Object title, Lisp_Object header, char **error_name)
{
int i, nb_buttons=0;
char dialog_name[6];
/* Detect if a dialog or menu has been posted. */
int
-popup_activated ()
+popup_activated (void)
{
return popup_activated_flag;
}
}
\f
void
-syms_of_xmenu ()
+syms_of_xmenu (void)
{
Qdebug_on_next_call = intern_c_string ("debug-on-next-call");
staticpro (&Qdebug_on_next_call);
#include "lisp.h"
-extern char *getenv ();
+extern char *getenv (const char *);
/* This does cause trouble on AIX. I'm going to take the comment at
face value. */
extern struct passwd *getpwuid (uid_t);
extern struct passwd *getpwnam (const char *);
#else
-extern struct passwd *getpwuid ();
-extern struct passwd *getpwnam ();
+extern struct passwd *getpwuid (uid_t);
+extern struct passwd *getpwnam (const char *);
#endif
extern char *get_system_name ();
#define free xfree
#endif
-char *x_get_string_resource ();
-static int file_p ();
+char *x_get_string_resource (XrmDatabase rdb, char *name, char *class);
+static int file_p (char *filename);
\f
/* X file search path processing. */
resource, for later use in search path decoding. If we find no
such resource, return zero. */
char *
-x_get_customization_string (db, name, class)
- XrmDatabase db;
- char *name, *class;
+x_get_customization_string (XrmDatabase db, char *name, char *class)
{
char *full_name
= (char *) alloca (strlen (name) + sizeof ("customization") + 3);
Return NULL otherwise. */
static char *
-magic_file_p (string, string_len, class, escaped_suffix, suffix)
- char *string;
- int string_len;
- char *class, *escaped_suffix, *suffix;
+magic_file_p (char *string, int string_len, char *class, char *escaped_suffix, char *suffix)
{
char *lang = getenv ("LANG");
static char *
-gethomedir ()
+gethomedir (void)
{
struct passwd *pw;
char *ptr;
static int
-file_p (filename)
- char *filename;
+file_p (char *filename)
{
struct stat status;
the path name of the one we found otherwise. */
static char *
-search_magic_path (search_path, class, escaped_suffix, suffix)
- char *search_path, *class, *escaped_suffix, *suffix;
+search_magic_path (char *search_path, char *class, char *escaped_suffix, char *suffix)
{
register char *s, *p;
/* Producing databases for individual sources. */
static XrmDatabase
-get_system_app (class)
- char *class;
+get_system_app (char *class)
{
XrmDatabase db = NULL;
char *path;
static XrmDatabase
-get_fallback (display)
- Display *display;
+get_fallback (Display *display)
{
return NULL;
}
static XrmDatabase
-get_user_app (class)
- char *class;
+get_user_app (char *class)
{
char *path;
char *file = 0;
static XrmDatabase
-get_user_db (display)
- Display *display;
+get_user_db (Display *display)
{
XrmDatabase db;
char *xdefs;
}
static XrmDatabase
-get_environ_db ()
+get_environ_db (void)
{
XrmDatabase db;
char *p;
/* Load X resources based on the display and a possible -xrm option. */
XrmDatabase
-x_load_resources (display, xrm_string, myname, myclass)
- Display *display;
- char *xrm_string, *myname, *myclass;
+x_load_resources (Display *display, char *xrm_string, char *myname, char *myclass)
{
XrmDatabase user_database;
XrmDatabase rdb;
and of type TYPE from database RDB. The value is returned in RET_VALUE. */
int
-x_get_resource (rdb, name, class, expected_type, ret_value)
- XrmDatabase rdb;
- char *name, *class;
- XrmRepresentation expected_type;
- XrmValue *ret_value;
+x_get_resource (XrmDatabase rdb, char *name, char *class, XrmRepresentation expected_type, XrmValue *ret_value)
{
XrmValue value;
XrmName namelist[100];
database RDB. */
char *
-x_get_string_resource (rdb, name, class)
- XrmDatabase rdb;
- char *name, *class;
+x_get_string_resource (XrmDatabase rdb, char *name, char *class)
{
XrmValue value;
/* Queue up an SELECTION_REQUEST_EVENT *EVENT, to be processed later. */
static void
-x_queue_event (event)
- struct input_event *event;
+x_queue_event (struct input_event *event)
{
struct selection_event_queue *queue_tmp;
/* Start queuing SELECTION_REQUEST_EVENT events. */
static void
-x_start_queuing_selection_requests ()
+x_start_queuing_selection_requests (void)
{
if (x_queue_selection_requests)
abort ();
/* Stop queuing SELECTION_REQUEST_EVENT events. */
static void
-x_stop_queuing_selection_requests ()
+x_stop_queuing_selection_requests (void)
{
TRACE1 ("x_stop_queuing_selection_requests %d", x_queue_selection_requests);
--x_queue_selection_requests;
roundtrip whenever possible. */
static Atom
-symbol_to_x_atom (dpyinfo, display, sym)
- struct x_display_info *dpyinfo;
- Display *display;
- Lisp_Object sym;
+symbol_to_x_atom (struct x_display_info *dpyinfo, Display *display, Lisp_Object sym)
{
Atom val;
if (NILP (sym)) return 0;
and calls to intern whenever possible. */
static Lisp_Object
-x_atom_to_symbol (dpy, atom)
- Display *dpy;
- Atom atom;
+x_atom_to_symbol (Display *dpy, Atom atom)
{
struct x_display_info *dpyinfo;
char *str;
our selection. */
static void
-x_own_selection (selection_name, selection_value)
- Lisp_Object selection_name, selection_value;
+x_own_selection (Lisp_Object selection_name, Lisp_Object selection_value)
{
struct frame *sf = SELECTED_FRAME ();
Window selecting_window;
This calls random Lisp code, and may signal or gc. */
static Lisp_Object
-x_get_local_selection (selection_symbol, target_type, local_request)
- Lisp_Object selection_symbol, target_type;
- int local_request;
+x_get_local_selection (Lisp_Object selection_symbol, Lisp_Object target_type, int local_request)
{
Lisp_Object local_value;
Lisp_Object handler_fn, value, type, check;
meaning we were unable to do what they wanted. */
static void
-x_decline_selection_request (event)
- struct input_event *event;
+x_decline_selection_request (struct input_event *event)
{
XSelectionEvent reply;
before we throw to top-level or go into the debugger or whatever. */
static Lisp_Object
-x_selection_request_lisp_error (ignore)
- Lisp_Object ignore;
+x_selection_request_lisp_error (Lisp_Object ignore)
{
if (x_selection_current_request != 0
&& selection_request_dpyinfo->display)
}
static Lisp_Object
-x_catch_errors_unwind (dummy)
- Lisp_Object dummy;
+x_catch_errors_unwind (Lisp_Object dummy)
{
BLOCK_INPUT;
x_uncatch_errors ();
struct prop_location *next;
};
-static struct prop_location *expect_property_change ();
-static void wait_for_property_change ();
-static void unexpect_property_change ();
-static int waiting_for_other_props_on_window ();
+static struct prop_location *expect_property_change (Display *display, Window window, Atom property, int state);
+static void wait_for_property_change (struct prop_location *location);
+static void unexpect_property_change (struct prop_location *location);
+static int waiting_for_other_props_on_window (Display *display, Window window);
static int prop_location_identifier;
static struct prop_location *property_change_wait_list;
static Lisp_Object
-queue_selection_requests_unwind (tem)
- Lisp_Object tem;
+queue_selection_requests_unwind (Lisp_Object tem)
{
x_stop_queuing_selection_requests ();
return Qnil;
Return nil if there is none. */
static Lisp_Object
-some_frame_on_display (dpyinfo)
- struct x_display_info *dpyinfo;
+some_frame_on_display (struct x_display_info *dpyinfo)
{
Lisp_Object list, frame;
#endif /* TRACE_SELECTION */
static void
-x_reply_selection_request (event, format, data, size, type)
- struct input_event *event;
- int format, size;
- unsigned char *data;
- Atom type;
+x_reply_selection_request (struct input_event *event, int format, unsigned char *data, int size, Atom type)
{
XSelectionEvent reply;
Display *display = SELECTION_EVENT_DISPLAY (event);
This is called from keyboard.c when such an event is found in the queue. */
static void
-x_handle_selection_request (event)
- struct input_event *event;
+x_handle_selection_request (struct input_event *event)
{
struct gcpro gcpro1, gcpro2, gcpro3;
Lisp_Object local_selection_data;
This is called from keyboard.c when such an event is found in the queue. */
static void
-x_handle_selection_clear (event)
- struct input_event *event;
+x_handle_selection_clear (struct input_event *event)
{
Display *display = SELECTION_EVENT_DISPLAY (event);
Atom selection = SELECTION_EVENT_SELECTION (event);
}
void
-x_handle_selection_event (event)
- struct input_event *event;
+x_handle_selection_event (struct input_event *event)
{
TRACE0 ("x_handle_selection_event");
We do this when about to delete a frame. */
void
-x_clear_frame_selections (f)
- FRAME_PTR f;
+x_clear_frame_selections (FRAME_PTR f)
{
Lisp_Object frame;
Lisp_Object rest;
are on the list of what we are waiting for. */
static int
-waiting_for_other_props_on_window (display, window)
- Display *display;
- Window window;
+waiting_for_other_props_on_window (Display *display, Window window)
{
struct prop_location *rest = property_change_wait_list;
while (rest)
this awaited property change. */
static struct prop_location *
-expect_property_change (display, window, property, state)
- Display *display;
- Window window;
- Atom property;
- int state;
+expect_property_change (Display *display, Window window, Atom property, int state)
{
struct prop_location *pl = (struct prop_location *) xmalloc (sizeof *pl);
pl->identifier = ++prop_location_identifier;
IDENTIFIER is the number that uniquely identifies the entry. */
static void
-unexpect_property_change (location)
- struct prop_location *location;
+unexpect_property_change (struct prop_location *location)
{
struct prop_location *prev = 0, *rest = property_change_wait_list;
while (rest)
/* Remove the property change expectation element for IDENTIFIER. */
static Lisp_Object
-wait_for_property_change_unwind (loc)
- Lisp_Object loc;
+wait_for_property_change_unwind (Lisp_Object loc)
{
struct prop_location *location = XSAVE_VALUE (loc)->pointer;
IDENTIFIER should be the value that expect_property_change returned. */
static void
-wait_for_property_change (location)
- struct prop_location *location;
+wait_for_property_change (struct prop_location *location)
{
int secs, usecs;
int count = SPECPDL_INDEX ();
/* Called from XTread_socket in response to a PropertyNotify event. */
void
-x_handle_property_notify (event)
- XPropertyEvent *event;
+x_handle_property_notify (XPropertyEvent *event)
{
struct prop_location *prev = 0, *rest = property_change_wait_list;
Converts this to Lisp data and returns it. */
static Lisp_Object
-x_get_foreign_selection (selection_symbol, target_type, time_stamp)
- Lisp_Object selection_symbol, target_type, time_stamp;
+x_get_foreign_selection (Lisp_Object selection_symbol, Lisp_Object target_type, Lisp_Object time_stamp)
{
struct frame *sf = SELECTED_FRAME ();
Window requestor_window;
static Lisp_Object
-selection_data_to_lisp_data (display, data, size, type, format)
- Display *display;
- unsigned char *data;
- Atom type;
- int size, format;
+selection_data_to_lisp_data (Display *display, unsigned char *data, int size, Atom type, int format)
{
struct x_display_info *dpyinfo = x_display_info_for_display (display);
}
static Lisp_Object
-clean_local_selection_data (obj)
- Lisp_Object obj;
+clean_local_selection_data (Lisp_Object obj)
{
if (CONSP (obj)
&& INTEGERP (XCAR (obj))
We store t there if the reply is successful, lambda if not. */
void
-x_handle_selection_notify (event)
- XSelectionEvent *event;
+x_handle_selection_notify (XSelectionEvent *event)
{
if (event->requestor != reading_selection_window)
return;
This is used when we kill a buffer. */
void
-x_disown_buffer_selections (buffer)
- Lisp_Object buffer;
+x_disown_buffer_selections (Lisp_Object buffer)
{
Lisp_Object tail;
struct buffer *buf = XBUFFER (buffer);
/* Ensure that all 8 cut buffers exist. ICCCM says we gotta... */
static void
-initialize_cut_buffers (display, window)
- Display *display;
- Window window;
+initialize_cut_buffers (Display *display, Window window)
{
unsigned char *data = (unsigned char *) "";
BLOCK_INPUT;
bit parts of a 32 bit number). */
int
-x_check_property_data (data)
- Lisp_Object data;
+x_check_property_data (Lisp_Object data)
{
Lisp_Object iter;
int size = 0;
XClientMessageEvent). */
void
-x_fill_property_data (dpy, data, ret, format)
- Display *dpy;
- Lisp_Object data;
- void *ret;
- int format;
+x_fill_property_data (Display *dpy, Lisp_Object data, void *ret, int format)
{
long val;
long *d32 = (long *) ret;
Also see comment for selection_data_to_lisp_data above. */
Lisp_Object
-x_property_data_to_lisp (f, data, type, format, size)
- struct frame *f;
- unsigned char *data;
- Atom type;
- int format;
- unsigned long size;
+x_property_data_to_lisp (struct frame *f, unsigned char *data, Atom type, int format, long unsigned int size)
{
return selection_data_to_lisp_data (FRAME_X_DISPLAY (f),
data, size*format/8, type, format);
/* Get the mouse position in frame relative coordinates. */
static void
-mouse_position_for_drop (f, x, y)
- FRAME_PTR f;
- int *x;
- int *y;
+mouse_position_for_drop (FRAME_PTR f, int *x, int *y)
{
Window root, dummy_window;
int dummy;
/* Convert an XClientMessageEvent to a Lisp event of type DRAG_N_DROP_EVENT. */
int
-x_handle_dnd_message (f, event, dpyinfo, bufp)
- struct frame *f;
- XClientMessageEvent *event;
- struct x_display_info *dpyinfo;
- struct input_event *bufp;
+x_handle_dnd_message (struct frame *f, XClientMessageEvent *event, struct x_display_info *dpyinfo, struct input_event *bufp)
{
Lisp_Object vec;
Lisp_Object frame;
\f
void
-syms_of_xselect ()
+syms_of_xselect (void)
{
defsubr (&Sx_get_selection_internal);
defsubr (&Sx_own_selection_internal);
static void
-store_config_changed_event (arg, display_name)
- Lisp_Object arg;
- Lisp_Object display_name;
+store_config_changed_event (Lisp_Object arg, Lisp_Object display_name)
{
struct input_event event;
EVENT_INIT (event);
that is SYSTEM_MONO_FONT. */
static void
-something_changedCB (client, cnxn_id, entry, user_data)
- GConfClient *client;
- guint cnxn_id;
- GConfEntry *entry;
- gpointer user_data;
+something_changedCB (GConfClient *client, guint cnxn_id, GConfEntry *entry, gpointer user_data)
{
GConfValue *v = gconf_entry_get_value (entry);
/* Find the window that contains the XSETTINGS property values. */
static void
-get_prop_window (dpyinfo)
- struct x_display_info *dpyinfo;
+get_prop_window (struct x_display_info *dpyinfo)
{
Display *dpy = dpyinfo->display;
*/
static int
-parse_settings (prop, bytes, settings)
- unsigned char *prop;
- unsigned long bytes;
- struct xsettings *settings;
+parse_settings (unsigned char *prop, long unsigned int bytes, struct xsettings *settings)
{
Lisp_Object byteorder = Fbyteorder ();
int my_bo = XFASTINT (byteorder) == 'B' ? MSBFirst : LSBFirst;
}
static int
-read_settings (dpyinfo, settings)
- struct x_display_info *dpyinfo;
- struct xsettings *settings;
+read_settings (struct x_display_info *dpyinfo, struct xsettings *settings)
{
long long_len;
Atom act_type;
static void
-apply_xft_settings (dpyinfo, send_event_p, settings)
- struct x_display_info *dpyinfo;
- int send_event_p;
- struct xsettings *settings;
+apply_xft_settings (struct x_display_info *dpyinfo, int send_event_p, struct xsettings *settings)
{
#ifdef HAVE_XFT
FcPattern *pat;
}
static void
-read_and_apply_settings (dpyinfo, send_event_p)
- struct x_display_info *dpyinfo;
- int send_event_p;
+read_and_apply_settings (struct x_display_info *dpyinfo, int send_event_p)
{
struct xsettings settings;
Lisp_Object dpyname = XCAR (dpyinfo->name_list_element);
}
void
-xft_settings_event (dpyinfo, event)
- struct x_display_info *dpyinfo;
- XEvent *event;
+xft_settings_event (struct x_display_info *dpyinfo, XEvent *event)
{
int check_window_p = 0;
int apply_settings = 0;
static void
-init_gconf ()
+init_gconf (void)
{
#if defined (HAVE_GCONF) && defined (HAVE_XFT)
int i;
}
static void
-init_xsettings (dpyinfo)
- struct x_display_info *dpyinfo;
+init_xsettings (struct x_display_info *dpyinfo)
{
char sel[64];
Display *dpy = dpyinfo->display;
}
void
-xsettings_initialize (dpyinfo)
- struct x_display_info *dpyinfo;
+xsettings_initialize (struct x_display_info *dpyinfo)
{
if (first_dpyinfo == NULL) first_dpyinfo = dpyinfo;
init_gconf ();
}
const char *
-xsettings_get_system_font ()
+xsettings_get_system_font (void)
{
return current_mono_font;
}
const char *
-xsettings_get_system_normal_font ()
+xsettings_get_system_normal_font (void)
{
return current_font;
}
}
void
-syms_of_xsettings ()
+syms_of_xsettings (void)
{
current_mono_font = NULL;
current_font = NULL;
#define CHDIR_OPT "--chdir="
static void
-ice_connection_closed ()
+ice_connection_closed (void)
{
if (ice_fd >= 0)
delete_keyboard_wait_descriptor (ice_fd);
Otherwise returns 1 if SAVE_SESSION_EVENT is stored in buffer BUFP. */
int
-x_session_check_input (bufp)
- struct input_event *bufp;
+x_session_check_input (struct input_event *bufp)
{
SELECT_TYPE read_fds;
EMACS_TIME tmout;
/* Return non-zero if we have a connection to a session manager. */
int
-x_session_have_connection ()
+x_session_have_connection (void)
{
return ice_fd != -1;
}
Then lisp code can interact with the user. */
static void
-smc_interact_CB (smcConn, clientData)
- SmcConn smcConn;
- SmPointer clientData;
+smc_interact_CB (SmcConn smcConn, SmPointer clientData)
{
doing_interact = True;
emacs_event.kind = SAVE_SESSION_EVENT;
/* According to the SM specification, this shall close the connection. */
static void
-smc_die_CB (smcConn, clientData)
- SmcConn smcConn;
- SmPointer clientData;
+smc_die_CB (SmcConn smcConn, SmPointer clientData)
{
SmcCloseConnection (smcConn, 0, 0);
ice_connection_closed ();
even seem necessary. */
static void
-smc_save_complete_CB (smcConn, clientData)
- SmcConn smcConn;
- SmPointer clientData;
+smc_save_complete_CB (SmcConn smcConn, SmPointer clientData)
{
/* Empty */
}
static void
-smc_shutdown_cancelled_CB (smcConn, clientData)
- SmcConn smcConn;
- SmPointer clientData;
+smc_shutdown_cancelled_CB (SmcConn smcConn, SmPointer clientData)
{
/* Empty */
}
static void
-ice_io_error_handler (iceConn)
- IceConn iceConn;
+ice_io_error_handler (IceConn iceConn)
{
/* Connection probably gone. */
ice_connection_closed ();
uses ICE as it transport protocol. */
static void
-ice_conn_watch_CB (iceConn, clientData, opening, watchData)
- IceConn iceConn;
- IcePointer clientData;
- Bool opening;
- IcePointer *watchData;
+ice_conn_watch_CB (IceConn iceConn, IcePointer clientData, int opening, IcePointer *watchData)
{
if (! opening)
{
/* Create the client leader window. */
static void
-create_client_leader_window (dpyinfo, client_id)
- struct x_display_info *dpyinfo;
- char *client_id;
+create_client_leader_window (struct x_display_info *dpyinfo, char *client_id)
{
Window w;
XClassHint class_hints;
/* Try to open a connection to the session manager. */
void
-x_session_initialize (dpyinfo)
- struct x_display_info *dpyinfo;
+x_session_initialize (struct x_display_info *dpyinfo)
{
#define SM_ERRORSTRING_LEN 512
char errorstring[SM_ERRORSTRING_LEN];
/* Ensure that the session manager is not contacted again. */
void
-x_session_close ()
+x_session_close (void)
{
ice_connection_closed ();
}
Initialization
***********************************************************************/
void
-syms_of_xsmfns ()
+syms_of_xsmfns (void)
{
DEFVAR_LISP ("x-session-id", &Vx_session_id,
doc: /* The session id Emacs got from the session manager for this session.
/* Flush display of frame F, or of all frames if F is null. */
static void
-x_flush (f)
- struct frame *f;
+x_flush (struct frame *f)
{
/* Don't call XFlush when it is not safe to redisplay; the X
connection may be broken. */
/* Return the struct x_display_info corresponding to DPY. */
struct x_display_info *
-x_display_info_for_display (dpy)
- Display *dpy;
+x_display_info_for_display (Display *dpy)
{
struct x_display_info *dpyinfo;
#define OPACITY "_NET_WM_WINDOW_OPACITY"
void
-x_set_frame_alpha (f)
- struct frame *f;
+x_set_frame_alpha (struct frame *f)
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
Display *dpy = FRAME_X_DISPLAY (f);
}
int
-x_display_pixel_height (dpyinfo)
- struct x_display_info *dpyinfo;
+x_display_pixel_height (struct x_display_info *dpyinfo)
{
return HeightOfScreen (dpyinfo->screen);
}
int
-x_display_pixel_width (dpyinfo)
- struct x_display_info *dpyinfo;
+x_display_pixel_width (struct x_display_info *dpyinfo)
{
return WidthOfScreen (dpyinfo->screen);
}
because all interesting stuff is done on a window basis. */
static void
-x_update_begin (f)
- struct frame *f;
+x_update_begin (struct frame *f)
{
/* Nothing to do. */
}
position of W. */
static void
-x_update_window_begin (w)
- struct window *w;
+x_update_window_begin (struct window *w)
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
struct x_display_info *display_info = FRAME_X_DISPLAY_INFO (f);
/* Draw a vertical window border from (x,y0) to (x,y1) */
static void
-x_draw_vertical_window_border (w, x, y0, y1)
- struct window *w;
- int x, y0, y1;
+x_draw_vertical_window_border (struct window *w, int x, int y0, int y1)
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
struct face *face;
here. */
static void
-x_update_window_end (w, cursor_on_p, mouse_face_overwritten_p)
- struct window *w;
- int cursor_on_p, mouse_face_overwritten_p;
+x_update_window_end (struct window *w, int cursor_on_p, int mouse_face_overwritten_p)
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
update_end. */
static void
-x_update_end (f)
- struct frame *f;
+x_update_end (struct frame *f)
{
/* Mouse highlight may be displayed again. */
FRAME_X_DISPLAY_INFO (f)->mouse_face_defer = 0;
updated_window is not available here. */
static void
-XTframe_up_to_date (f)
- struct frame *f;
+XTframe_up_to_date (struct frame *f)
{
if (FRAME_X_P (f))
{
between bitmaps to be drawn between current row and DESIRED_ROW. */
static void
-x_after_update_window_line (desired_row)
- struct glyph_row *desired_row;
+x_after_update_window_line (struct glyph_row *desired_row)
{
struct window *w = updated_window;
struct frame *f;
}
static void
-x_draw_fringe_bitmap (w, row, p)
- struct window *w;
- struct glyph_row *row;
- struct draw_fringe_bitmap_params *p;
+x_draw_fringe_bitmap (struct window *w, struct glyph_row *row, struct draw_fringe_bitmap_params *p)
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
Display *display = FRAME_X_DISPLAY (f);
face. */
static void
-x_set_cursor_gc (s)
- struct glyph_string *s;
+x_set_cursor_gc (struct glyph_string *s)
{
if (s->font == FRAME_FONT (s->f)
&& s->face->background == FRAME_BACKGROUND_PIXEL (s->f)
/* Set up S->gc of glyph string S for drawing text in mouse face. */
static void
-x_set_mouse_face_gc (s)
- struct glyph_string *s;
+x_set_mouse_face_gc (struct glyph_string *s)
{
int face_id;
struct face *face;
matrix was built, so there isn't much to do, here. */
static INLINE void
-x_set_mode_line_face_gc (s)
- struct glyph_string *s;
+x_set_mode_line_face_gc (struct glyph_string *s)
{
s->gc = s->face->gc;
}
pattern. */
static INLINE void
-x_set_glyph_string_gc (s)
- struct glyph_string *s;
+x_set_glyph_string_gc (struct glyph_string *s)
{
PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
line or menu if we don't have X toolkit support. */
static INLINE void
-x_set_glyph_string_clipping (s)
- struct glyph_string *s;
+x_set_glyph_string_clipping (struct glyph_string *s)
{
XRectangle *r = s->clip;
int n = get_glyph_string_clip_rects (s, r, 2);
the area of SRC. */
static void
-x_set_glyph_string_clipping_exactly (src, dst)
- struct glyph_string *src, *dst;
+x_set_glyph_string_clipping_exactly (struct glyph_string *src, struct glyph_string *dst)
{
XRectangle r;
Compute left and right overhang of glyph string S. */
static void
-x_compute_glyph_string_overhangs (s)
- struct glyph_string *s;
+x_compute_glyph_string_overhangs (struct glyph_string *s)
{
if (s->cmp == NULL
&& (s->first_glyph->type == CHAR_GLYPH
/* Fill rectangle X, Y, W, H with background color of glyph string S. */
static INLINE void
-x_clear_glyph_string_rect (s, x, y, w, h)
- struct glyph_string *s;
- int x, y, w, h;
+x_clear_glyph_string_rect (struct glyph_string *s, int x, int y, int w, int h)
{
XGCValues xgcv;
XGetGCValues (s->display, s->gc, GCForeground | GCBackground, &xgcv);
contains the first component of a composition. */
static void
-x_draw_glyph_string_background (s, force_p)
- struct glyph_string *s;
- int force_p;
+x_draw_glyph_string_background (struct glyph_string *s, int force_p)
{
/* Nothing to do if background has already been drawn or if it
shouldn't be drawn in the first place. */
/* Draw the foreground of glyph string S. */
static void
-x_draw_glyph_string_foreground (s)
- struct glyph_string *s;
+x_draw_glyph_string_foreground (struct glyph_string *s)
{
int i, x;
/* Draw the foreground of composite glyph string S. */
static void
-x_draw_composite_glyph_string_foreground (s)
- struct glyph_string *s;
+x_draw_composite_glyph_string_foreground (struct glyph_string *s)
{
int i, j, x;
struct font *font = s->font;
say a 24-bit TrueColor map. */
static const XColor *
-x_color_cells (dpy, ncells)
- Display *dpy;
- int *ncells;
+x_color_cells (Display *dpy, int *ncells)
{
struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
colors in COLORS. Use cached information, if available. */
void
-x_query_colors (f, colors, ncolors)
- struct frame *f;
- XColor *colors;
- int ncolors;
+x_query_colors (struct frame *f, XColor *colors, int ncolors)
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
COLOR. Use cached information, if available. */
void
-x_query_color (f, color)
- struct frame *f;
- XColor *color;
+x_query_color (struct frame *f, XColor *color)
{
x_query_colors (f, color, 1);
}
allocated. */
static int
-x_alloc_nearest_color_1 (dpy, cmap, color)
- Display *dpy;
- Colormap cmap;
- XColor *color;
+x_alloc_nearest_color_1 (Display *dpy, Colormap cmap, XColor *color)
{
int rc;
allocated. */
int
-x_alloc_nearest_color (f, cmap, color)
- struct frame *f;
- Colormap cmap;
- XColor *color;
+x_alloc_nearest_color (struct frame *f, Colormap cmap, XColor *color)
{
gamma_correct (f, color);
return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f), cmap, color);
get color reference counts right. */
unsigned long
-x_copy_color (f, pixel)
- struct frame *f;
- unsigned long pixel;
+x_copy_color (struct frame *f, long unsigned int pixel)
{
XColor color;
get color reference counts right. */
unsigned long
-x_copy_dpy_color (dpy, cmap, pixel)
- Display *dpy;
- Colormap cmap;
- unsigned long pixel;
+x_copy_dpy_color (Display *dpy, Colormap cmap, long unsigned int pixel)
{
XColor color;
Value is non-zero if successful. */
static int
-x_alloc_lighter_color (f, display, cmap, pixel, factor, delta)
- struct frame *f;
- Display *display;
- Colormap cmap;
- unsigned long *pixel;
- double factor;
- int delta;
+x_alloc_lighter_color (struct frame *f, Display *display, Colormap cmap, long unsigned int *pixel, double factor, int delta)
{
XColor color, new;
long bright;
be allocated, use DEFAULT_PIXEL, instead. */
static void
-x_setup_relief_color (f, relief, factor, delta, default_pixel)
- struct frame *f;
- struct relief *relief;
- double factor;
- int delta;
- unsigned long default_pixel;
+x_setup_relief_color (struct frame *f, struct relief *relief, double factor, int delta, long unsigned int default_pixel)
{
XGCValues xgcv;
struct x_output *di = f->output_data.x;
/* Set up colors for the relief lines around glyph string S. */
static void
-x_setup_relief_colors (s)
- struct glyph_string *s;
+x_setup_relief_colors (struct glyph_string *s)
{
struct x_output *di = s->f->output_data.x;
unsigned long color;
/* Draw a box around glyph string S. */
static void
-x_draw_glyph_string_box (s)
- struct glyph_string *s;
+x_draw_glyph_string_box (struct glyph_string *s)
{
int width, left_x, right_x, top_y, bottom_y, last_x, raised_p;
int left_p, right_p;
/* Draw foreground of image glyph string S. */
static void
-x_draw_image_foreground (s)
- struct glyph_string *s;
+x_draw_image_foreground (struct glyph_string *s)
{
int x = s->x;
int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
/* Draw a relief around the image glyph string S. */
static void
-x_draw_image_relief (s)
- struct glyph_string *s;
+x_draw_image_relief (struct glyph_string *s)
{
int x0, y0, x1, y1, thick, raised_p, extra;
XRectangle r;
/* Draw the foreground of image glyph string S to PIXMAP. */
static void
-x_draw_image_foreground_1 (s, pixmap)
- struct glyph_string *s;
- Pixmap pixmap;
+x_draw_image_foreground_1 (struct glyph_string *s, Pixmap pixmap)
{
int x = 0;
int y = s->ybase - s->y - image_ascent (s->img, s->face, &s->slice);
give the rectangle to draw. */
static void
-x_draw_glyph_string_bg_rect (s, x, y, w, h)
- struct glyph_string *s;
- int x, y, w, h;
+x_draw_glyph_string_bg_rect (struct glyph_string *s, int x, int y, int w, int h)
{
if (s->stippled_p)
{
*/
static void
-x_draw_image_glyph_string (s)
- struct glyph_string *s;
+x_draw_image_glyph_string (struct glyph_string *s)
{
int box_line_hwidth = eabs (s->face->box_line_width);
int box_line_vwidth = max (s->face->box_line_width, 0);
/* Draw stretch glyph string S. */
static void
-x_draw_stretch_glyph_string (s)
- struct glyph_string *s;
+x_draw_stretch_glyph_string (struct glyph_string *s)
{
xassert (s->first_glyph->type == STRETCH_GLYPH);
/* Draw glyph string S. */
static void
-x_draw_glyph_string (s)
- struct glyph_string *s;
+x_draw_glyph_string (struct glyph_string *s)
{
int relief_drawn_p = 0;
/* Shift display to make room for inserted glyphs. */
void
-x_shift_glyphs_for_insert (f, x, y, width, height, shift_by)
- struct frame *f;
- int x, y, width, height, shift_by;
+x_shift_glyphs_for_insert (struct frame *f, int x, int y, int width, int height, int shift_by)
{
XCopyArea (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), FRAME_X_WINDOW (f),
f->output_data.x->normal_gc,
for X frames. */
static void
-x_delete_glyphs (f, n)
- struct frame *f;
- register int n;
+x_delete_glyphs (struct frame *f, register int n)
{
abort ();
}
If they are <= 0, this is probably an error. */
void
-x_clear_area (dpy, window, x, y, width, height, exposures)
- Display *dpy;
- Window window;
- int x, y;
- int width, height;
- int exposures;
+x_clear_area (Display *dpy, Window window, int x, int y, int width, int height, int exposures)
{
xassert (width > 0 && height > 0);
XClearArea (dpy, window, x, y, width, height, exposures);
*RESULT. Return 1 if the difference is negative, otherwise 0. */
static int
-timeval_subtract (result, x, y)
- struct timeval *result, x, y;
+timeval_subtract (struct timeval *result, struct timeval x, struct timeval y)
{
/* Perform the carry for the later subtraction by updating y. This
is safer because on some systems the tv_sec member is unsigned. */
}
void
-XTflash (f)
- struct frame *f;
+XTflash (struct frame *f)
{
BLOCK_INPUT;
static void
-XTtoggle_invisible_pointer (f, invisible)
- FRAME_PTR f;
- int invisible;
+XTtoggle_invisible_pointer (FRAME_PTR f, int invisible)
{
BLOCK_INPUT;
if (invisible)
/* Make audible bell. */
void
-XTring_bell ()
+XTring_bell (void)
{
struct frame *f = SELECTED_FRAME ();
that is bounded by calls to x_update_begin and x_update_end. */
static void
-XTset_terminal_window (n)
- register int n;
+XTset_terminal_window (register int n)
{
/* This function intentionally left blank. */
}
lines or deleting -N lines at vertical position VPOS. */
static void
-x_ins_del_lines (f, vpos, n)
- struct frame *f;
- int vpos, n;
+x_ins_del_lines (struct frame *f, int vpos, int n)
{
abort ();
}
/* Scroll part of the display as described by RUN. */
static void
-x_scroll_run (w, run)
- struct window *w;
- struct run *run;
+x_scroll_run (struct window *w, struct run *run)
{
struct frame *f = XFRAME (w->frame);
int x, y, width, height, from_y, to_y, bottom_y;
\f
static void
-frame_highlight (f)
- struct frame *f;
+frame_highlight (struct frame *f)
{
/* We used to only do this if Vx_no_window_manager was non-nil, but
the ICCCM (section 4.1.6) says that the window's border pixmap
}
static void
-frame_unhighlight (f)
- struct frame *f;
+frame_unhighlight (struct frame *f)
{
/* We used to only do this if Vx_no_window_manager was non-nil, but
the ICCCM (section 4.1.6) says that the window's border pixmap
Lisp code can tell when the switch took place by examining the events. */
static void
-x_new_focus_frame (dpyinfo, frame)
- struct x_display_info *dpyinfo;
- struct frame *frame;
+x_new_focus_frame (struct x_display_info *dpyinfo, struct frame *frame)
{
struct frame *old_focus = dpyinfo->x_focus_frame;
a FOCUS_IN_EVENT into *BUFP. */
static void
-x_focus_changed (type, state, dpyinfo, frame, bufp)
- int type;
- int state;
- struct x_display_info *dpyinfo;
- struct frame *frame;
- struct input_event *bufp;
+x_focus_changed (int type, int state, struct x_display_info *dpyinfo, struct frame *frame, struct input_event *bufp)
{
if (type == FocusIn)
{
Returns FOCUS_IN_EVENT event in *BUFP. */
static void
-x_detect_focus_change (dpyinfo, event, bufp)
- struct x_display_info *dpyinfo;
- XEvent *event;
- struct input_event *bufp;
+x_detect_focus_change (struct x_display_info *dpyinfo, XEvent *event, struct input_event *bufp)
{
struct frame *frame;
/* Handle an event saying the mouse has moved out of an Emacs frame. */
void
-x_mouse_leave (dpyinfo)
- struct x_display_info *dpyinfo;
+x_mouse_leave (struct x_display_info *dpyinfo)
{
x_new_focus_frame (dpyinfo, dpyinfo->x_focus_event_frame);
}
the appropriate X display info. */
static void
-XTframe_rehighlight (frame)
- struct frame *frame;
+XTframe_rehighlight (struct frame *frame)
{
x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame));
}
static void
-x_frame_rehighlight (dpyinfo)
- struct x_display_info *dpyinfo;
+x_frame_rehighlight (struct x_display_info *dpyinfo)
{
struct frame *old_highlight = dpyinfo->x_highlight_frame;
/* Initialize mode_switch_bit and modifier_meaning. */
static void
-x_find_modifier_meanings (dpyinfo)
- struct x_display_info *dpyinfo;
+x_find_modifier_meanings (struct x_display_info *dpyinfo)
{
int min_code, max_code;
KeySym *syms;
Emacs uses. */
unsigned int
-x_x_to_emacs_modifiers (dpyinfo, state)
- struct x_display_info *dpyinfo;
- unsigned int state;
+x_x_to_emacs_modifiers (struct x_display_info *dpyinfo, unsigned int state)
{
EMACS_UINT mod_meta = meta_modifier;
EMACS_UINT mod_alt = alt_modifier;
}
static unsigned int
-x_emacs_to_x_modifiers (dpyinfo, state)
- struct x_display_info *dpyinfo;
- unsigned int state;
+x_emacs_to_x_modifiers (struct x_display_info *dpyinfo, unsigned int state)
{
EMACS_UINT mod_meta = meta_modifier;
EMACS_UINT mod_alt = alt_modifier;
/* Convert a keysym to its name. */
char *
-x_get_keysym_name (keysym)
- KeySym keysym;
+x_get_keysym_name (KeySym keysym)
{
char *value;
the mouse. */
static Lisp_Object
-construct_mouse_click (result, event, f)
- struct input_event *result;
- XButtonEvent *event;
- struct frame *f;
+construct_mouse_click (struct input_event *result, XButtonEvent *event, struct frame *f)
{
/* Make the event type NO_EVENT; we'll change that when we decide
otherwise. */
static Lisp_Object last_mouse_motion_frame;
static int
-note_mouse_movement (frame, event)
- FRAME_PTR frame;
- XMotionEvent *event;
+note_mouse_movement (FRAME_PTR frame, XMotionEvent *event)
{
last_mouse_movement_time = event->time;
last_mouse_motion_event = *event;
************************************************************************/
static void
-redo_mouse_highlight ()
+redo_mouse_highlight (void)
{
if (!NILP (last_mouse_motion_frame)
&& FRAME_LIVE_P (XFRAME (last_mouse_motion_frame)))
movement. */
static void
-XTmouse_position (fp, insist, bar_window, part, x, y, time)
- FRAME_PTR *fp;
- int insist;
- Lisp_Object *bar_window;
- enum scroll_bar_part *part;
- Lisp_Object *x, *y;
- unsigned long *time;
+XTmouse_position (FRAME_PTR *fp, int insist, Lisp_Object *bar_window, enum scroll_bar_part *part, Lisp_Object *x, Lisp_Object *y, long unsigned int *time)
{
FRAME_PTR f1;
bits. */
static struct scroll_bar *
-x_window_to_scroll_bar (display, window_id)
- Display *display;
- Window window_id;
+x_window_to_scroll_bar (Display *display, Window window_id)
{
Lisp_Object tail;
amount to scroll of a whole of WHOLE. */
static void
-x_send_scroll_bar_event (window, part, portion, whole)
- Lisp_Object window;
- int part, portion, whole;
+x_send_scroll_bar_event (Lisp_Object window, int part, int portion, int whole)
{
XEvent event;
XClientMessageEvent *ev = (XClientMessageEvent *) &event;
in *IEVENT. */
static void
-x_scroll_bar_to_input_event (event, ievent)
- XEvent *event;
- struct input_event *ievent;
+x_scroll_bar_to_input_event (XEvent *event, struct input_event *ievent)
{
XClientMessageEvent *ev = (XClientMessageEvent *) event;
Lisp_Object window;
#ifdef USE_GTK
static void
-x_create_toolkit_scroll_bar (f, bar)
- struct frame *f;
- struct scroll_bar *bar;
+x_create_toolkit_scroll_bar (struct frame *f, struct scroll_bar *bar)
{
char *scroll_bar_name = SCROLL_BAR_NAME;
#ifdef USE_GTK
static void
-x_set_toolkit_scroll_bar_thumb (bar, portion, position, whole)
- struct scroll_bar *bar;
- int portion, position, whole;
+x_set_toolkit_scroll_bar_thumb (struct scroll_bar *bar, int portion, int position, int whole)
{
xg_set_toolkit_scroll_bar_thumb (bar, portion, position, whole);
}
scroll bar. */
static struct scroll_bar *
-x_scroll_bar_create (w, top, left, width, height)
- struct window *w;
- int top, left, width, height;
+x_scroll_bar_create (struct window *w, int top, int left, int width, int height)
{
struct frame *f = XFRAME (w->frame);
struct scroll_bar *bar
nil. */
static void
-x_scroll_bar_remove (bar)
- struct scroll_bar *bar;
+x_scroll_bar_remove (struct scroll_bar *bar)
{
struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
BLOCK_INPUT;
create one. */
static void
-XTset_vertical_scroll_bar (w, portion, whole, position)
- struct window *w;
- int portion, whole, position;
+XTset_vertical_scroll_bar (struct window *w, int portion, int whole, int position)
{
struct frame *f = XFRAME (w->frame);
struct scroll_bar *bar;
`*redeem_scroll_bar_hook' is applied to its window before the judgment. */
static void
-XTcondemn_scroll_bars (frame)
- FRAME_PTR frame;
+XTcondemn_scroll_bars (FRAME_PTR frame)
{
/* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
while (! NILP (FRAME_SCROLL_BARS (frame)))
Note that WINDOW isn't necessarily condemned at all. */
static void
-XTredeem_scroll_bar (window)
- struct window *window;
+XTredeem_scroll_bar (struct window *window)
{
struct scroll_bar *bar;
struct frame *f;
last call to `*condemn_scroll_bars_hook'. */
static void
-XTjudge_scroll_bars (f)
- FRAME_PTR f;
+XTjudge_scroll_bars (FRAME_PTR f)
{
Lisp_Object bar, next;
static void
-x_scroll_bar_handle_click (bar, event, emacs_event)
- struct scroll_bar *bar;
- XEvent *event;
- struct input_event *emacs_event;
+x_scroll_bar_handle_click (struct scroll_bar *bar, XEvent *event, struct input_event *emacs_event)
{
if (! WINDOWP (bar->window))
abort ();
on the scroll bar. */
static void
-x_scroll_bar_report_motion (fp, bar_window, part, x, y, time)
- FRAME_PTR *fp;
- Lisp_Object *bar_window;
- enum scroll_bar_part *part;
- Lisp_Object *x, *y;
- unsigned long *time;
+x_scroll_bar_report_motion (FRAME_PTR *fp, Lisp_Object *bar_window, enum scroll_bar_part *part, Lisp_Object *x, Lisp_Object *y, long unsigned int *time)
{
struct scroll_bar *bar = XSCROLL_BAR (last_mouse_scroll_bar);
Window w = bar->x_window;
redraw them. */
void
-x_scroll_bar_clear (f)
- FRAME_PTR f;
+x_scroll_bar_clear (FRAME_PTR f)
{
#ifndef USE_TOOLKIT_SCROLL_BARS
Lisp_Object bar;
#ifdef HAVE_X_I18N
static int
-x_filter_event (dpyinfo, event)
- struct x_display_info *dpyinfo;
- XEvent *event;
+x_filter_event (struct x_display_info *dpyinfo, XEvent *event)
{
/* XFilterEvent returns non-zero if the input method has
consumed the event. We pass the frame's X window to
It is invoked before the XEvent is translated to a GdkEvent,
so we have a chance to act on the event before GTK. */
static GdkFilterReturn
-event_handler_gdk (gxev, ev, data)
- GdkXEvent *gxev;
- GdkEvent *ev;
- gpointer data;
+event_handler_gdk (GdkXEvent *gxev, GdkEvent *ev, gpointer data)
{
XEvent *xev = (XEvent *) gxev;
We return the number of characters stored into the buffer. */
static int
-handle_one_xevent (dpyinfo, eventp, finish, hold_quit)
- struct x_display_info *dpyinfo;
- XEvent *eventp;
- int *finish;
- struct input_event *hold_quit;
+handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventp, int *finish, struct input_event *hold_quit)
{
union {
struct input_event ie;
Returns the value handle_one_xevent sets in the finish argument. */
int
-x_dispatch_event (event, display)
- XEvent *event;
- Display *display;
+x_dispatch_event (XEvent *event, Display *display)
{
struct x_display_info *dpyinfo;
int finish = X_EVENT_NORMAL;
EXPECTED is nonzero if the caller knows input is available. */
static int
-XTread_socket (terminal, expected, hold_quit)
- struct terminal *terminal;
- int expected;
- struct input_event *hold_quit;
+XTread_socket (struct terminal *terminal, int expected, struct input_event *hold_quit)
{
int count = 0;
XEvent event;
mode lines must be clipped to the whole window. */
static void
-x_clip_to_row (w, row, area, gc)
- struct window *w;
- struct glyph_row *row;
- int area;
- GC gc;
+x_clip_to_row (struct window *w, struct glyph_row *row, int area, GC gc)
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
XRectangle clip_rect;
/* Draw a hollow box cursor on window W in glyph row ROW. */
static void
-x_draw_hollow_cursor (w, row)
- struct window *w;
- struct glyph_row *row;
+x_draw_hollow_cursor (struct window *w, struct glyph_row *row)
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
--gerd. */
static void
-x_draw_bar_cursor (w, row, width, kind)
- struct window *w;
- struct glyph_row *row;
- int width;
- enum text_cursor_kinds kind;
+x_draw_bar_cursor (struct window *w, struct glyph_row *row, int width, enum text_cursor_kinds kind)
{
struct frame *f = XFRAME (w->frame);
struct glyph *cursor_glyph;
/* RIF: Define cursor CURSOR on frame F. */
static void
-x_define_frame_cursor (f, cursor)
- struct frame *f;
- Cursor cursor;
+x_define_frame_cursor (struct frame *f, Cursor cursor)
{
if (!f->pointer_invisible
&& f->output_data.x->current_cursor != cursor)
/* RIF: Clear area on frame F. */
static void
-x_clear_frame_area (f, x, y, width, height)
- struct frame *f;
- int x, y, width, height;
+x_clear_frame_area (struct frame *f, int x, int y, int width, int height)
{
x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
x, y, width, height, False);
/* RIF: Draw cursor on window W. */
static void
-x_draw_window_cursor (w, glyph_row, x, y, cursor_type, cursor_width, on_p, active_p)
- struct window *w;
- struct glyph_row *glyph_row;
- int x, y;
- int cursor_type, cursor_width;
- int on_p, active_p;
+x_draw_window_cursor (struct window *w, struct glyph_row *glyph_row, int x, int y, int cursor_type, int cursor_width, int on_p, int active_p)
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
/* Make the x-window of frame F use the gnu icon bitmap. */
int
-x_bitmap_icon (f, file)
- struct frame *f;
- Lisp_Object file;
+x_bitmap_icon (struct frame *f, Lisp_Object file)
{
int bitmap_id;
Use ICON_NAME as the text. */
int
-x_text_icon (f, icon_name)
- struct frame *f;
- char *icon_name;
+x_text_icon (struct frame *f, char *icon_name)
{
if (FRAME_X_WINDOW (f) == 0)
return 1;
x_catch_errors is in effect. */
static void
-x_error_catcher (display, error)
- Display *display;
- XErrorEvent *error;
+x_error_catcher (Display *display, XErrorEvent *error)
{
XGetErrorText (display, error->error_code,
x_error_message->string,
Calling x_uncatch_errors resumes the normal error handling. */
-void x_check_errors ();
+void x_check_errors (Display *dpy, char *format);
void
-x_catch_errors (dpy)
- Display *dpy;
+x_catch_errors (Display *dpy)
{
struct x_error_message_stack *data = xmalloc (sizeof (*data));
DPY should be the display that was passed to x_catch_errors. */
void
-x_uncatch_errors ()
+x_uncatch_errors (void)
{
struct x_error_message_stack *tmp;
sprintf (a buffer, FORMAT, the x error message text) as the text. */
void
-x_check_errors (dpy, format)
- Display *dpy;
- char *format;
+x_check_errors (Display *dpy, char *format)
{
/* Make sure to catch any errors incurred so far. */
XSync (dpy, False);
since we did x_catch_errors on DPY. */
int
-x_had_errors_p (dpy)
- Display *dpy;
+x_had_errors_p (Display *dpy)
{
/* Make sure to catch any errors incurred so far. */
XSync (dpy, False);
/* Forget about any errors we have had, since we did x_catch_errors on DPY. */
void
-x_clear_errors (dpy)
- Display *dpy;
+x_clear_errors (Display *dpy)
{
x_error_message->string[0] = 0;
}
/* Nonzero if x_catch_errors has been done and not yet canceled. */
int
-x_catching_errors ()
+x_catching_errors (void)
{
return x_error_message != 0;
}
which will do the appropriate cleanup for us. */
static SIGTYPE
-x_connection_signal (signalnum) /* If we don't have an argument, */
- int signalnum; /* some compilers complain in signal calls. */
+x_connection_signal (int signalnum) /* If we don't have an argument, */
+ /* some compilers complain in signal calls. */
{
#ifdef USG
/* USG systems forget handlers when they are used;
instead of dumping core when XtCloseDisplay fails. */
static void
-x_fatal_error_signal ()
+x_fatal_error_signal (void)
{
fprintf (stderr, "%s\n", error_msg);
exit (70);
the text of an error message that lead to the connection loss. */
static SIGTYPE
-x_connection_closed (dpy, error_message)
- Display *dpy;
- char *error_message;
+x_connection_closed (Display *dpy, char *error_message)
{
struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
Lisp_Object frame, tail;
It calls x_error_quitter or x_error_catcher. */
static int
-x_error_handler (display, error)
- Display *display;
- XErrorEvent *error;
+x_error_handler (Display *display, XErrorEvent *error)
{
if (x_error_message)
x_error_catcher (display, error);
after x_error_handler prevents inlining into the former. */
static void NO_INLINE
-x_error_quitter (display, error)
- Display *display;
- XErrorEvent *error;
+x_error_quitter (Display *display, XErrorEvent *error)
{
char buf[256], buf1[356];
If that was the only one, it prints an error message and kills Emacs. */
static int
-x_io_error_quitter (display)
- Display *display;
+x_io_error_quitter (Display *display)
{
char buf[256];
FONT-OBJECT. */
Lisp_Object
-x_new_font (f, font_object, fontset)
- struct frame *f;
- Lisp_Object font_object;
- int fontset;
+x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
{
struct font *font = XFONT_OBJECT (font_object);
pointer to the x_display_info structure corresponding to XIM. */
static void
-xim_destroy_callback (xim, client_data, call_data)
- XIM xim;
- XPointer client_data;
- XPointer call_data;
+xim_destroy_callback (XIM xim, XPointer client_data, XPointer call_data)
{
struct x_display_info *dpyinfo = (struct x_display_info *) client_data;
Lisp_Object frame, tail;
RESOURCE_NAME is the resource name Emacs uses. */
static void
-xim_open_dpy (dpyinfo, resource_name)
- struct x_display_info *dpyinfo;
- char *resource_name;
+xim_open_dpy (struct x_display_info *dpyinfo, char *resource_name)
{
XIM xim;
when the callback was registered. */
static void
-xim_instantiate_callback (display, client_data, call_data)
- Display *display;
- XPointer client_data;
- XPointer call_data;
+xim_instantiate_callback (Display *display, XPointer client_data, XPointer call_data)
{
struct xim_inst_t *xim_inst = (struct xim_inst_t *) client_data;
struct x_display_info *dpyinfo = xim_inst->dpyinfo;
in the XIM instantiate callback function. */
static void
-xim_initialize (dpyinfo, resource_name)
- struct x_display_info *dpyinfo;
- char *resource_name;
+xim_initialize (struct x_display_info *dpyinfo, char *resource_name)
{
dpyinfo->xim = NULL;
#ifdef HAVE_XIM
/* Close the connection to the XIM server on display DPYINFO. */
static void
-xim_close_dpy (dpyinfo)
- struct x_display_info *dpyinfo;
+xim_close_dpy (struct x_display_info *dpyinfo)
{
#ifdef HAVE_XIM
if (use_xim)
from its current recorded position values and gravity. */
void
-x_calc_absolute_position (f)
- struct frame *f;
+x_calc_absolute_position (struct frame *f)
{
int flags = f->size_hint_flags;
which means, do adjust for borders but don't change the gravity. */
void
-x_set_offset (f, xoff, yoff, change_gravity)
- struct frame *f;
- register int xoff, yoff;
- int change_gravity;
+x_set_offset (struct frame *f, register int xoff, register int yoff, int change_gravity)
{
int modified_top, modified_left;
http://freedesktop.org/wiki/Specifications/wm-spec. */
static int
-wm_supports (f, atomname)
- struct frame *f;
- const char *atomname;
+wm_supports (struct frame *f, const char *atomname)
{
Atom actual_type;
unsigned long actual_size, bytes_remaining;
}
static void
-set_wm_state (frame, add, what, what2)
- Lisp_Object frame;
- int add;
- const char *what;
- const char *what2;
+set_wm_state (Lisp_Object frame, int add, const char *what, const char *what2)
{
const char *atom = "_NET_WM_STATE";
Fx_send_client_event (frame, make_number (0), frame,
}
void
-x_set_sticky (f, new_value, old_value)
- struct frame *f;
- Lisp_Object new_value, old_value;
+x_set_sticky (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
{
Lisp_Object frame;
/* Do fullscreen as specified in extended window manager hints */
static int
-do_ewmh_fullscreen (f)
- struct frame *f;
+do_ewmh_fullscreen (struct frame *f)
{
int have_net_atom = wm_supports (f, "_NET_WM_STATE");
}
static void
-XTfullscreen_hook (f)
- FRAME_PTR f;
+XTfullscreen_hook (FRAME_PTR f)
{
if (f->async_visible)
{
static void
-x_handle_net_wm_state (f, event)
- struct frame *f;
- XPropertyEvent *event;
+x_handle_net_wm_state (struct frame *f, XPropertyEvent *event)
{
Atom actual_type;
unsigned long actual_size, bytes_remaining;
/* Check if we need to resize the frame due to a fullscreen request.
If so needed, resize the frame. */
static void
-x_check_fullscreen (f)
- struct frame *f;
+x_check_fullscreen (struct frame *f)
{
if (do_ewmh_fullscreen (f))
return;
compensate by moving the window right and down by the proper amount. */
static void
-x_check_expected_move (f, expected_left, expected_top)
- struct frame *f;
- int expected_left;
- int expected_top;
+x_check_expected_move (struct frame *f, int expected_left, int expected_top)
{
int current_left = 0, current_top = 0;
of an exact comparison. */
static void
-x_sync_with_move (f, left, top, fuzzy)
- struct frame *f;
- int left, top, fuzzy;
+x_sync_with_move (struct frame *f, int left, int top, int fuzzy)
{
int count = 0;
/* Wait for an event on frame F matching EVENTTYPE. */
void
-x_wait_for_event (f, eventtype)
- struct frame *f;
- int eventtype;
+x_wait_for_event (struct frame *f, int eventtype)
{
int level = interrupt_input_blocked;
size changes. Otherwise we leave the window gravity unchanged. */
static void
-x_set_window_size_1 (f, change_gravity, cols, rows)
- struct frame *f;
- int change_gravity;
- int cols, rows;
+x_set_window_size_1 (struct frame *f, int change_gravity, int cols, int rows)
{
int pixelwidth, pixelheight;
Otherwise we leave the window gravity unchanged. */
void
-x_set_window_size (f, change_gravity, cols, rows)
- struct frame *f;
- int change_gravity;
- int cols, rows;
+x_set_window_size (struct frame *f, int change_gravity, int cols, int rows)
{
BLOCK_INPUT;
/* Mouse warping. */
void
-x_set_mouse_position (f, x, y)
- struct frame *f;
- int x, y;
+x_set_mouse_position (struct frame *f, int x, int y)
{
int pix_x, pix_y;
/* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
void
-x_set_mouse_pixel_position (f, pix_x, pix_y)
- struct frame *f;
- int pix_x, pix_y;
+x_set_mouse_pixel_position (struct frame *f, int pix_x, int pix_y)
{
BLOCK_INPUT;
/* focus shifting, raising and lowering. */
void
-x_focus_on_frame (f)
- struct frame *f;
+x_focus_on_frame (struct frame *f)
{
#if 0
/* I don't think that the ICCCM allows programs to do things like this
}
void
-x_unfocus_frame (f)
- struct frame *f;
+x_unfocus_frame (struct frame *f)
{
#if 0
/* Look at the remarks in x_focus_on_frame. */
/* Raise frame F. */
void
-x_raise_frame (f)
- struct frame *f;
+x_raise_frame (struct frame *f)
{
BLOCK_INPUT;
if (f->async_visible)
/* Lower frame F. */
void
-x_lower_frame (f)
- struct frame *f;
+x_lower_frame (struct frame *f)
{
if (f->async_visible)
{
/* Activate frame with Extended Window Manager Hints */
void
-x_ewmh_activate_frame (f)
- FRAME_PTR f;
+x_ewmh_activate_frame (FRAME_PTR f)
{
/* See Window Manager Specification/Extended Window Manager Hints at
http://freedesktop.org/wiki/Specifications/wm-spec */
}
static void
-XTframe_raise_lower (f, raise_flag)
- FRAME_PTR f;
- int raise_flag;
+XTframe_raise_lower (FRAME_PTR f, int raise_flag)
{
if (raise_flag)
x_raise_frame (f);
/* XEmbed implementation. */
void
-xembed_set_info (f, flags)
- struct frame *f;
- enum xembed_info flags;
+xembed_set_info (struct frame *f, enum xembed_info flags)
{
Atom atom;
unsigned long data[2];
}
void
-xembed_send_message (f, time, message, detail, data1, data2)
- struct frame *f;
- Time time;
- enum xembed_message message;
- long detail;
- long data1;
- long data2;
+xembed_send_message (struct frame *f, Time time, enum xembed_message message, long int detail, long int data1, long int data2)
{
XEvent event;
finishes with it. */
void
-x_make_frame_visible (f)
- struct frame *f;
+x_make_frame_visible (struct frame *f)
{
Lisp_Object type;
int original_top, original_left;
/* Make the frame visible (mapped and not iconified). */
void
-x_make_frame_invisible (f)
- struct frame *f;
+x_make_frame_invisible (struct frame *f)
{
Window window;
/* Change window state from mapped to iconified. */
void
-x_iconify_frame (f)
- struct frame *f;
+x_iconify_frame (struct frame *f)
{
int result;
Lisp_Object type;
/* Free X resources of frame F. */
void
-x_free_frame_resources (f)
- struct frame *f;
+x_free_frame_resources (struct frame *f)
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
Lisp_Object bar;
/* Destroy the X window of frame F. */
void
-x_destroy_window (f)
- struct frame *f;
+x_destroy_window (struct frame *f)
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
/* Used for IconicState or NormalState */
void
-x_wm_set_window_state (f, state)
- struct frame *f;
- int state;
+x_wm_set_window_state (struct frame *f, int state)
{
#ifdef USE_X_TOOLKIT
Arg al[1];
}
void
-x_wm_set_icon_pixmap (f, pixmap_id)
- struct frame *f;
- int pixmap_id;
+x_wm_set_icon_pixmap (struct frame *f, int pixmap_id)
{
Pixmap icon_pixmap, icon_mask;
}
void
-x_wm_set_icon_position (f, icon_x, icon_y)
- struct frame *f;
- int icon_x, icon_y;
+x_wm_set_icon_position (struct frame *f, int icon_x, int icon_y)
{
Window window = FRAME_OUTER_WINDOW (f);
/* Test whether two display-name strings agree up to the dot that separates
the screen number from the server number. */
static int
-same_x_server (name1, name2)
- const char *name1, *name2;
+same_x_server (const char *name1, const char *name2)
{
int seen_colon = 0;
const unsigned char *system_name = SDATA (Vsystem_name);
get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
to 5. */
static void
-get_bits_and_offset (mask, bits, offset)
- unsigned long mask;
- int *bits;
- int *offset;
+get_bits_and_offset (long unsigned int mask, int *bits, int *offset)
{
int nr = 0;
int off = 0;
But don't permanently open it, just test its availability. */
int
-x_display_ok (display)
- const char *display;
+x_display_ok (const char *display)
{
int dpy_ok = 1;
Display *dpy;
#ifdef USE_GTK
static void
-my_log_handler (log_domain, log_level, message, user_data)
- const gchar *log_domain;
- GLogLevelFlags log_level;
- const gchar *message;
- gpointer user_data;
+my_log_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data)
{
if (!strstr (message, "g_set_prgname"))
fprintf (stderr, "%s-WARNING **: %s\n", log_domain, message);
If we cannot contact the display, return null. */
struct x_display_info *
-x_term_init (display_name, xrm_option, resource_name)
- Lisp_Object display_name;
- char *xrm_option;
- char *resource_name;
+x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
{
int connection;
Display *dpy;
and without sending any more commands to the X server. */
void
-x_delete_display (dpyinfo)
- struct x_display_info *dpyinfo;
+x_delete_display (struct x_display_info *dpyinfo)
{
struct terminal *t;
}
void
-x_initialize ()
+x_initialize (void)
{
baud_rate = 19200;
void
-syms_of_xterm ()
+syms_of_xterm (void)
{
x_error_message = NULL;
projects / emacs.git / commitdiff