+2011-04-29 Paul Eggert <eggert@cs.ucla.edu>
+
+ * configure.in (BITS_PER_LONG_LONG): New macro.
+
2011-04-27 Ben Key <bkey76@gmail.com>
* configure.in: Fixed a bug that caused configure with
#endif
/* These default definitions are good for almost all machines.
- The exceptions override them in m/MACHINE.h. */
+ Any exceptions should override them in m/MACHINE.h.
+ They must be usable in preprocessor conditionals. */
#ifndef BITS_PER_CHAR
#define BITS_PER_CHAR 8
#define BITS_PER_SHORT 16
#endif
-/* Note that lisp.h uses this in a preprocessor conditional, so it
- would not work to use sizeof. That being so, we do all of them
- without sizeof, for uniformity's sake. */
#ifndef BITS_PER_INT
#define BITS_PER_INT 32
#endif
#endif
#endif
+#if !defined BITS_PER_LONG_LONG && HAVE_LONG_LONG_INT
+#define BITS_PER_LONG_LONG 64
+#endif
+
/* Define if the compiler supports function prototypes. It may do so but
not define __STDC__ (e.g. DEC C by default) or may define it as zero. */
#undef PROTOTYPES
+2011-04-30 Paul Eggert <eggert@cs.ucla.edu>
+
+ * config.nt: Configure 64-bit integers for older compilers.
+ (EMACS_INT, BITS_PER_EMACS_INT, pI): Define these if __int64 and
+ "%I64d" work but long long and "%lld" do not.
+
2011-04-30 Eli Zaretskii <eliz@gnu.org>
* config.nt (HAVE_LONG_LONG_INT, HAVE_UNSIGNED_LONG_LONG_INT):
You should have received a copy of the GNU General Public License
along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
-
/* Define to 1 if the system has the type `unsigned long long int'. */
# define HAVE_UNSIGNED_LONG_LONG_INT 1
-#endif /* __MINGW32__ || _MSC_VER >= 1400 */
+#elif _MSC_VER >= 1200
+
+/* Use pre-C99-style 64-bit integers. */
+# define EMACS_INT __int64
+# define BITS_PER_EMACS_INT 64
+# define pI "I64"
+
+#endif
#ifndef POINTER_TYPE
#define POINTER_TYPE void
/* Make a leaner executable. */
#define WIN32_LEAN_AND_MEAN 1
-
+2011-04-30 Paul Eggert <eggert@cs.ucla.edu>
+
+ * dispnew.c (scrolling_window): Return 1 if we scrolled,
+ to match comment at start of function. This also removes a
+ GCC warning about overflow in a 32+64-bit port.
+
+ * lisp.h (EMACS_INT, EMACS_UINT, BITS_PER_EMACS_INT, pI): Simplify.
+
+ * dbusbind.c: Do not use XPNTR on a value that may be an integer.
+ Reported by Stefan Monnier in
+ <http://lists.gnu.org/archive/html/emacs-devel/2011-04/msg00919.html>.
+ (xd_remove_watch, Fdbus_init_bus, xd_read_queued_messages): Use
+ SYMBOLP-guarded XSYMBOL, not XPNTR.
+
+ * lisp.h (EMACS_INTPTR): Remove. All uses changed to intptr_t.
+ (EMACS_UINTPTR): Likewise, with uintptr_t.
+
+ * lisp.h: Prefer 64-bit EMACS_INT if available.
+ (EMACS_INT, EMACS_UINT, BITS_PER_EMACS_INT, pI): Define to 64-bit
+ on 32-bit hosts that have 64-bit int, so that they can access
+ large files.
+
+ * lread.c, process.c: Do not include <inttypes.h>; lisp.h does it now.
+
+ Prefer intptr_t/uintptr_t for integers the same widths as pointers.
+ This removes an assumption that EMACS_INT and long are the same
+ width as pointers. The assumption is true for Emacs porting targets
+ now, but we want to make other targets possible.
+ * lisp.h: Include <inttypes.h>, for INTPTR_MAX, UINTPTR_MAX.
+ (EMACS_INTPTR, EMACS_UINTPTR): New macros.
+ In the rest of the code, change types of integers that hold casted
+ pointers to EMACS_INTPTR and EMACS_UINTPTR, systematically
+ replacing EMACS_INT, long, EMACS_UINT, and unsigned long.
+ (XTYPE): Don't cast arg to EMACS_UINT; normally is not needed.
+ (XSET): Cast type of XTYPE arg to EMACS_INTPTR; it is needed here.
+ No need to cast type when ORing.
+ (XPNTR): Return a value of type EMACS_INTPTR or EMACS_UINTPTR.
+ * alloc.c (lisp_align_malloc): Remove a no-longer-needed cast.
+ * doc.c (store_function_docstring): Use EMACS_INTPTR, so as not to
+ assume EMACS_INT is the same width as char *.
+ * gtkutil.c (xg_gtk_scroll_destroy, xg_tool_bar_button_cb):
+ (xg_tool_bar_callback, xg_tool_bar_help_callback, xg_make_tool_item):
+ Remove no-longer-needed casts.
+ (xg_create_scroll_bar, xg_tool_bar_button_cb, xg_tool_bar_callback):
+ (xg_tool_bar_help_callback, xg_make_tool_item):
+ Use EMACS_INTPTR to hold an integer
+ that will be cast to void *; this can avoid a GCC warning
+ if EMACS_INT is not the same width as void *.
+ * menu.c (find_and_call_menu_selection): Remove no-longer-needed cast.
+ * xdisp.c (display_echo_area_1, resize_mini_window_1):
+ (current_message_1, set_message_1):
+ Use a local to convert to proper width without a cast.
+ * xmenu.c (dialog_selection_callback): Likewise.
+
+ * sysdep.c (get_random): Don't assume EMACS_INT is no wider than long.
+ Also, don't assume VALBITS / RAND_BITS is less than 5,
+ and don't rely on undefined behavior when shifting a 1 left into
+ the sign bit.
+ * lisp.h (get_random): Change signature to match.
+
+ * lread.c (hash_string): Use size_t, not int, for hash computation.
+ Normally we prefer signed values; but hashing is special, because
+ it's better to use unsigned division on hash table sizes so that
+ the remainder is nonnegative. Also, size_t is the natural width
+ for hashing into memory. The previous code used 'int', which doesn't
+ retain enough info to hash well into very large tables.
+ (oblookup, oblookup_last_bucket_number, Funintern): Likewise.
+
+ * dbusbind.c: Don't possibly lose pointer info when converting.
+ (xd_remove_watch, Fdbus_init_bus, xd_read_queued_messages):
+ Use XPNTR rather than XHASH, so that the high-order bits of
+ the pointer aren't lost when converting through void *.
+
+ * eval.c (Fautoload): Don't double-shift a pointer.
+
+ * fns.c (Frandom): Let EMACS_UINT be wider than unsigned long.
+
2011-04-30 Eli Zaretskii <eliz@gnu.org>
* dosfns.c (Fint86, Fdos_memget, Fdos_memput): Use `ASIZE (FOO)'
ALIGNMENT must be a power of 2. */
#define ALIGN(ptr, ALIGNMENT) \
- ((POINTER_TYPE *) ((((EMACS_UINT)(ptr)) + (ALIGNMENT) - 1) \
+ ((POINTER_TYPE *) ((((uintptr_t) (ptr)) + (ALIGNMENT) - 1) \
& ~((ALIGNMENT) - 1)))
#define ABLOCKS_BYTES (sizeof (struct ablocks) - BLOCK_PADDING)
#define ABLOCK_ABASE(block) \
- (((unsigned long) (block)->abase) <= (1 + 2 * ABLOCKS_SIZE) \
+ (((uintptr_t) (block)->abase) <= (1 + 2 * ABLOCKS_SIZE) \
? (struct ablocks *)(block) \
: (block)->abase)
#define ABLOCKS_BASE(abase) (abase)
#else
#define ABLOCKS_BASE(abase) \
- (1 & (long) ABLOCKS_BUSY (abase) ? abase : ((void**)abase)[-1])
+ (1 & (intptr_t) ABLOCKS_BUSY (abase) ? abase : ((void**)abase)[-1])
#endif
/* The list of free ablock. */
if (!free_ablock)
{
int i;
- EMACS_INT aligned; /* int gets warning casting to 64-bit pointer. */
+ intptr_t aligned; /* int gets warning casting to 64-bit pointer. */
#ifdef DOUG_LEA_MALLOC
/* Prevent mmap'ing the chunk. Lisp data may not be mmap'ed
abase->blocks[i].x.next_free = free_ablock;
free_ablock = &abase->blocks[i];
}
- ABLOCKS_BUSY (abase) = (struct ablocks *) (long) aligned;
+ ABLOCKS_BUSY (abase) = (struct ablocks *) aligned;
- eassert (0 == ((EMACS_UINT)abase) % BLOCK_ALIGN);
+ eassert (0 == ((uintptr_t) abase) % BLOCK_ALIGN);
eassert (ABLOCK_ABASE (&abase->blocks[3]) == abase); /* 3 is arbitrary */
eassert (ABLOCK_ABASE (&abase->blocks[0]) == abase);
eassert (ABLOCKS_BASE (abase) == base);
- eassert (aligned == (long) ABLOCKS_BUSY (abase));
+ eassert (aligned == (intptr_t) ABLOCKS_BUSY (abase));
}
abase = ABLOCK_ABASE (free_ablock);
- ABLOCKS_BUSY (abase) = (struct ablocks *) (2 + (long) ABLOCKS_BUSY (abase));
+ ABLOCKS_BUSY (abase) =
+ (struct ablocks *) (2 + (intptr_t) ABLOCKS_BUSY (abase));
val = free_ablock;
free_ablock = free_ablock->x.next_free;
if (!val && nbytes)
memory_full ();
- eassert (0 == ((EMACS_UINT)val) % BLOCK_ALIGN);
+ eassert (0 == ((uintptr_t) val) % BLOCK_ALIGN);
return val;
}
ablock->x.next_free = free_ablock;
free_ablock = ablock;
/* Update busy count. */
- ABLOCKS_BUSY (abase) = (struct ablocks *) (-2 + (long) ABLOCKS_BUSY (abase));
+ ABLOCKS_BUSY (abase) =
+ (struct ablocks *) (-2 + (intptr_t) ABLOCKS_BUSY (abase));
- if (2 > (long) ABLOCKS_BUSY (abase))
+ if (2 > (intptr_t) ABLOCKS_BUSY (abase))
{ /* All the blocks are free. */
- int i = 0, aligned = (long) ABLOCKS_BUSY (abase);
+ int i = 0, aligned = (intptr_t) ABLOCKS_BUSY (abase);
struct ablock **tem = &free_ablock;
struct ablock *atop = &abase->blocks[aligned ? ABLOCKS_SIZE : ABLOCKS_SIZE - 1];
eassert ((aligned & 1) == aligned);
eassert (i == (aligned ? ABLOCKS_SIZE : ABLOCKS_SIZE - 1));
#ifdef USE_POSIX_MEMALIGN
- eassert ((unsigned long)ABLOCKS_BASE (abase) % BLOCK_ALIGN == 0);
+ eassert ((uintptr_t) ABLOCKS_BASE (abase) % BLOCK_ALIGN == 0);
#endif
free (ABLOCKS_BASE (abase));
}
s = string_free_list;
while (s != NULL)
{
- if ((unsigned long)s < 1024)
+ if ((uintptr_t) s < 1024)
abort();
s = NEXT_FREE_LISP_STRING (s);
}
&= ~(1 << ((n) % (sizeof(int) * CHAR_BIT)))
#define FLOAT_BLOCK(fptr) \
- ((struct float_block *)(((EMACS_UINT)(fptr)) & ~(BLOCK_ALIGN - 1)))
+ ((struct float_block *) (((uintptr_t) (fptr)) & ~(BLOCK_ALIGN - 1)))
#define FLOAT_INDEX(fptr) \
- ((((EMACS_UINT)(fptr)) & (BLOCK_ALIGN - 1)) / sizeof (struct Lisp_Float))
+ ((((uintptr_t) (fptr)) & (BLOCK_ALIGN - 1)) / sizeof (struct Lisp_Float))
struct float_block
{
/ (sizeof (struct Lisp_Cons) * CHAR_BIT + 1))
#define CONS_BLOCK(fptr) \
- ((struct cons_block *)(((EMACS_UINT)(fptr)) & ~(BLOCK_ALIGN - 1)))
+ ((struct cons_block *) ((uintptr_t) (fptr) & ~(BLOCK_ALIGN - 1)))
#define CONS_INDEX(fptr) \
- ((((EMACS_UINT)(fptr)) & (BLOCK_ALIGN - 1)) / sizeof (struct Lisp_Cons))
+ (((uintptr_t) (fptr) & (BLOCK_ALIGN - 1)) / sizeof (struct Lisp_Cons))
struct cons_block
{
struct mem_node *m;
/* Quickly rule out some values which can't point to Lisp data. */
- if ((EMACS_INT) p %
+ if ((intptr_t) p %
#ifdef USE_LSB_TAG
8 /* USE_LSB_TAG needs Lisp data to be aligned on multiples of 8. */
#else
{
Lisp_Object end;
- XSETINT (end, (EMACS_INT) (char *) sbrk (0) / 1024);
+ XSETINT (end, (intptr_t) (char *) sbrk (0) / 1024);
return end;
}
return;
/* Unset session environment. */
- if (data != NULL && data == (void*) XHASH (QCdbus_session_bus))
+ if (SYMBOLP (QCdbus_session_bus) && XSYMBOL (QCdbus_session_bus) == data)
{
XD_DEBUG_MESSAGE ("unsetenv DBUS_SESSION_BUS_ADDRESS");
unsetenv ("DBUS_SESSION_BUS_ADDRESS");
{
DBusConnection *connection;
+ CHECK_SYMBOL (bus);
+
/* Open a connection to the bus. */
connection = xd_initialize (bus, TRUE);
xd_add_watch,
xd_remove_watch,
xd_toggle_watch,
- (void*) XHASH (bus), NULL))
+ XSYMBOL (bus), NULL))
XD_SIGNAL1 (build_string ("Cannot add watch functions"));
/* Add bus to list of registered buses. */
if (data != NULL)
while (!NILP (busp))
{
- if (data == (void*) XHASH (CAR_SAFE (busp)))
+ if (SYMBOLP (CAR_SAFE (busp)) && XSYMBOL (CAR_SAFE (busp)) == data)
bus = CAR_SAFE (busp);
busp = CDR_SAFE (busp);
}
for (i = 0; i < row_entry_idx; ++i)
row_table[row_entry_pool[i].bucket] = NULL;
- /* Value is > 0 to indicate that we scrolled the display. */
- return nruns;
+ /* Value is 1 to indicate that we scrolled the display. */
+ return 0 < nruns;
}
return Qnil;
/* FIXME: This is not portable, as it assumes that string
pointers have the top bit clear. */
- else if ((EMACS_INT) XSUBR (fun)->doc >= 0)
+ else if ((intptr_t) XSUBR (fun)->doc >= 0)
doc = build_string (XSUBR (fun)->doc);
else
- doc = make_number ((EMACS_INT) XSUBR (fun)->doc);
+ doc = make_number ((intptr_t) XSUBR (fun)->doc);
}
else if (COMPILEDP (fun))
{
/* The type determines where the docstring is stored. */
/* Lisp_Subrs have a slot for it. */
- if (SUBRP (fun))
- XSUBR (fun)->doc = (char *) - offset;
+ if (SUBRP (fun))
+ {
+ intptr_t negative_offset = - offset;
+ XSUBR (fun)->doc = (char *) negative_offset;
+ }
/* If it's a lisp form, stick it in the form. */
else if (CONSP (fun))
We used to use 0 here, but that leads to accidental sharing in
purecopy's hash-consing, so we use a (hopefully) unique integer
instead. */
- docstring = make_number (XHASH (function));
+ docstring = make_number (XPNTR (function));
return Ffset (function,
Fpurecopy (list5 (Qautoload, file, docstring,
interactive, type)));
{
EMACS_INT val;
Lisp_Object lispy_val;
- unsigned long denominator;
+ EMACS_UINT denominator;
if (EQ (limit, Qt))
seed_random (getpid () + time (NULL));
it's possible to get a quotient larger than n; discarding
these values eliminates the bias that would otherwise appear
when using a large n. */
- denominator = ((unsigned long)1 << VALBITS) / XFASTINT (limit);
+ denominator = ((EMACS_UINT) 1 << VALBITS) / XFASTINT (limit);
do
val = get_random () / denominator;
while (val >= XFASTINT (limit));
static void
xg_gtk_scroll_destroy (GtkWidget *widget, gpointer data)
{
- int id = (int) (EMACS_INT) data; /* The EMACS_INT cast avoids a warning. */
+ int id = (intptr_t) data;
xg_remove_widget_from_map (id);
}
{
GtkWidget *wscroll;
GtkWidget *webox;
- int scroll_id;
+ intptr_t scroll_id;
#ifdef HAVE_GTK3
GtkAdjustment *vadj;
#else
scroll_id = xg_store_widget_in_map (wscroll);
- /* The EMACS_INT cast avoids a warning. */
g_signal_connect (G_OBJECT (wscroll),
"destroy",
G_CALLBACK (xg_gtk_scroll_destroy),
- (gpointer) (EMACS_INT) scroll_id);
+ (gpointer) scroll_id);
g_signal_connect (G_OBJECT (wscroll),
"change-value",
scroll_callback,
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;
+ intptr_t state = event->state;
+ gpointer ptr = (gpointer) state;
g_object_set_data (G_OBJECT (widget), XG_TOOL_BAR_LAST_MODIFIER, ptr);
return FALSE;
}
static void
xg_tool_bar_callback (GtkWidget *w, gpointer client_data)
{
- /* The EMACS_INT cast avoids a warning. */
- int idx = (int) (EMACS_INT) client_data;
+ intptr_t idx = (intptr_t) client_data;
gpointer gmod = g_object_get_data (G_OBJECT (w), XG_TOOL_BAR_LAST_MODIFIER);
- int mod = (int) (EMACS_INT) gmod;
+ intptr_t mod = (intptr_t) gmod;
FRAME_PTR f = (FRAME_PTR) g_object_get_data (G_OBJECT (w), XG_FRAME_DATA);
Lisp_Object key, frame;
GdkEventCrossing *event,
gpointer client_data)
{
- /* The EMACS_INT cast avoids a warning. */
- int idx = (int) (EMACS_INT) client_data;
+ intptr_t idx = (intptr_t) client_data;
FRAME_PTR f = (FRAME_PTR) g_object_get_data (G_OBJECT (w), XG_FRAME_DATA);
Lisp_Object help, frame;
if (wimage)
{
- /* The EMACS_INT cast avoids a warning. */
+ intptr_t ii = i;
+ gpointer gi = (gpointer) ii;
+
g_signal_connect (G_OBJECT (ti), "create-menu-proxy",
G_CALLBACK (xg_tool_bar_menu_proxy),
- (gpointer) (EMACS_INT) i);
+ gi);
g_signal_connect (G_OBJECT (wb), "clicked",
G_CALLBACK (xg_tool_bar_callback),
- (gpointer) (EMACS_INT) i);
+ gi);
g_object_set_data (G_OBJECT (weventbox), XG_FRAME_DATA, (gpointer)f);
g_signal_connect (G_OBJECT (weventbox),
"enter-notify-event",
G_CALLBACK (xg_tool_bar_help_callback),
- (gpointer) (EMACS_INT) i);
+ gi);
g_signal_connect (G_OBJECT (weventbox),
"leave-notify-event",
G_CALLBACK (xg_tool_bar_help_callback),
- (gpointer) (EMACS_INT) i);
+ gi);
}
if (wbutton) *wbutton = wb;
#include <stdarg.h>
#include <stddef.h>
+#include <inttypes.h>
/* Use the configure flag --enable-checking[=LIST] to enable various
types of run time checks for Lisp objects. */
#endif
/* These are default choices for the types to use. */
-#ifdef _LP64
#ifndef EMACS_INT
-#define EMACS_INT long
-#define BITS_PER_EMACS_INT BITS_PER_LONG
-#define pI "l"
-#endif
-#ifndef EMACS_UINT
-#define EMACS_UINT unsigned long
-#endif
-#else /* not _LP64 */
-#ifndef EMACS_INT
-#define EMACS_INT int
-#define BITS_PER_EMACS_INT BITS_PER_INT
-#define pI ""
+# if BITS_PER_LONG < BITS_PER_LONG_LONG
+# define EMACS_INT long long
+# define BITS_PER_EMACS_INT BITS_PER_LONG_LONG
+# define pI "ll"
+# elif BITS_PER_INT < BITS_PER_LONG
+# define EMACS_INT long
+# define BITS_PER_EMACS_INT BITS_PER_LONG
+# define pI "l"
+# else
+# define EMACS_INT int
+# define BITS_PER_EMACS_INT BITS_PER_INT
+# define pI ""
+# endif
#endif
#ifndef EMACS_UINT
-#define EMACS_UINT unsigned int
-#endif
+# define EMACS_UINT unsigned EMACS_INT
#endif
/* Extra internal type checking? */
#ifdef USE_LSB_TAG
#define TYPEMASK ((((EMACS_INT) 1) << GCTYPEBITS) - 1)
-#define XTYPE(a) ((enum Lisp_Type) (((EMACS_UINT) (a)) & TYPEMASK))
+#define XTYPE(a) ((enum Lisp_Type) ((a) & TYPEMASK))
#ifdef USE_2_TAGS_FOR_INTS
# define XINT(a) (((EMACS_INT) (a)) >> (GCTYPEBITS - 1))
# define XUINT(a) (((EMACS_UINT) (a)) >> (GCTYPEBITS - 1))
# define XUINT(a) (((EMACS_UINT) (a)) >> GCTYPEBITS)
# define make_number(N) (((EMACS_INT) (N)) << GCTYPEBITS)
#endif
-#define XSET(var, type, ptr) \
- (eassert (XTYPE (ptr) == 0), /* Check alignment. */ \
- (var) = ((EMACS_INT) (type)) | ((EMACS_INT) (ptr)))
+#define XSET(var, type, ptr) \
+ (eassert (XTYPE ((intptr_t) (ptr)) == 0), /* Check alignment. */ \
+ (var) = (type) | (intptr_t) (ptr))
-#define XPNTR(a) ((EMACS_INT) ((a) & ~TYPEMASK))
+#define XPNTR(a) ((intptr_t) ((a) & ~TYPEMASK))
#else /* not USE_LSB_TAG */
#define XSET(var, type, ptr) \
((var) = ((EMACS_INT) ((EMACS_UINT) (type) << VALBITS) \
- + ((EMACS_INT) (ptr) & VALMASK)))
+ + ((intptr_t) (ptr) & VALMASK)))
#ifdef DATA_SEG_BITS
/* DATA_SEG_BITS forces extra bits to be or'd in with any pointers
which were stored in a Lisp_Object */
-#define XPNTR(a) ((EMACS_UINT) (((a) & VALMASK) | DATA_SEG_BITS))
+#define XPNTR(a) ((uintptr_t) (((a) & VALMASK)) | DATA_SEG_BITS))
#else
-#define XPNTR(a) ((EMACS_UINT) ((a) & VALMASK))
+#define XPNTR(a) ((uintptr_t) ((a) & VALMASK))
#endif
#endif /* not USE_LSB_TAG */
/* Some versions of gcc seem to consider the bitfield width when issuing
the "cast to pointer from integer of different size" warning, so the
cast is here to widen the value back to its natural size. */
-# define XPNTR(v) ((EMACS_INT)((v).s.val) << GCTYPEBITS)
+# define XPNTR(v) ((intptr_t) (v).s.val << GCTYPEBITS)
#else /* !USE_LSB_TAG */
#ifdef DATA_SEG_BITS
/* DATA_SEG_BITS forces extra bits to be or'd in with any pointers
which were stored in a Lisp_Object */
-#define XPNTR(a) (XUINT (a) | DATA_SEG_BITS)
+#define XPNTR(a) ((intptr_t) (XUINT (a) | DATA_SEG_BITS))
#else
-#define XPNTR(a) ((EMACS_INT) XUINT (a))
+#define XPNTR(a) ((intptr_t) XUINT (a))
#endif
#endif /* !USE_LSB_TAG */
XSETCDR ((x), tmp); \
} while (0)
-/* Cast pointers to this type to compare them. Some machines want int. */
-#define PNTR_COMPARISON_TYPE EMACS_UINT
+/* Cast pointers to this type to compare them. */
+#define PNTR_COMPARISON_TYPE uintptr_t
\f
/* Define a built-in function for calling from Lisp.
`lname' should be the name to give the function in Lisp,
extern void child_setup_tty (int);
extern void setup_pty (int);
extern int set_window_size (int, int, int);
-extern long get_random (void);
+extern EMACS_INT get_random (void);
extern void seed_random (long);
extern int emacs_open (const char *, int, int);
extern int emacs_close (int);
#include <config.h>
-#include <inttypes.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
/* oblookup stores the bucket number here, for the sake of Funintern. */
-static int oblookup_last_bucket_number;
+static size_t oblookup_last_bucket_number;
-static int hash_string (const char *ptr, int len);
+static size_t hash_string (const char *ptr, size_t len);
/* Get an error if OBARRAY is not an obarray.
If it is one, return it. */
(Lisp_Object name, Lisp_Object obarray)
{
register Lisp_Object string, tem;
- int hash;
+ size_t hash;
if (NILP (obarray)) obarray = Vobarray;
obarray = check_obarray (obarray);
Lisp_Object
oblookup (Lisp_Object obarray, register const char *ptr, EMACS_INT size, EMACS_INT size_byte)
{
- int hash;
- int obsize;
+ size_t hash;
+ size_t obsize;
register Lisp_Object tail;
Lisp_Object bucket, tem;
return tem;
}
-static int
-hash_string (const char *ptr, int len)
+static size_t
+hash_string (const char *ptr, size_t len)
{
register const char *p = ptr;
register const char *end = p + len;
register unsigned char c;
- register int hash = 0;
+ register size_t hash = 0;
while (p != end)
{
c = *p++;
if (c >= 0140) c -= 40;
- hash = ((hash<<3) + (hash>>28) + c);
+ hash = (hash << 3) + (hash >> (CHAR_BIT * sizeof hash - 4)) + c;
}
- return hash & 07777777777;
+ return hash;
}
\f
void
if (!NILP (descrip))
wv->lkey = descrip;
wv->value = 0;
- /* The EMACS_INT cast avoids a warning. There's no problem
+ /* The intptr_t cast avoids a warning. There's no problem
as long as pointers have enough bits to hold small integers. */
- wv->call_data = (!NILP (def) ? (void *) (EMACS_INT) i : 0);
+ wv->call_data = (!NILP (def) ? (void *) (intptr_t) i : 0);
wv->enabled = !NILP (enable);
if (NILP (type))
else
{
entry = XVECTOR (vector)->contents[i + MENU_ITEMS_ITEM_VALUE];
- /* The EMACS_INT cast avoids a warning. There's no problem
+ /* Treat the pointer as an integer. There's no problem
as long as pointers have enough bits to hold small integers. */
- if ((int) (EMACS_INT) client_data == i)
+ if ((intptr_t) client_data == i)
{
int j;
struct input_event buf;
#include <sys/file.h>
#include <sys/stat.h>
#include <setjmp.h>
-#include <inttypes.h>
#include <unistd.h>
#include <fcntl.h>
some data in the TCP buffers so that select works, but
with custom pull/push functions we need to check if some
data is available in the buffers manually. */
- if (nfds == 0 &&
+ if (nfds == 0 &&
wait_proc && wait_proc->gnutls_p /* Check for valid process. */
/* Do we have pending data? */
&& gnutls_record_check_pending (wait_proc->gnutls_state) > 0)
* Build a full Emacs-sized word out of whatever we've got.
* This suffices even for a 64-bit architecture with a 15-bit rand.
*/
-long
+EMACS_INT
get_random (void)
{
- long val = random ();
-#if VALBITS > RAND_BITS
- val = (val << RAND_BITS) ^ random ();
-#if VALBITS > 2*RAND_BITS
- val = (val << RAND_BITS) ^ random ();
-#if VALBITS > 3*RAND_BITS
- val = (val << RAND_BITS) ^ random ();
-#if VALBITS > 4*RAND_BITS
- val = (val << RAND_BITS) ^ random ();
-#endif /* need at least 5 */
-#endif /* need at least 4 */
-#endif /* need at least 3 */
-#endif /* need at least 2 */
- return val & ((1L << VALBITS) - 1);
+ EMACS_UINT val = 0;
+ int i;
+ for (i = 0; i < (VALBITS + RAND_BITS - 1) / RAND_BITS; i++)
+ val = (val << RAND_BITS) ^ random ();
+ return val & (((EMACS_INT) 1 << VALBITS) - 1);
}
#ifndef HAVE_STRERROR
window_height_changed_p
= with_echo_area_buffer (w, display_last_displayed_message_p,
display_echo_area_1,
- (EMACS_INT) w, Qnil, 0, 0);
+ (intptr_t) w, Qnil, 0, 0);
if (no_message_p)
echo_area_buffer[i] = Qnil;
static int
display_echo_area_1 (EMACS_INT a1, Lisp_Object a2, EMACS_INT a3, EMACS_INT a4)
{
- struct window *w = (struct window *) a1;
+ intptr_t i1 = a1;
+ struct window *w = (struct window *) i1;
Lisp_Object window;
struct text_pos start;
int window_height_changed_p = 0;
resize_exactly = Qnil;
resized_p = with_echo_area_buffer (w, 0, resize_mini_window_1,
- (EMACS_INT) w, resize_exactly, 0, 0);
+ (intptr_t) w, resize_exactly,
+ 0, 0);
if (resized_p)
{
++windows_or_buffers_changed;
static int
resize_mini_window_1 (EMACS_INT a1, Lisp_Object exactly, EMACS_INT a3, EMACS_INT a4)
{
- return resize_mini_window ((struct window *) a1, !NILP (exactly));
+ intptr_t i1 = a1;
+ return resize_mini_window ((struct window *) i1, !NILP (exactly));
}
else
{
with_echo_area_buffer (0, 0, current_message_1,
- (EMACS_INT) &msg, Qnil, 0, 0);
+ (intptr_t) &msg, Qnil, 0, 0);
if (NILP (msg))
echo_area_buffer[0] = Qnil;
}
static int
current_message_1 (EMACS_INT a1, Lisp_Object a2, EMACS_INT a3, EMACS_INT a4)
{
- Lisp_Object *msg = (Lisp_Object *) a1;
+ intptr_t i1 = a1;
+ Lisp_Object *msg = (Lisp_Object *) i1;
if (Z > BEG)
*msg = make_buffer_string (BEG, Z, 1);
|| (STRINGP (string) && STRING_MULTIBYTE (string)));
with_echo_area_buffer (0, -1, set_message_1,
- (EMACS_INT) s, string, nbytes, multibyte_p);
+ (intptr_t) s, string, nbytes, multibyte_p);
message_buf_print = 0;
help_echo_showing_p = 0;
}
static int
set_message_1 (EMACS_INT a1, Lisp_Object a2, EMACS_INT nbytes, EMACS_INT multibyte_p)
{
- const char *s = (const char *) a1;
+ intptr_t i1 = a1;
+ const char *s = (const char *) i1;
const unsigned char *msg = (const unsigned char *) s;
Lisp_Object string = a2;
wv->help = Qnil;
/* This prevents lwlib from assuming this
menu item is really supposed to be empty. */
- /* The EMACS_INT cast avoids a warning.
+ /* The intptr_t cast avoids a warning.
This value just has to be different from small integers. */
- wv->call_data = (void *) (EMACS_INT) (-1);
+ wv->call_data = (void *) (intptr_t) (-1);
if (prev_wv)
prev_wv->next = wv;
static void
dialog_selection_callback (GtkWidget *widget, gpointer client_data)
{
- /* The EMACS_INT cast avoids a warning. There's no problem
+ /* Treat the pointer as an integer. There's no problem
as long as pointers have enough bits to hold small integers. */
- if ((int) (EMACS_INT) client_data != -1)
+ if ((intptr_t) client_data != -1)
menu_item_selection = (Lisp_Object *) client_data;
popup_activated_flag = 0;