From 5ef169ed701fa4f850fdca5563cdd468207d5d4f Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Wed, 17 May 2023 15:36:54 -0700 Subject: Prefer C23 ckd_* to Gnulib *_WRAPV macros C23 has added ckd_add etc. macros with functionality equivalent to the older Gnulib INT_ADD_WRAPV macros, so switch to the more-standard names. * admin/merge-gnulib (GNULIB_MODULES): Add stdckdint. This merely makes the dependency explicit, as we were already using this Gnulib module indirectly. * lib-src/etags.c, src/lisp.h: Include stdckdint.h. * lib-src/etags.c (xnmalloc, xnrealloc): * src/alloc.c (xnmalloc, xnrealloc, xpalloc, Fmake_string) (mark_memory): * src/bignum.c (emacs_mpz_pow_ui): * src/buffer.c (record_overlay_string, overlay_strings): * src/bytecode.c (exec_byte_code): * src/casefiddle.c (do_casify_multibyte_string): * src/ccl.c (ccl_driver, Fccl_execute_on_string): * src/character.c (char_width, c_string_width) (lisp_string_width, count_size_as_multibyte) (string_escape_byte8): * src/cmds.c (internal_self_insert): * src/coding.c (coding_alloc_by_realloc, produce_chars): * src/data.c (arith_driver): * src/dispnew.c (realloc_glyph_pool, init_display_interactive): * src/doprnt.c (parse_format_integer): * src/editfns.c (Freplace_buffer_contents, str2num) (styled_format): * src/emacs-module.c (module_global_reference_p) (module_make_global_ref, module_funcall): * src/eval.c (max_ensure_room): * src/fileio.c (blocks_to_bytes): * src/fns.c (Ffillarray): * src/font.c (font_intern_prop): * src/frame.c (check_frame_pixels): * src/gnutls.c (gnutls_hex_string, gnutls_symmetric_aead): * src/gtkutil.c (get_utf8_string): * src/haikuterm.c (haiku_term_init): * src/image.c (xbm_scan, image_to_emacs_colors) (image_detect_edges, png_load_body): * src/keyboard.c (Frecursion_depth): * src/keymap.c (Flookup_key, Fkey_description): * src/lisp.h (modiff_incr, SAFE_ALLOCA_LISP_EXTRA): * src/lread.c (read_bool_vector): * src/pgtkterm.c (pgtk_term_init): * src/regex-emacs.c (regex_compile): * src/term.c (encode_terminal_code): * src/termcap.c (tputs): * src/textconv.c (textconv_query): * src/timefns.c (timespec_ticks, lisp_time_hz_ticks) (Fdecode_time, check_tm_member): * src/tparam.c (tparam1): * src/w32term.c (w32_initialize_display_info): * src/xdisp.c (fill_column_indicator_column, decode_mode_spec): * src/xselect.c (selection_data_size, x_property_data_to_lisp): * src/xsmfns.c (smc_save_yourself_CB): * src/xterm.c (xm_setup_dnd_targets, x_sync_get_monotonic_time) (x_sync_current_monotonic_time, x_sync_note_frame_times) (x_display_set_last_user_time, x_term_init): Prefer the C23 stdckdint macros to their Gnulib intprops.h counterparts, since C23 is standard. --- admin/merge-gnulib | 2 +- lib-src/etags.c | 5 +++-- lib/gnulib.mk.in | 1 + src/alloc.c | 16 ++++++++-------- src/bignum.c | 2 +- src/buffer.c | 6 +++--- src/bytecode.c | 2 +- src/casefiddle.c | 4 ++-- src/ccl.c | 20 ++++++++++---------- src/character.c | 16 ++++++++-------- src/cmds.c | 2 +- src/coding.c | 7 +++---- src/data.c | 6 +++--- src/dispnew.c | 6 +++--- src/doprnt.c | 4 ++-- src/editfns.c | 16 ++++++++-------- src/emacs-module.c | 6 +++--- src/eval.c | 2 +- src/fileio.c | 2 +- src/fns.c | 3 +-- src/font.c | 2 +- src/frame.c | 2 +- src/gnutls.c | 6 +++--- src/gtkutil.c | 4 ++-- src/haikuterm.c | 2 +- src/image.c | 22 +++++++++++----------- src/keyboard.c | 2 +- src/keymap.c | 6 +++--- src/lisp.h | 7 ++++--- src/lread.c | 12 ++++++------ src/pgtkterm.c | 3 +-- src/regex-emacs.c | 5 ++--- src/term.c | 2 +- src/termcap.c | 2 +- src/textconv.c | 6 +++--- src/timefns.c | 18 ++++++++---------- src/tparam.c | 3 +-- src/w32term.c | 2 +- src/xdisp.c | 9 ++++----- src/xselect.c | 6 +++--- src/xsmfns.c | 2 +- src/xterm.c | 46 ++++++++++++++++++++-------------------------- 42 files changed, 143 insertions(+), 154 deletions(-) diff --git a/admin/merge-gnulib b/admin/merge-gnulib index 97487381886..3e7526102ae 100755 --- a/admin/merge-gnulib +++ b/admin/merge-gnulib @@ -44,7 +44,7 @@ GNULIB_MODULES=' nanosleep nproc nstrftime pathmax pipe2 pselect pthread_sigmask qcopy-acl readlink readlinkat regex - sig2str sigdescr_np socklen stat-time std-gnu11 stdbool stddef stdio + sig2str sigdescr_np socklen stat-time std-gnu11 stdbool stdckdint stddef stdio stpcpy strnlen strtoimax symlink sys_stat sys_time tempname time-h time_r time_rz timegm timer-time timespec-add timespec-sub update-copyright unlocked-io utimensat diff --git a/lib-src/etags.c b/lib-src/etags.c index 2c6b4e7a630..147ecbd7c1b 100644 --- a/lib-src/etags.c +++ b/lib-src/etags.c @@ -109,6 +109,7 @@ University of California, as described above. */ #include #include #include +#include #include #include #include @@ -8038,7 +8039,7 @@ xnmalloc (ptrdiff_t nitems, ptrdiff_t item_size) ptrdiff_t nbytes; assume (0 <= nitems); assume (0 < item_size); - if (INT_MULTIPLY_WRAPV (nitems, item_size, &nbytes)) + if (ckd_mul (&nbytes, nitems, item_size)) memory_full (); return xmalloc (nbytes); } @@ -8049,7 +8050,7 @@ xnrealloc (void *pa, ptrdiff_t nitems, ptrdiff_t item_size) ptrdiff_t nbytes; assume (0 <= nitems); assume (0 < item_size); - if (INT_MULTIPLY_WRAPV (nitems, item_size, &nbytes) || SIZE_MAX < nbytes) + if (ckd_mul (&nbytes, nitems, item_size) || SIZE_MAX < nbytes) memory_full (); void *result = realloc (pa, nbytes); if (!result) diff --git a/lib/gnulib.mk.in b/lib/gnulib.mk.in index 5722e2588eb..a25bee25aae 100644 --- a/lib/gnulib.mk.in +++ b/lib/gnulib.mk.in @@ -147,6 +147,7 @@ # stat-time \ # std-gnu11 \ # stdbool \ +# stdckdint \ # stddef \ # stdio \ # stpcpy \ diff --git a/src/alloc.c b/src/alloc.c index 29393deeff4..17ca5c725d0 100644 --- a/src/alloc.c +++ b/src/alloc.c @@ -863,7 +863,7 @@ xnmalloc (ptrdiff_t nitems, ptrdiff_t item_size) { eassert (0 <= nitems && 0 < item_size); ptrdiff_t nbytes; - if (INT_MULTIPLY_WRAPV (nitems, item_size, &nbytes) || SIZE_MAX < nbytes) + if (ckd_mul (&nbytes, nitems, item_size) || SIZE_MAX < nbytes) memory_full (SIZE_MAX); return xmalloc (nbytes); } @@ -877,7 +877,7 @@ xnrealloc (void *pa, ptrdiff_t nitems, ptrdiff_t item_size) { eassert (0 <= nitems && 0 < item_size); ptrdiff_t nbytes; - if (INT_MULTIPLY_WRAPV (nitems, item_size, &nbytes) || SIZE_MAX < nbytes) + if (ckd_mul (&nbytes, nitems, item_size) || SIZE_MAX < nbytes) memory_full (SIZE_MAX); return xrealloc (pa, nbytes); } @@ -924,13 +924,13 @@ xpalloc (void *pa, ptrdiff_t *nitems, ptrdiff_t nitems_incr_min, NITEMS_MAX, and what the C language can represent safely. */ ptrdiff_t n, nbytes; - if (INT_ADD_WRAPV (n0, n0 >> 1, &n)) + if (ckd_add (&n, n0, n0 >> 1)) n = PTRDIFF_MAX; if (0 <= nitems_max && nitems_max < n) n = nitems_max; ptrdiff_t adjusted_nbytes - = ((INT_MULTIPLY_WRAPV (n, item_size, &nbytes) || SIZE_MAX < nbytes) + = ((ckd_mul (&nbytes, n, item_size) || SIZE_MAX < nbytes) ? min (PTRDIFF_MAX, SIZE_MAX) : nbytes < DEFAULT_MXFAST ? DEFAULT_MXFAST : 0); if (adjusted_nbytes) @@ -942,9 +942,9 @@ xpalloc (void *pa, ptrdiff_t *nitems, ptrdiff_t nitems_incr_min, if (! pa) *nitems = 0; if (n - n0 < nitems_incr_min - && (INT_ADD_WRAPV (n0, nitems_incr_min, &n) + && (ckd_add (&n, n0, nitems_incr_min) || (0 <= nitems_max && nitems_max < n) - || INT_MULTIPLY_WRAPV (n, item_size, &nbytes))) + || ckd_mul (&nbytes, n, item_size))) memory_full (SIZE_MAX); pa = xrealloc (pa, nbytes); *nitems = n; @@ -2375,7 +2375,7 @@ a multibyte string even if INIT is an ASCII character. */) ptrdiff_t len = CHAR_STRING (c, str); EMACS_INT string_len = XFIXNUM (length); - if (INT_MULTIPLY_WRAPV (len, string_len, &nbytes)) + if (ckd_mul (&nbytes, len, string_len)) string_overflow (); val = make_clear_multibyte_string (string_len, nbytes, clearit); if (!clearit) @@ -5226,7 +5226,7 @@ mark_memory (void const *start, void const *end) a Lisp_Object might be split into registers saved into non-adjacent words and P might be the low-order word's value. */ intptr_t ip; - INT_ADD_WRAPV ((intptr_t) p, (intptr_t) lispsym, &ip); + ckd_add (&ip, (intptr_t) p, (intptr_t) lispsym); mark_maybe_pointer ((void *) ip, true); } } diff --git a/src/bignum.c b/src/bignum.c index e64653b2873..22ed171533f 100644 --- a/src/bignum.c +++ b/src/bignum.c @@ -354,7 +354,7 @@ emacs_mpz_pow_ui (mpz_t rop, mpz_t const base, unsigned long exp) enum { lim = min (NLIMBS_LIMIT, GMP_NLIMBS_MAX - pow_ui_extra_limbs) }; int nbase = emacs_mpz_size (base), n; - if (INT_MULTIPLY_WRAPV (nbase, exp, &n) || lim < n) + if (ckd_mul (&n, nbase, exp) || lim < n) overflow_error (); mpz_pow_ui (rop, base, exp); } diff --git a/src/buffer.c b/src/buffer.c index 7951b7ac322..0c46b201586 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -3343,7 +3343,7 @@ record_overlay_string (struct sortstrlist *ssl, Lisp_Object str, else nbytes = SBYTES (str); - if (INT_ADD_WRAPV (ssl->bytes, nbytes, &nbytes)) + if (ckd_add (&nbytes, nbytes, ssl->bytes)) memory_full (SIZE_MAX); ssl->bytes = nbytes; @@ -3357,7 +3357,7 @@ record_overlay_string (struct sortstrlist *ssl, Lisp_Object str, else nbytes = SBYTES (str2); - if (INT_ADD_WRAPV (ssl->bytes, nbytes, &nbytes)) + if (ckd_add (&nbytes, nbytes, ssl->bytes)) memory_full (SIZE_MAX); ssl->bytes = nbytes; } @@ -3429,7 +3429,7 @@ overlay_strings (ptrdiff_t pos, struct window *w, unsigned char **pstr) unsigned char *p; ptrdiff_t total; - if (INT_ADD_WRAPV (overlay_heads.bytes, overlay_tails.bytes, &total)) + if (ckd_add (&total, overlay_heads.bytes, overlay_tails.bytes)) memory_full (SIZE_MAX); if (total > overlay_str_len) overlay_str_buf = xpalloc (overlay_str_buf, &overlay_str_len, diff --git a/src/bytecode.c b/src/bytecode.c index 74a94859aba..4207ff0b71f 100644 --- a/src/bytecode.c +++ b/src/bytecode.c @@ -1327,7 +1327,7 @@ exec_byte_code (Lisp_Object fun, ptrdiff_t args_template, Lisp_Object v1 = TOP; intmax_t res; if (FIXNUMP (v1) && FIXNUMP (v2) - && !INT_MULTIPLY_WRAPV (XFIXNUM (v1), XFIXNUM (v2), &res) + && !ckd_mul (&res, XFIXNUM (v1), XFIXNUM (v2)) && !FIXNUM_OVERFLOW_P (res)) TOP = make_fixnum (res); else diff --git a/src/casefiddle.c b/src/casefiddle.c index 1a959b1c07b..d567a5e353a 100644 --- a/src/casefiddle.c +++ b/src/casefiddle.c @@ -283,8 +283,8 @@ do_casify_multibyte_string (struct casing_context *ctx, Lisp_Object obj) ptrdiff_t size = SCHARS (obj), n; USE_SAFE_ALLOCA; - if (INT_MULTIPLY_WRAPV (size, MAX_MULTIBYTE_LENGTH, &n) - || INT_ADD_WRAPV (n, sizeof (struct casing_str_buf), &n)) + if (ckd_mul (&n, size, MAX_MULTIBYTE_LENGTH) + || ckd_add (&n, n, sizeof (struct casing_str_buf))) n = PTRDIFF_MAX; unsigned char *dst = SAFE_ALLOCA (n); unsigned char *dst_end = dst + n; diff --git a/src/ccl.c b/src/ccl.c index ce9abd59493..67f2a275841 100644 --- a/src/ccl.c +++ b/src/ccl.c @@ -1156,9 +1156,9 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size ccl_expr_self: switch (op) { - case CCL_PLUS: INT_ADD_WRAPV (reg[rrr], i, ®[rrr]); break; - case CCL_MINUS: INT_SUBTRACT_WRAPV (reg[rrr], i, ®[rrr]); break; - case CCL_MUL: INT_MULTIPLY_WRAPV (reg[rrr], i, ®[rrr]); break; + case CCL_PLUS: ckd_add (®[rrr], reg[rrr], i); break; + case CCL_MINUS: ckd_sub (®[rrr], reg[rrr], i); break; + case CCL_MUL: ckd_mul (®[rrr], reg[rrr], i); break; case CCL_DIV: if (!i) CCL_INVALID_CMD; @@ -1194,7 +1194,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size if (i == -1) { reg[7] = 0; - INT_SUBTRACT_WRAPV (0, reg[rrr], ®[rrr]); + ckd_sub (®[rrr], 0, reg[rrr]); } else { @@ -1251,9 +1251,9 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size ccl_set_expr: switch (op) { - case CCL_PLUS: INT_ADD_WRAPV (i, j, ®[rrr]); break; - case CCL_MINUS: INT_SUBTRACT_WRAPV (i, j, ®[rrr]); break; - case CCL_MUL: INT_MULTIPLY_WRAPV (i, j, ®[rrr]); break; + case CCL_PLUS: ckd_add (®[rrr], i, j); break; + case CCL_MINUS: ckd_sub (®[rrr], i, j); break; + case CCL_MUL: ckd_mul (®[rrr], i, j); break; case CCL_DIV: if (!j) CCL_INVALID_CMD; @@ -1288,7 +1288,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size CCL_INVALID_CMD; if (j == -1) { - INT_SUBTRACT_WRAPV (0, reg[rrr], ®[rrr]); + ckd_sub (®[rrr], 0, reg[rrr]); reg[7] = 0; } else @@ -2169,8 +2169,8 @@ usage: (ccl-execute-on-string CCL-PROGRAM STATUS STRING &optional CONTINUE UNIBY buf_magnification = ccl.buf_magnification ? ccl.buf_magnification : 1; outbufsize = str_bytes; - if (INT_MULTIPLY_WRAPV (buf_magnification, outbufsize, &outbufsize) - || INT_ADD_WRAPV (256, outbufsize, &outbufsize)) + if (ckd_mul (&outbufsize, outbufsize, buf_magnification) + || ckd_add (&outbufsize, outbufsize, 256)) memory_full (SIZE_MAX); outp = outbuf = xmalloc (outbufsize); diff --git a/src/character.c b/src/character.c index d0b18367a83..ae153a579d6 100644 --- a/src/character.c +++ b/src/character.c @@ -250,7 +250,7 @@ char_width (int c, struct Lisp_Char_Table *dp) if (c >= 0) { int w = CHARACTER_WIDTH (c); - if (INT_ADD_WRAPV (width, w, &width)) + if (ckd_add (&width, width, w)) string_overflow (); } } @@ -301,7 +301,7 @@ c_string_width (const unsigned char *str, ptrdiff_t len, int precision, *nbytes = i_byte; return width; } - if (INT_ADD_WRAPV (thiswidth, width, &width)) + if (ckd_add (&width, width, thiswidth)) string_overflow (); i++; i_byte += bytes; @@ -441,7 +441,7 @@ lisp_string_width (Lisp_Object string, ptrdiff_t from, ptrdiff_t to, *nbytes = i_byte - from_byte; return width; } - if (INT_ADD_WRAPV (thiswidth, width, &width)) + if (ckd_add (&width, width, thiswidth)) string_overflow (); i += chars; i_byte += bytes; @@ -664,7 +664,7 @@ count_size_as_multibyte (const unsigned char *str, ptrdiff_t len) for (ptrdiff_t i = 0; i < len; i++) nonascii += str[i] >> 7; ptrdiff_t bytes; - if (INT_ADD_WRAPV (len, nonascii, &bytes)) + if (ckd_add (&bytes, len, nonascii)) string_overflow (); return bytes; } @@ -780,21 +780,21 @@ string_escape_byte8 (Lisp_Object string) if (byte8_count == 0) return string; - if (INT_MULTIPLY_WRAPV (byte8_count, 3, &thrice_byte8_count)) + if (ckd_mul (&thrice_byte8_count, byte8_count, 3)) string_overflow (); if (multibyte) { /* Convert 2-byte sequence of byte8 chars to 4-byte octal. */ - if (INT_ADD_WRAPV (nchars, thrice_byte8_count, &uninit_nchars) - || INT_ADD_WRAPV (nbytes, 2 * byte8_count, &uninit_nbytes)) + if (ckd_add (&uninit_nchars, nchars, thrice_byte8_count) + || ckd_add (&uninit_nbytes, nbytes, 2 * byte8_count)) string_overflow (); val = make_uninit_multibyte_string (uninit_nchars, uninit_nbytes); } else { /* Convert 1-byte sequence of byte8 chars to 4-byte octal. */ - if (INT_ADD_WRAPV (thrice_byte8_count, nbytes, &uninit_nbytes)) + if (ckd_add (&uninit_nbytes, thrice_byte8_count, nbytes)) string_overflow (); val = make_uninit_string (uninit_nbytes); } diff --git a/src/cmds.c b/src/cmds.c index 15caa4a6972..37e1779296a 100644 --- a/src/cmds.c +++ b/src/cmds.c @@ -453,7 +453,7 @@ internal_self_insert (int c, EMACS_INT n) } ptrdiff_t to; - if (INT_ADD_WRAPV (PT, chars_to_delete, &to)) + if (ckd_add (&to, PT, chars_to_delete)) to = PTRDIFF_MAX; replace_range (PT, to, string, 1, 1, 1, 0, false); Fforward_char (make_fixnum (n)); diff --git a/src/coding.c b/src/coding.c index a2e0d7040f8..f014749c4ea 100644 --- a/src/coding.c +++ b/src/coding.c @@ -989,7 +989,7 @@ static void coding_alloc_by_realloc (struct coding_system *coding, ptrdiff_t bytes) { ptrdiff_t newbytes; - if (INT_ADD_WRAPV (coding->dst_bytes, bytes, &newbytes) + if (ckd_add (&newbytes, coding->dst_bytes, bytes) || SIZE_MAX < newbytes) string_overflow (); coding->destination = xrealloc (coding->destination, newbytes); @@ -7059,9 +7059,8 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table, { eassert (growable_destination (coding)); ptrdiff_t dst_size; - if (INT_MULTIPLY_WRAPV (to_nchars, MAX_MULTIBYTE_LENGTH, - &dst_size) - || INT_ADD_WRAPV (buf_end - buf, dst_size, &dst_size)) + if (ckd_mul (&dst_size, to_nchars, MAX_MULTIBYTE_LENGTH) + || ckd_add (&dst_size, dst_size, buf_end - buf)) memory_full (SIZE_MAX); dst = alloc_destination (coding, dst_size, dst); if (EQ (coding->src_object, coding->dst_object)) diff --git a/src/data.c b/src/data.c index 8f9ee63e779..9d7e7effdcd 100644 --- a/src/data.c +++ b/src/data.c @@ -3190,9 +3190,9 @@ arith_driver (enum arithop code, ptrdiff_t nargs, Lisp_Object *args, intmax_t a; switch (code) { - case Aadd : overflow = INT_ADD_WRAPV (accum, next, &a); break; - case Amult: overflow = INT_MULTIPLY_WRAPV (accum, next, &a); break; - case Asub : overflow = INT_SUBTRACT_WRAPV (accum, next, &a); break; + case Aadd : overflow = ckd_add (&a, accum, next); break; + case Amult: overflow = ckd_mul (&a, accum, next); break; + case Asub : overflow = ckd_sub (&a, accum, next); break; case Adiv: if (next == 0) xsignal0 (Qarith_error); diff --git a/src/dispnew.c b/src/dispnew.c index a928a5d1b14..9133d515ca3 100644 --- a/src/dispnew.c +++ b/src/dispnew.c @@ -1385,7 +1385,7 @@ realloc_glyph_pool (struct glyph_pool *pool, struct dim matrix_dim) || matrix_dim.width != pool->ncolumns); /* Enlarge the glyph pool. */ - if (INT_MULTIPLY_WRAPV (matrix_dim.height, matrix_dim.width, &needed)) + if (ckd_mul (&needed, matrix_dim.height, matrix_dim.width)) memory_full (SIZE_MAX); if (needed > pool->nglyphs) { @@ -6653,8 +6653,8 @@ init_display_interactive (void) change. It's not clear what better we could do. The rest of the code assumes that (width + 2) * height * sizeof (struct glyph) does not overflow and does not exceed PTRDIFF_MAX or SIZE_MAX. */ - if (INT_ADD_WRAPV (width, 2, &area) - || INT_MULTIPLY_WRAPV (height, area, &area) + if (ckd_add (&area, width, 2) + || ckd_mul (&area, area, height) || min (PTRDIFF_MAX, SIZE_MAX) / sizeof (struct glyph) < area) fatal ("screen size %dx%d too big", width, height); } diff --git a/src/doprnt.c b/src/doprnt.c index 3ebb957e9f2..e8911fad252 100644 --- a/src/doprnt.c +++ b/src/doprnt.c @@ -134,8 +134,8 @@ parse_format_integer (char const *fmt, int *value) bool overflow = false; for (; '0' <= *fmt && *fmt <= '9'; fmt++) { - overflow |= INT_MULTIPLY_WRAPV (n, 10, &n); - overflow |= INT_ADD_WRAPV (n, *fmt - '0', &n); + overflow |= ckd_mul (&n, n, 10); + overflow |= ckd_add (&n, n, *fmt - '0'); } if (overflow || min (PTRDIFF_MAX, SIZE_MAX) - SIZE_BOUND_EXTRA < n) error ("Format width or precision too large"); diff --git a/src/editfns.c b/src/editfns.c index d02cce4aef3..44e11841faa 100644 --- a/src/editfns.c +++ b/src/editfns.c @@ -2027,8 +2027,8 @@ nil. */) ptrdiff_t ins_bytes = size_b / CHAR_BIT + 1; ptrdiff_t *buffer; ptrdiff_t bytes_needed; - if (INT_MULTIPLY_WRAPV (diags, 2 * sizeof *buffer, &bytes_needed) - || INT_ADD_WRAPV (del_bytes + ins_bytes, bytes_needed, &bytes_needed)) + if (ckd_mul (&bytes_needed, diags, 2 * sizeof *buffer) + || ckd_add (&bytes_needed, bytes_needed, del_bytes + ins_bytes)) memory_full (SIZE_MAX); USE_SAFE_ALLOCA; buffer = SAFE_ALLOCA (bytes_needed); @@ -3296,7 +3296,7 @@ str2num (char *str, char **str_end) { ptrdiff_t n = 0; for (; c_isdigit (*str); str++) - if (INT_MULTIPLY_WRAPV (n, 10, &n) || INT_ADD_WRAPV (n, *str - '0', &n)) + if (ckd_mul (&n, n, 10) || ckd_add (&n, n, *str - '0')) n = PTRDIFF_MAX; *str_end = str; return n; @@ -3464,8 +3464,8 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message) /* Allocate the info and discarded tables. */ ptrdiff_t info_size, alloca_size; - if (INT_MULTIPLY_WRAPV (nspec_bound, sizeof *info, &info_size) - || INT_ADD_WRAPV (formatlen, info_size, &alloca_size) + if (ckd_mul (&info_size, nspec_bound, sizeof *info) + || ckd_add (&alloca_size, formatlen, info_size) || SIZE_MAX < alloca_size) memory_full (SIZE_MAX); info = SAFE_ALLOCA (alloca_size); @@ -4012,8 +4012,8 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message) /* Compute the total bytes needed for this item, including excess precision and padding. */ ptrdiff_t numwidth; - if (INT_ADD_WRAPV (prefixlen + sprintf_bytes, excess_precision, - &numwidth)) + if (ckd_add (&numwidth, prefixlen + sprintf_bytes, + excess_precision)) numwidth = PTRDIFF_MAX; ptrdiff_t padding = numwidth < field_width ? field_width - numwidth : 0; @@ -4173,7 +4173,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message) ptrdiff_t used = p - buf; ptrdiff_t buflen_needed; - if (INT_ADD_WRAPV (used, convbytes, &buflen_needed)) + if (ckd_add (&buflen_needed, used, convbytes)) string_overflow (); if (bufsize <= buflen_needed) { diff --git a/src/emacs-module.c b/src/emacs-module.c index d158e243139..10699ec25d9 100644 --- a/src/emacs-module.c +++ b/src/emacs-module.c @@ -416,7 +416,7 @@ module_global_reference_p (emacs_value v, ptrdiff_t *n) } /* Only used for debugging, so we don't care about overflow, just make sure the operation is defined. */ - INT_ADD_WRAPV (*n, h->count, n); + ckd_add (n, *n, h->count); return false; } @@ -435,7 +435,7 @@ module_make_global_ref (emacs_env *env, emacs_value value) { Lisp_Object value = HASH_VALUE (h, i); struct module_global_reference *ref = XMODULE_GLOBAL_REFERENCE (value); - bool overflow = INT_ADD_WRAPV (ref->refcount, 1, &ref->refcount); + bool overflow = ckd_add (&ref->refcount, ref->refcount, 1); if (overflow) overflow_error (); return &ref->value; @@ -662,7 +662,7 @@ module_funcall (emacs_env *env, emacs_value func, ptrdiff_t nargs, Lisp_Object *newargs; USE_SAFE_ALLOCA; ptrdiff_t nargs1; - if (INT_ADD_WRAPV (nargs, 1, &nargs1)) + if (ckd_add (&nargs1, nargs, 1)) overflow_error (); SAFE_ALLOCA_LISP (newargs, nargs1); newargs[0] = value_to_lisp (func); diff --git a/src/eval.c b/src/eval.c index cd3eb0a3676..3f4e77cd3b1 100644 --- a/src/eval.c +++ b/src/eval.c @@ -254,7 +254,7 @@ init_eval (void) static void max_ensure_room (intmax_t *m, intmax_t a, intmax_t b) { - intmax_t sum = INT_ADD_WRAPV (a, b, &sum) ? INTMAX_MAX : sum; + intmax_t sum = ckd_add (&sum, a, b) ? INTMAX_MAX : sum; *m = max (*m, sum); } diff --git a/src/fileio.c b/src/fileio.c index a364aa2ea33..859cf57d249 100644 --- a/src/fileio.c +++ b/src/fileio.c @@ -6276,7 +6276,7 @@ static Lisp_Object blocks_to_bytes (uintmax_t blocksize, uintmax_t blocks, bool negate) { intmax_t n; - if (!INT_MULTIPLY_WRAPV (blocksize, blocks, &n)) + if (!ckd_mul (&n, blocksize, blocks)) return make_int (negate ? -n : n); Lisp_Object bs = make_uint (blocksize); if (negate) diff --git a/src/fns.c b/src/fns.c index 561f526f8d0..bfd19e8c8f2 100644 --- a/src/fns.c +++ b/src/fns.c @@ -2938,8 +2938,7 @@ ARRAY is a vector, string, char-table, or bool-vector. */) else { ptrdiff_t product; - if (INT_MULTIPLY_WRAPV (size, len, &product) - || product != size_byte) + if (ckd_mul (&product, size, len) || product != size_byte) error ("Attempt to change byte length of a string"); for (idx = 0; idx < size_byte; idx++) *p++ = str[idx % len]; diff --git a/src/font.c b/src/font.c index de8748dd857..e586277a5d3 100644 --- a/src/font.c +++ b/src/font.c @@ -279,7 +279,7 @@ font_intern_prop (const char *str, ptrdiff_t len, bool force_symbol) { if (i == len) return make_fixnum (n); - if (INT_MULTIPLY_WRAPV (n, 10, &n)) + if (ckd_mul (&n, n, 10)) break; } diff --git a/src/frame.c b/src/frame.c index 2cea96d4a32..037914ac9dc 100644 --- a/src/frame.c +++ b/src/frame.c @@ -3729,7 +3729,7 @@ check_frame_pixels (Lisp_Object size, Lisp_Object pixelwise, int item_size) item_size = 1; if (!integer_to_intmax (size, &sz) - || INT_MULTIPLY_WRAPV (sz, item_size, &pixel_size)) + || ckd_mul (&pixel_size, sz, item_size)) args_out_of_range_3 (size, make_int (INT_MIN / item_size), make_int (INT_MAX / item_size)); diff --git a/src/gnutls.c b/src/gnutls.c index ca7e9fc4c73..8f0e2d01703 100644 --- a/src/gnutls.c +++ b/src/gnutls.c @@ -1083,8 +1083,8 @@ gnutls_hex_string (unsigned char *buf, ptrdiff_t buf_size, const char *prefix) { ptrdiff_t prefix_length = strlen (prefix); ptrdiff_t retlen; - if (INT_MULTIPLY_WRAPV (buf_size, 3, &retlen) - || INT_ADD_WRAPV (prefix_length - (buf_size != 0), retlen, &retlen)) + if (ckd_mul (&retlen, buf_size, 3) + || ckd_add (&retlen, retlen, prefix_length - (buf_size != 0))) string_overflow (); Lisp_Object ret = make_uninit_string (retlen); char *string = SSDATA (ret); @@ -2378,7 +2378,7 @@ gnutls_symmetric_aead (bool encrypting, gnutls_cipher_algorithm_t gca, ptrdiff_t cipher_tag_size = gnutls_cipher_get_tag_size (gca); ptrdiff_t tagged_size; - if (INT_ADD_WRAPV (isize, cipher_tag_size, &tagged_size) + if (ckd_add (&tagged_size, isize, cipher_tag_size) || SIZE_MAX < tagged_size) memory_full (SIZE_MAX); size_t storage_length = tagged_size; diff --git a/src/gtkutil.c b/src/gtkutil.c index 4cc0f9f15b4..22b2a70f279 100644 --- a/src/gtkutil.c +++ b/src/gtkutil.c @@ -694,8 +694,8 @@ get_utf8_string (const char *str) len = strlen (str); ptrdiff_t alloc; - if (INT_MULTIPLY_WRAPV (nr_bad, 4, &alloc) - || INT_ADD_WRAPV (len + 1, alloc, &alloc) + if (ckd_mul (&alloc, nr_bad, 4) + || ckd_add (&alloc, alloc, len + 1) || SIZE_MAX < alloc) memory_full (SIZE_MAX); up = utf8_str = xmalloc (alloc); diff --git a/src/haikuterm.c b/src/haikuterm.c index 8733b82fb2b..212870064e8 100644 --- a/src/haikuterm.c +++ b/src/haikuterm.c @@ -4420,7 +4420,7 @@ haiku_term_init (void) { nbytes = sizeof "GNU Emacs" + sizeof " at "; - if (INT_ADD_WRAPV (nbytes, SBYTES (system_name), &nbytes)) + if (ckd_add (&nbytes, nbytes, SBYTES (system_name))) memory_full (SIZE_MAX); name_buffer = alloca (nbytes); diff --git a/src/image.c b/src/image.c index 8ee802a9d62..87a0c1ca497 100644 --- a/src/image.c +++ b/src/image.c @@ -4003,7 +4003,7 @@ xbm_scan (char **s, char *end, char *sval, int *ival) digit = char_hexdigit (c); if (digit < 0) break; - overflow |= INT_MULTIPLY_WRAPV (value, 16, &value); + overflow |= ckd_mul (&value, value, 16); value += digit; } } @@ -4013,7 +4013,7 @@ xbm_scan (char **s, char *end, char *sval, int *ival) while (*s < end && (c = *(*s)++, '0' <= c && c <= '7')) { - overflow |= INT_MULTIPLY_WRAPV (value, 8, &value); + overflow |= ckd_mul (&value, value, 8); value += c - '0'; } } @@ -4024,8 +4024,8 @@ xbm_scan (char **s, char *end, char *sval, int *ival) while (*s < end && (c = *(*s)++, c_isdigit (c))) { - overflow |= INT_MULTIPLY_WRAPV (value, 10, &value); - overflow |= INT_ADD_WRAPV (value, c - '0', &value); + overflow |= ckd_mul (&value, value, 10); + overflow |= ckd_add (&value, value, c - '0'); } } @@ -4069,7 +4069,7 @@ xbm_scan (char **s, char *end, char *sval, int *ival) if (digit < 0) return 0; - overflow |= INT_MULTIPLY_WRAPV (value, 16, &value); + overflow |= ckd_mul (&value, value, 16); value += digit; } } @@ -6136,8 +6136,8 @@ image_to_emacs_colors (struct frame *f, struct image *img, bool rgb_p) HGDIOBJ prev; #endif /* HAVE_NTGUI */ - if (INT_MULTIPLY_WRAPV (sizeof *colors, img->width, &nbytes) - || INT_MULTIPLY_WRAPV (img->height, nbytes, &nbytes) + if (ckd_mul (&nbytes, sizeof *colors, img->width) + || ckd_mul (&nbytes, nbytes, img->height) || SIZE_MAX < nbytes) memory_full (SIZE_MAX); colors = xmalloc (nbytes); @@ -6282,8 +6282,8 @@ image_detect_edges (struct frame *f, struct image *img, #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X)) - if (INT_MULTIPLY_WRAPV (sizeof *new, img->width, &nbytes) - || INT_MULTIPLY_WRAPV (img->height, nbytes, &nbytes)) + if (ckd_mul (&nbytes, sizeof *new, img->width) + || ckd_mul (&nbytes, nbytes, img->height)) memory_full (SIZE_MAX); new = xmalloc (nbytes); @@ -7655,8 +7655,8 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c) row_bytes = png_get_rowbytes (png_ptr, info_ptr); /* Allocate memory for the image. */ - if (INT_MULTIPLY_WRAPV (row_bytes, sizeof *pixels, &nbytes) - || INT_MULTIPLY_WRAPV (nbytes, height, &nbytes)) + if (ckd_mul (&nbytes, row_bytes, sizeof *pixels) + || ckd_mul (&nbytes, nbytes, height)) memory_full (SIZE_MAX); c->pixels = pixels = xmalloc (nbytes); c->rows = rows = xmalloc (height * sizeof *rows); diff --git a/src/keyboard.c b/src/keyboard.c index b1ccf4acde4..14c55666768 100644 --- a/src/keyboard.c +++ b/src/keyboard.c @@ -11161,7 +11161,7 @@ DEFUN ("recursion-depth", Frecursion_depth, Srecursion_depth, 0, 0, 0, (void) { EMACS_INT sum; - INT_ADD_WRAPV (command_loop_level, minibuf_level, &sum); + ckd_add (&sum, command_loop_level, minibuf_level); return make_fixnum (sum); } diff --git a/src/keymap.c b/src/keymap.c index 7f5777c9251..da2af98c2d6 100644 --- a/src/keymap.c +++ b/src/keymap.c @@ -1363,7 +1363,7 @@ recognize the default bindings, just as `read-key-sequence' does. */) { USE_SAFE_ALLOCA; ptrdiff_t size = SCHARS (key_item), n; - if (INT_MULTIPLY_WRAPV (size, MAX_MULTIBYTE_LENGTH, &n)) + if (ckd_mul (&n, size, MAX_MULTIBYTE_LENGTH)) n = PTRDIFF_MAX; unsigned char *dst = SAFE_ALLOCA (n); unsigned char *p = dst; @@ -1411,7 +1411,7 @@ recognize the default bindings, just as `read-key-sequence' does. */) USE_SAFE_ALLOCA; ptrdiff_t size = SCHARS (lc_key), n; - if (INT_MULTIPLY_WRAPV (size, MAX_MULTIBYTE_LENGTH, &n)) + if (ckd_mul (&n, size, MAX_MULTIBYTE_LENGTH)) n = PTRDIFF_MAX; unsigned char *dst = SAFE_ALLOCA (n); @@ -2097,7 +2097,7 @@ For an approximate inverse of this, see `kbd'. */) /* This has one extra element at the end that we don't pass to Fconcat. */ ptrdiff_t size4; - if (INT_MULTIPLY_WRAPV (nkeys + nprefix, 4, &size4)) + if (ckd_mul (&size4, nkeys + nprefix, 4)) memory_full (SIZE_MAX); SAFE_ALLOCA_LISP (args, size4); diff --git a/src/lisp.h b/src/lisp.h index 57c1c7395c1..2bfcd1a1983 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -23,6 +23,7 @@ along with GNU Emacs. If not, see . */ #include #include #include +#include #include #include #include @@ -3927,7 +3928,7 @@ modiff_incr (modiff_count *a, ptrdiff_t len) increasing it too much. */ verify (PTRDIFF_MAX <= ULLONG_MAX); int incr = len == 0 ? 1 : elogb (len) + 1; - bool modiff_overflow = INT_ADD_WRAPV (a0, incr, a); + bool modiff_overflow = ckd_add (a, a0, incr); eassert (!modiff_overflow && *a >> 30 >> 30 == 0); return a0; } @@ -5422,8 +5423,8 @@ safe_free_unbind_to (specpdl_ref count, specpdl_ref sa_count, Lisp_Object val) #define SAFE_ALLOCA_LISP_EXTRA(buf, nelt, extra) \ do { \ ptrdiff_t alloca_nbytes; \ - if (INT_MULTIPLY_WRAPV (nelt, word_size, &alloca_nbytes) \ - || INT_ADD_WRAPV (alloca_nbytes, extra, &alloca_nbytes) \ + if (ckd_mul (&alloca_nbytes, nelt, word_size) \ + || ckd_add (&alloca_nbytes, alloca_nbytes, extra) \ || SIZE_MAX < alloca_nbytes) \ memory_full (SIZE_MAX); \ else if (alloca_nbytes <= sa_avail) \ diff --git a/src/lread.c b/src/lread.c index 4f1d29d80b2..d2e544afef9 100644 --- a/src/lread.c +++ b/src/lread.c @@ -3377,8 +3377,8 @@ read_bool_vector (Lisp_Object readcharfun) invalid_syntax ("#&", readcharfun); break; } - if (INT_MULTIPLY_WRAPV (length, 10, &length) - || INT_ADD_WRAPV (length, c - '0', &length)) + if (ckd_mul (&length, length, 10) + || ckd_add (&length, length, c - '0')) invalid_syntax ("#&", readcharfun); } @@ -3423,8 +3423,8 @@ skip_lazy_string (Lisp_Object readcharfun) UNREAD (c); break; } - if (INT_MULTIPLY_WRAPV (nskip, 10, &nskip) - || INT_ADD_WRAPV (nskip, c - '0', &nskip)) + if (ckd_mul (&nskip, nskip, 10) + || ckd_add (&nskip, nskip, c - '0')) invalid_syntax ("#@", readcharfun); digits++; if (digits == 2 && nskip == 0) @@ -3988,8 +3988,8 @@ read0 (Lisp_Object readcharfun, bool locate_syms) c = READCHAR; if (c < '0' || c > '9') break; - if (INT_MULTIPLY_WRAPV (n, 10, &n) - || INT_ADD_WRAPV (n, c - '0', &n)) + if (ckd_mul (&n, n, 10) + || ckd_add (&n, n, c - '0')) invalid_syntax ("#", readcharfun); } if (c == 'r' || c == 'R') diff --git a/src/pgtkterm.c b/src/pgtkterm.c index 6cb1a3a4626..b8c626d81d8 100644 --- a/src/pgtkterm.c +++ b/src/pgtkterm.c @@ -6832,8 +6832,7 @@ pgtk_term_init (Lisp_Object display_name, char *resource_name) Lisp_Object system_name = Fsystem_name (); ptrdiff_t nbytes; - if (INT_ADD_WRAPV (SBYTES (Vinvocation_name), SBYTES (system_name) + 2, - &nbytes)) + if (ckd_add (&nbytes, SBYTES (Vinvocation_name), SBYTES (system_name) + 2)) memory_full (SIZE_MAX); dpyinfo->x_id = ++x_display_id; dpyinfo->x_id_name = xmalloc (nbytes); diff --git a/src/regex-emacs.c b/src/regex-emacs.c index 746779490ad..e3237cd425a 100644 --- a/src/regex-emacs.c +++ b/src/regex-emacs.c @@ -2202,9 +2202,8 @@ regex_compile (re_char *pattern, ptrdiff_t size, FALLTHROUGH; case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': - if (INT_MULTIPLY_WRAPV (regnum, 10, ®num) - || INT_ADD_WRAPV (regnum, c - '0', - ®num)) + if (ckd_mul (®num, regnum, 10) + || ckd_add (®num, regnum, c - '0')) FREE_STACK_RETURN (REG_ESIZE); break; default: diff --git a/src/term.c b/src/term.c index 2b28d3303e8..4df3de8f4a5 100644 --- a/src/term.c +++ b/src/term.c @@ -533,7 +533,7 @@ encode_terminal_code (struct glyph *src, int src_len, multibyte-form. But, it may be enlarged on demand if Vglyph_table contains a string or a composite glyph is encountered. */ - if (INT_MULTIPLY_WRAPV (src_len, MAX_MULTIBYTE_LENGTH, &required)) + if (ckd_mul (&required, src_len, MAX_MULTIBYTE_LENGTH)) memory_full (SIZE_MAX); if (encode_terminal_src_size < required) encode_terminal_src = xpalloc (encode_terminal_src, diff --git a/src/termcap.c b/src/termcap.c index d2688b3838d..1e989b6e2de 100644 --- a/src/termcap.c +++ b/src/termcap.c @@ -296,7 +296,7 @@ tputs (register const char *str, int nlines, int (*outfun) (int)) BAUD_RATE is measured in characters per 10 seconds. Compute PADFACTOR = 100000 * (how many padding bytes are needed). */ intmax_t padfactor; - if (INT_MULTIPLY_WRAPV (padcount, baud_rate, &padfactor)) + if (ckd_mul (&padfactor, padcount, baud_rate)) padfactor = baud_rate < 0 ? INTMAX_MIN : INTMAX_MAX; for (; 50000 <= padfactor; padfactor -= 100000) diff --git a/src/textconv.c b/src/textconv.c index d5db6d11717..7ed8ede3544 100644 --- a/src/textconv.c +++ b/src/textconv.c @@ -125,7 +125,7 @@ textconv_query (struct frame *f, struct textconv_callback_struct *query) overflows, move back to point or to the extremes of the accessible region. */ - if (INT_ADD_WRAPV (pos, query->position, &pos)) + if (ckd_add (&pos, pos, query->position)) pos = PT; if (pos < BEGV) @@ -145,7 +145,7 @@ textconv_query (struct frame *f, struct textconv_callback_struct *query) { case TEXTCONV_FORWARD_CHAR: /* Move forward by query->factor characters. */ - if (INT_ADD_WRAPV (pos, query->factor, &end) || end > ZV) + if (ckd_add (&end, pos, query->factor) || end > ZV) end = ZV; end_byte = CHAR_TO_BYTE (end); @@ -153,7 +153,7 @@ textconv_query (struct frame *f, struct textconv_callback_struct *query) case TEXTCONV_BACKWARD_CHAR: /* Move backward by query->factor characters. */ - if (INT_SUBTRACT_WRAPV (pos, query->factor, &end) || end < BEGV) + if (ckd_sub (&end, pos, query->factor) || end < BEGV) end = BEGV; end_byte = CHAR_TO_BYTE (end); diff --git a/src/timefns.c b/src/timefns.c index 87971cf4563..151f5b482a3 100644 --- a/src/timefns.c +++ b/src/timefns.c @@ -514,8 +514,8 @@ timespec_ticks (struct timespec t) /* For speed, use intmax_t arithmetic if it will do. */ intmax_t accum; if (FASTER_TIMEFNS - && !INT_MULTIPLY_WRAPV (t.tv_sec, TIMESPEC_HZ, &accum) - && !INT_ADD_WRAPV (t.tv_nsec, accum, &accum)) + && !ckd_mul (&accum, t.tv_sec, TIMESPEC_HZ) + && !ckd_add (&accum, accum, t.tv_nsec)) return make_int (accum); /* Fall back on bignum arithmetic. */ @@ -543,7 +543,7 @@ lisp_time_hz_ticks (struct lisp_time t, Lisp_Object hz) /* For speed, use intmax_t arithmetic if it will do. */ intmax_t ticks; if (FASTER_TIMEFNS && FIXNUMP (t.ticks) && FIXNUMP (t.hz) - && !INT_MULTIPLY_WRAPV (XFIXNUM (t.ticks), XFIXNUM (hz), &ticks)) + && !ckd_mul (&ticks, XFIXNUM (t.ticks), XFIXNUM (hz))) return make_int (ticks / XFIXNUM (t.hz) - (ticks % XFIXNUM (t.hz) < 0)); } @@ -1557,12 +1557,10 @@ usage: (decode-time &optional TIME ZONE FORM) */) Lisp_Object ticks; intmax_t n; if (FASTER_TIMEFNS && FIXNUMP (lt.ticks) && FIXNUMP (hz) - && !INT_MULTIPLY_WRAPV (XFIXNUM (hz), local_tm.tm_sec, &n) - && ! (INT_ADD_WRAPV - (n, (XFIXNUM (lt.ticks) % XFIXNUM (hz) - + (XFIXNUM (lt.ticks) % XFIXNUM (hz) < 0 - ? XFIXNUM (hz) : 0)), - &n))) + && !ckd_mul (&n, XFIXNUM (hz), local_tm.tm_sec) + && !ckd_add (&n, n, (XFIXNUM (lt.ticks) % XFIXNUM (hz) + + (XFIXNUM (lt.ticks) % XFIXNUM (hz) < 0 + ? XFIXNUM (hz) : 0)))) ticks = make_int (n); else { @@ -1603,7 +1601,7 @@ check_tm_member (Lisp_Object obj, int offset) CHECK_FIXNUM (obj); EMACS_INT n = XFIXNUM (obj); int i; - if (INT_SUBTRACT_WRAPV (n, offset, &i)) + if (ckd_sub (&i, n, offset)) time_overflow (); return i; } diff --git a/src/tparam.c b/src/tparam.c index 1a5eab37452..a0d2ee74d99 100644 --- a/src/tparam.c +++ b/src/tparam.c @@ -173,8 +173,7 @@ tparam1 (const char *string, char *outstring, int len, doup++, append_len_incr = strlen (up); else doleft++, append_len_incr = strlen (left); - if (INT_ADD_WRAPV (append_len_incr, - append_len, &append_len)) + if (ckd_add (&append_len, append_len, append_len_incr)) memory_full (SIZE_MAX); } } diff --git a/src/w32term.c b/src/w32term.c index 2899e82b295..57dc6b465e4 100644 --- a/src/w32term.c +++ b/src/w32term.c @@ -7378,7 +7378,7 @@ w32_initialize_display_info (Lisp_Object display_name) { static char const at[] = " at "; ptrdiff_t nbytes = sizeof (title) + sizeof (at); - if (INT_ADD_WRAPV (nbytes, SCHARS (Vsystem_name), &nbytes)) + if (ckd_add (&nbytes, nbytes, SCHARS (Vsystem_name))) memory_full (SIZE_MAX); dpyinfo->w32_id_name = xmalloc (nbytes); sprintf (dpyinfo->w32_id_name, "%s%s%s", title, at, SDATA (Vsystem_name)); diff --git a/src/xdisp.c b/src/xdisp.c index 982e1b3c103..e31533b3680 100644 --- a/src/xdisp.c +++ b/src/xdisp.c @@ -602,8 +602,8 @@ fill_column_indicator_column (struct it *it, int char_width) if (RANGED_FIXNUMP (0, col, INT_MAX)) { int icol = XFIXNUM (col); - if (!INT_MULTIPLY_WRAPV (char_width, icol, &icol) - && !INT_ADD_WRAPV (it->lnum_pixel_width, icol, &icol)) + if (!ckd_mul (&icol, icol, char_width) + && !ckd_add (&icol, icol, it->lnum_pixel_width)) return icol; } } @@ -28216,9 +28216,8 @@ decode_mode_spec (struct window *w, register int c, int field_width, ptrdiff_t position; ptrdiff_t distance = (line_number_display_limit_width < 0 ? 0 - : INT_MULTIPLY_WRAPV (line_number_display_limit_width, - height * 2 + 30, - &distance) + : ckd_mul (&distance, line_number_display_limit_width, + height * 2 + 30) ? PTRDIFF_MAX : distance); if (startpos - distance > limit) diff --git a/src/xselect.c b/src/xselect.c index 0586e46870b..40be6d4c00c 100644 --- a/src/xselect.c +++ b/src/xselect.c @@ -744,13 +744,13 @@ selection_data_size (struct selection_data *data) return (size_t) data->size; case 16: - if (INT_MULTIPLY_WRAPV (data->size, 2, &scratch)) + if (ckd_mul (&scratch, data->size, 2)) return SIZE_MAX; return scratch; case 32: - if (INT_MULTIPLY_WRAPV (data->size, 4, &scratch)) + if (ckd_mul (&scratch, data->size, 4)) return SIZE_MAX; return scratch; @@ -3027,7 +3027,7 @@ x_property_data_to_lisp (struct frame *f, const unsigned char *data, { ptrdiff_t format_bytes = format >> 3; ptrdiff_t data_bytes; - if (INT_MULTIPLY_WRAPV (size, format_bytes, &data_bytes)) + if (ckd_mul (&data_bytes, size, format_bytes)) memory_full (SIZE_MAX); return selection_data_to_lisp_data (FRAME_DISPLAY_INFO (f), data, data_bytes, type, format); diff --git a/src/xsmfns.c b/src/xsmfns.c index 799c9fd1053..3cf5165242e 100644 --- a/src/xsmfns.c +++ b/src/xsmfns.c @@ -223,7 +223,7 @@ smc_save_yourself_CB (SmcConn smcConn, props[props_idx]->name = xstrdup (SmRestartCommand); props[props_idx]->type = xstrdup (SmLISTofARRAY8); /* /path/to/emacs, --smid=xxx --no-splash --chdir=dir ... */ - if (INT_ADD_WRAPV (initial_argc, 3, &i)) + if (ckd_add (&i, initial_argc, 3)) memory_full (SIZE_MAX); props[props_idx]->num_vals = i; vp = xnmalloc (i, sizeof *vp); diff --git a/src/xterm.c b/src/xterm.c index 0899fcdc2d6..15bd9f98d17 100644 --- a/src/xterm.c +++ b/src/xterm.c @@ -2322,13 +2322,10 @@ xm_setup_dnd_targets (struct x_display_info *dpyinfo, target_count = header.target_list_count; rc = false; - if (INT_ADD_WRAPV (header.target_list_count, 1, - &header.target_list_count) - || INT_MULTIPLY_WRAPV (ntargets, 4, &size) - || INT_ADD_WRAPV (header.total_data_size, size, - &header.total_data_size) - || INT_ADD_WRAPV (header.total_data_size, 2, - &header.total_data_size)) + if (ckd_add (&header.target_list_count, header.target_list_count, 1) + || ckd_mul (&size, ntargets, 4) + || ckd_add (&header.total_data_size, header.total_data_size, size) + || ckd_add (&header.total_data_size, header.total_data_size, 2)) { /* Overflow, remove every entry from the targets table and add one for our current targets list. This @@ -6949,8 +6946,7 @@ x_sync_get_monotonic_time (struct x_display_info *dpyinfo, return 0; uint_fast64_t t; - return (INT_SUBTRACT_WRAPV (timestamp, dpyinfo->server_time_offset, &t) - ? 0 : t); + return ckd_sub (&t, timestamp, dpyinfo->server_time_offset) ? 0 : t; } # ifndef CLOCK_MONOTONIC @@ -6968,8 +6964,8 @@ x_sync_current_monotonic_time (void) return (((clock_gettime (CLOCK_MONOTONIC, &time) != 0 && (CLOCK_MONOTONIC == CLOCK_REALTIME || clock_gettime (CLOCK_REALTIME, &time) != 0)) - || INT_MULTIPLY_WRAPV (time.tv_sec, 1000000, &t) - || INT_ADD_WRAPV (t, time.tv_nsec / 1000, &t)) + || ckd_mul (&t, time.tv_sec, 1000000) + || ckd_add (&t, t, time.tv_nsec / 1000)) ? 0 : t); } @@ -6990,8 +6986,7 @@ x_sync_note_frame_times (struct x_display_info *dpyinfo, time = x_sync_get_monotonic_time (dpyinfo, low | (high << 32)); if (!time || !output->temp_frame_time - || INT_SUBTRACT_WRAPV (time, output->temp_frame_time, - &output->last_frame_time)) + || ckd_sub (&output->last_frame_time, time, output->temp_frame_time)) output->last_frame_time = 0; #ifdef FRAME_DEBUG @@ -7967,7 +7962,7 @@ x_display_set_last_user_time (struct x_display_info *dpyinfo, Time time, dpyinfo->server_time_monotonic_p = (monotonic_time != 0 - && !INT_SUBTRACT_WRAPV (time, monotonic_ms, &diff_ms) + && !ckd_sub (&diff_ms, time, monotonic_ms) && -500 < diff_ms && diff_ms < 500); if (!dpyinfo->server_time_monotonic_p) @@ -7976,10 +7971,9 @@ x_display_set_last_user_time (struct x_display_info *dpyinfo, Time time, time to estimate the monotonic time on the X server. */ if (!monotonic_time - || INT_MULTIPLY_WRAPV (time, 1000, &dpyinfo->server_time_offset) - || INT_SUBTRACT_WRAPV (dpyinfo->server_time_offset, - monotonic_time, - &dpyinfo->server_time_offset)) + || ckd_mul (&dpyinfo->server_time_offset, time, 1000) + || ckd_sub (&dpyinfo->server_time_offset, + dpyinfo->server_time_offset, monotonic_time)) dpyinfo->server_time_offset = 0; /* If the server time is reasonably close to the monotonic @@ -7988,18 +7982,18 @@ x_display_set_last_user_time (struct x_display_info *dpyinfo, Time time, actual time in ms. */ monotonic_ms = monotonic_ms & 0xffffffff; - if (!INT_SUBTRACT_WRAPV (time, monotonic_ms, &diff_ms) + if (!ckd_sub (&diff_ms, time, monotonic_ms) && -500 < diff_ms && diff_ms < 500) { /* The server timestamp overflowed. Make the time offset exactly how much it overflowed by. */ - if (INT_SUBTRACT_WRAPV (monotonic_time / 1000, monotonic_ms, - &dpyinfo->server_time_offset) - || INT_MULTIPLY_WRAPV (dpyinfo->server_time_offset, - 1000, &dpyinfo->server_time_offset) - || INT_SUBTRACT_WRAPV (0, dpyinfo->server_time_offset, - &dpyinfo->server_time_offset)) + if (ckd_sub (&dpyinfo->server_time_offset, + monotonic_time / 1000, monotonic_ms) + || ckd_mul (&dpyinfo->server_time_offset, + dpyinfo->server_time_offset, 1000) + || ckd_sub (&dpyinfo->server_time_offset, + 0, dpyinfo->server_time_offset)) dpyinfo->server_time_offset = 0; } } @@ -30199,7 +30193,7 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name) { static char const at[] = " at "; ptrdiff_t nbytes = sizeof (title) + sizeof (at); - if (INT_ADD_WRAPV (nbytes, SBYTES (system_name), &nbytes)) + if (ckd_add (&nbytes, nbytes, SBYTES (system_name))) memory_full (SIZE_MAX); dpyinfo->x_id_name = xmalloc (nbytes); sprintf (dpyinfo->x_id_name, "%s%s%s", title, at, SDATA (system_name)); -- cgit v1.2.1