#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))
{
CHECK_NUMBER (newval);
*XINTFWD (valcontents)->intvar = XINT (newval);
break;
-
+
case Lisp_Fwd_Bool:
*XBOOLFWD (valcontents)->boolvar = !NILP (newval);
break;
-
+
case Lisp_Fwd_Obj:
*XOBJFWD (valcontents)->objvar = newval;
-
+
/* If this variable is a default for something stored
in the buffer itself, such as default-fill-column,
find the buffers that don't have local values for it
int offset = ((char *) XOBJFWD (valcontents)->objvar
- (char *) &buffer_defaults);
int idx = PER_BUFFER_IDX (offset);
-
+
Lisp_Object tail;
-
+
if (idx <= 0)
break;
-
+
for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
{
Lisp_Object buf;
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;
Lisp_Object tail, elt, tmp;
struct Lisp_Buffer_Local_Value *blv = SYMBOL_BLV (sym);
XSETBUFFER (tmp, buf);
-
+
for (tail = buf->local_var_alist; CONSP (tail); tail = XCDR (tail))
{
elt = XCAR (tail);
/* This code is disabled now that we use the selected frame to return
keyboard-local-values. */
#if 0
-extern struct terminal *get_terminal P_ ((Lisp_Object display, int));
+extern struct terminal *get_terminal (Lisp_Object display, int);
DEFUN ("terminal-local-value", Fterminal_local_value, Sterminal_local_value, 2, 2, 0,
doc: /* Return the terminal-local value of SYMBOL on TERMINAL.
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;
idxval_byte = string_char_to_byte (array, idxval);
p1 = SDATA (array) + idxval_byte;
- PARSE_MULTIBYTE_SEQ (p1, nbytes - idxval_byte, prev_bytes);
+ prev_bytes = BYTES_BY_CHAR_HEAD (*p1);
new_bytes = CHAR_STRING (XINT (newelt), p0);
if (prev_bytes != new_bytes)
{
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;
Amin
};
-static Lisp_Object float_arith_driver P_ ((double, int, enum arithop,
- int, Lisp_Object *));
+static Lisp_Object float_arith_driver (double, int, enum arithop,
+ int, Lisp_Object *);
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
HCoop / bpt / emacs.git / blobdiff