mirrors/emacs
1
Fork 0
mirror of git://git.sv.gnu.org/emacs.git synced 2026-01-01 18:00:40 -08:00
Code Issues Projects Releases Wiki Activity

Update from Gnulib by running admin/merge-gnulib

Browse source
This commit is contained in:
Paul Eggert 2025-12-25 09:52:44 -08:00
parent 0a6daa1412
commit 7be4fe89fc
6 changed files with 146 additions and 89 deletions
Download patch file Download diff file Expand all files Collapse all files

16
doc/misc/texinfo.tex
View file

@ -3,7 +3,7 @@
% Load plain if necessary, i.e., if running under initex.
\expandafter\ifx\csname fmtname\endcsname\relax\input plain\fi
%
\def\texinfoversion{2025-12-06.19}
\def\texinfoversion{2025-12-23.13}
%
% Copyright 1985, 1986, 1988, 1990-2025 Free Software Foundation, Inc.
%
@ -10435,7 +10435,7 @@ directory should work if nowhere else does.}
\gdefchar^^af{\={}}
%
\gdefchar^^b0{\textdegree}
\gdefchar^^b1{$\pm$}
\gdefchar^^b1{\ensuremath\pm}
\gdefchar^^b2{$^2$}
\gdefchar^^b3{$^3$}
\gdefchar^^b4{\'{}}
@ -10456,7 +10456,7 @@ directory should work if nowhere else does.}
\gdefchar^^c2{\^A}
\gdefchar^^c3{\~A}
\gdefchar^^c4{\"A}
\gdefchar^^c5{\ringaccent A}
\gdefchar^^c5{\AA}
\gdefchar^^c6{\AE}
\gdefchar^^c7{\cedilla C}
\gdefchar^^c8{\`E}
@ -10475,7 +10475,7 @@ directory should work if nowhere else does.}
\gdefchar^^d4{\^O}
\gdefchar^^d5{\~O}
\gdefchar^^d6{\"O}
\gdefchar^^d7{$\times$}
\gdefchar^^d7{\ensuremath\times}
\gdefchar^^d8{\O}
\gdefchar^^d9{\`U}
\gdefchar^^da{\'U}
@ -10490,7 +10490,7 @@ directory should work if nowhere else does.}
\gdefchar^^e2{\^a}
\gdefchar^^e3{\~a}
\gdefchar^^e4{\"a}
\gdefchar^^e5{\ringaccent a}
\gdefchar^^e5{\aa}
\gdefchar^^e6{\ae}
\gdefchar^^e7{\cedilla c}
\gdefchar^^e8{\`e}
@ -10509,7 +10509,7 @@ directory should work if nowhere else does.}
\gdefchar^^f4{\^o}
\gdefchar^^f5{\~o}
\gdefchar^^f6{\"o}
\gdefchar^^f7{$\div$}
\gdefchar^^f7{\ensuremath\div}
\gdefchar^^f8{\o}
\gdefchar^^f9{\`u}
\gdefchar^^fa{\'u}
@ -10595,7 +10595,7 @@ directory should work if nowhere else does.}
\gdefchar^^d4{\^O}
\gdefchar^^d5{\H O}
\gdefchar^^d6{\"O}
\gdefchar^^d7{$\times$}
\gdefchar^^d7{\ensuremath\times}
\gdefchar^^d8{\v R}
\gdefchar^^d9{\ringaccent U}
\gdefchar^^da{\'U}
@ -10629,7 +10629,7 @@ directory should work if nowhere else does.}
\gdefchar^^f4{\^o}
\gdefchar^^f5{\H o}
\gdefchar^^f6{\"o}
\gdefchar^^f7{$\div$}
\gdefchar^^f7{\ensuremath\div}
\gdefchar^^f8{\v r}
\gdefchar^^f9{\ringaccent u}
\gdefchar^^fa{\'u}

104
lib/attribute.h
View file

@ -89,7 +89,7 @@
_GL_ATTRIBUTE_NONNULL_IF_NONZERO, _GL_ATTRIBUTE_NONSTRING,
_GL_ATTRIBUTE_NOTHROW, _GL_ATTRIBUTE_PACKED, _GL_ATTRIBUTE_PURE,
_GL_ATTRIBUTE_REPRODUCIBLE, _GL_ATTRIBUTE_RETURNS_NONNULL,
_GL_ATTRIBUTE_SENTINEL, _GL_ATTRIBUTE_UNSEQUENCED. */
_GL_ATTRIBUTE_SENTINEL, _GL_ATTRIBUTE_UNSEQUENCED, _GL_UNNAMED. */
#if !_GL_CONFIG_H_INCLUDED
#error "Please include config.h first."
#endif
@ -240,62 +240,68 @@
/* Applies to: functions. */
#define ATTRIBUTE_ALWAYS_INLINE _GL_ATTRIBUTE_ALWAYS_INLINE
/* It is OK for a compiler to move calls to the function and to omit
calls to the function if another call has the same arguments or the
result is not used.
This attribute is safe for a function that neither depends on
nor affects state, and always returns exactly once -
/* It is OK for a compiler to move a call, or omit a duplicate call
and reuse a cached return value, even if the state changes between calls.
It is also OK to omit a call if the result is not used.
This attribute is safe if the function does not change observable state,
returns a value determined solely by its arguments' values
without examining state, and always returns exactly once -
e.g., does not raise an exception, call longjmp, or loop forever.
(This attribute is stricter than ATTRIBUTE_PURE because the
function cannot observe state. It is stricter than UNSEQUENCED
because the function must return exactly once and cannot depend on
state addressed by its arguments.) */
(This attribute is stricter than _GL_ATTRIBUTE_PURE because the
function cannot observe state. Unlike _GL_ATTRIBUTE_UNSEQUENCED
the function must return exactly once and cannot access state
addressed by its pointer arguments or that happens to have the same
value for all calls to the function, but the function is allowed to
return a pointer to storage that can be modified later. */
/* Applies to: functions. */
#define ATTRIBUTE_CONST _GL_ATTRIBUTE_CONST
/* It is OK for a compiler to move calls to the function and to omit duplicate
calls to the function with the same arguments, so long as the state
addressed by its arguments is the same.
/* It is OK for a compiler to move a call, or omit a duplicate call
and reuse a cached value returned either directly or indirectly via
a pointer, if the state addressed by its pointer arguments is the same;
however, pointer arguments cannot alias.
This attribute is safe for a function that is effectless, idempotent,
stateless, and independent; see ISO C 23 § 6.7.13.8 for a definition of
these terms.
(This attribute is stricter than REPRODUCIBLE because the function
must be stateless and independent. It is looser than ATTRIBUTE_CONST
because the function need not return exactly once and can depend
on state addressed by its arguments.)
(This attribute is stricter than _GL_ATTRIBUTE_REPRODUCIBLE because
the function must be stateless and independent. Unlike
_GL_ATTRIBUTE_CONST the function need not return exactly once, and
can depend on state accessed via its pointer arguments or that
happens to have the same value for all calls to the function, but
the function cannot return a pointer to storage whose contents
change later.)
See also <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2956.htm> and
<https://stackoverflow.com/questions/76847905/>.
ATTENTION! Efforts are underway to change the meaning of this attribute.
See <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3494.htm>. */
<https://stackoverflow.com/questions/76847905/>. */
/* Applies to: functions, pointer to functions, function type. */
#define UNSEQUENCED _GL_ATTRIBUTE_UNSEQUENCED
/* It is OK for a compiler to move calls to the function and to omit
calls to the function if another call has the same arguments or the
result is not used, and if observable state is the same.
This attribute is safe for a function that does not affect observable state
and always returns exactly once.
(This attribute is looser than ATTRIBUTE_CONST because the function
can depend on observable state. It is stricter than REPRODUCIBLE
because the function must return exactly once and cannot affect
state addressed by its arguments.) */
/* It is OK for a compiler to move a call, or omit a duplicate call
and reuse a cached return value, if observable state is the same.
It is also OK to omit a call if the return value is not used.
This attribute is safe if the function does not change observable state,
returns a value determined solely by its arguments's values
together with observable state, and always returns exactly once.
(This attribute is looser than _GL_ATTRIBUTE_CONST because the function
can depend on observable state.
Unlike _GL_ATTRIBUTE_REPRODUCIBLE the function must return exactly
once and cannot change state addressed by its arguments, but the
function can return a pointer to storage whose contents change later.) */
/* Applies to: functions. */
#define ATTRIBUTE_PURE _GL_ATTRIBUTE_PURE
/* It is OK for a compiler to move calls to the function and to omit duplicate
calls to the function with the same arguments, so long as the state
addressed by its arguments is the same and is updated in time for
the rest of the program.
This attribute is safe for a function that is effectless and idempotent; see
ISO C 23 § 6.7.13.8 for a definition of these terms.
(This attribute is looser than UNSEQUENCED because the function need
not be stateless and idempotent. It is looser than ATTRIBUTE_PURE
because the function need not return exactly once and can affect
state addressed by its arguments.)
/* It is OK for a compiler to move a call, or omit a duplicate call
and reuse a cached value returned either directly or indirectly via
a pointer, if other observable state is the same;
however, pointer arguments cannot alias.
This attribute is safe for a function that is effectless and idempotent;
see ISO C 23 § 6.7.13.8 for a definition of these terms.
(This attribute is looser than _GL_ATTRIBUTE_UNSEQUENCED because
the function need not be stateless or independent.
Unlike _GL_ATTRIBUTE_PURE the function need not return exactly once
and can change state addressed by its pointer arguments, but the
function cannot return a pointer to storage whose contents change later.)
See also <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2956.htm> and
<https://stackoverflow.com/questions/76847905/>.
ATTENTION! Efforts are underway to change the meaning of this attribute.
See <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3494.htm>. */
<https://stackoverflow.com/questions/76847905/>. */
/* Applies to: functions, pointer to functions, function type. */
#define REPRODUCIBLE _GL_ATTRIBUTE_REPRODUCIBLE
@ -328,4 +334,18 @@
#define ATTRIBUTE_MAY_ALIAS _GL_ATTRIBUTE_MAY_ALIAS
/* ==================== Unnamed function parameters ======================== */
/* Although UNNAMED is not an attribute, it is related to MAYBE_UNUSED
and so is defined here for convenience. */
/* UNNAMED (ID) is the "name" of an unnamed function parameter.
Each of the function's unnamed parameters should have a unique "name".
The "name" cannot be used. This ports both to C17 and earlier, which
lack unnamed parameters, and to C++ and later C, which have them. */
/* Applies to:
- function parameters. */
#define UNNAMED(id) _GL_UNNAMED (id)
#endif /* _GL_ATTRIBUTE_H */

11
lib/file-has-acl.c
View file

@ -79,16 +79,15 @@ smack_smackfs_path (void)
return NULL;
}
static ssize_t
smack_new_label_from_path (MAYBE_UNUSED const char *path,
MAYBE_UNUSED const char *xattr,
MAYBE_UNUSED int follow, MAYBE_UNUSED char **label)
smack_new_label_from_path (const char *UNNAMED (path),
const char *UNNAMED (xattr),
int UNNAMED (follow), char **UNNAMED (label))
{
return -1;
}
static ssize_t
smack_new_label_from_file (MAYBE_UNUSED int fd,
MAYBE_UNUSED const char *xattr,
MAYBE_UNUSED char **label)
smack_new_label_from_file (int UNNAMED (fd), const char *UNNAMED (xattr),
char **UNNAMED (label))
{
return -1;
}

8
lib/timespec.h
View file

@ -20,7 +20,7 @@
#define TIMESPEC_H
/* This file uses _GL_INLINE_HEADER_BEGIN, _GL_INLINE, _GL_ATTRIBUTE_CONST,
_GL_ATTRIBUTE_PURE, _GL_CMP. */
_GL_CMP. */
#if !_GL_CONFIG_H_INCLUDED
#error "Please include config.h first."
#endif
@ -60,7 +60,7 @@ make_timespec (time_t s, long int ns)
/* Return negative, zero, positive if A < B, A == B, A > B, respectively. */
_GL_TIMESPEC_INLINE int _GL_ATTRIBUTE_PURE
_GL_TIMESPEC_INLINE int _GL_ATTRIBUTE_CONST
timespec_cmp (struct timespec a, struct timespec b)
{
return 2 * _GL_CMP (a.tv_sec, b.tv_sec) + _GL_CMP (a.tv_nsec, b.tv_nsec);
@ -68,10 +68,10 @@ timespec_cmp (struct timespec a, struct timespec b)
/* Return -1, 0, 1, depending on the sign of A. A.tv_nsec must be
nonnegative. */
_GL_TIMESPEC_INLINE int _GL_ATTRIBUTE_PURE
_GL_TIMESPEC_INLINE int _GL_ATTRIBUTE_CONST
timespec_sign (struct timespec a)
{
return _GL_CMP (a.tv_sec, 0) + (!a.tv_sec & !!a.tv_nsec);
return _GL_CMP (a.tv_sec | a.tv_nsec, 0);
}
struct timespec timespec_add (struct timespec, struct timespec)

75
m4/gnulib-common.m4
View file

@ -422,15 +422,17 @@ AC_DEFUN([gl_COMMON_BODY], [
without examining state, and always returns exactly once -
e.g., does not raise an exception, call longjmp, or loop forever.
(This attribute is stricter than _GL_ATTRIBUTE_PURE because the
function cannot observe state. It is stricter than
_GL_ATTRIBUTE_UNSEQUENCED because the function must return exactly
once and cannot access state addressed by its arguments.) */
function cannot observe state. Unlike _GL_ATTRIBUTE_UNSEQUENCED
the function must return exactly once and cannot access state
addressed by its pointer arguments or that happens to have the same
value for all calls to the function, but the function is allowed to
return a pointer to storage that can be modified later. */
/* Applies to: functions. */
#ifndef _GL_ATTRIBUTE_CONST
# if _GL_HAS_ATTRIBUTE (const)
# define _GL_ATTRIBUTE_CONST __attribute__ ((__const__))
# else
# define _GL_ATTRIBUTE_CONST _GL_ATTRIBUTE_UNSEQUENCED
# define _GL_ATTRIBUTE_CONST
# endif
#endif
@ -591,7 +593,9 @@ AC_DEFUN([gl_COMMON_BODY], [
/* _GL_ATTRIBUTE_MAYBE_UNUSED declares that it is not a programming mistake if
the entity is not used. The compiler should not warn if the entity is not
used. */
used. However, 'int _GL_UNNAMED (i)' is preferable to
'_GL_ATTRIBUTE_MAYBE_UNUSED int i' when parameter I is unused
regardless of preprocessor macro settings. */
/* Applies to:
- function, variable,
- struct, union, struct/union member,
@ -752,34 +756,33 @@ AC_DEFUN([gl_COMMON_BODY], [
returns a value determined solely by its arguments's values
together with observable state, and always returns exactly once.
(This attribute is looser than _GL_ATTRIBUTE_CONST because the function
can depend on observable state. It is stricter than
_GL_ATTRIBUTE_REPRODUCIBLE because the function must return exactly
once and cannot change state addressed by its arguments.) */
can depend on observable state.
Unlike _GL_ATTRIBUTE_REPRODUCIBLE the function must return exactly
once and cannot change state addressed by its arguments, but the
function can return a pointer to storage whose contents change later.) */
/* Applies to: functions. */
#ifndef _GL_ATTRIBUTE_PURE
# if _GL_HAS_ATTRIBUTE (pure)
# define _GL_ATTRIBUTE_PURE __attribute__ ((__pure__))
# else
# define _GL_ATTRIBUTE_PURE _GL_ATTRIBUTE_REPRODUCIBLE
# define _GL_ATTRIBUTE_PURE
# endif
#endif
/* _GL_ATTRIBUTE_REPRODUCIBLE declares:
It is OK for a compiler to move a call, or omit a duplicate call
and reuse a cached value returned either directly or indirectly
via a pointer argument, if other observable state is the same;
however, these pointer arguments cannot alias.
and reuse a cached value returned either directly or indirectly via
a pointer, if other observable state is the same;
however, pointer arguments cannot alias.
This attribute is safe for a function that is effectless and idempotent;
see ISO C 23 § 6.7.13.8 for a definition of these terms.
(This attribute is looser than _GL_ATTRIBUTE_UNSEQUENCED because
the function need not be stateless or independent. It is looser
from _GL_ATTRIBUTE_PURE because the function need not return
exactly once, and it can change state addressed by its pointer arguments
that do not alias.)
the function need not be stateless or independent.
Unlike _GL_ATTRIBUTE_PURE the function need not return exactly once
and can change state addressed by its pointer arguments, but the
function cannot return a pointer to storage whose contents change later.)
See also <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2956.htm> and
<https://stackoverflow.com/questions/76847905/>.
ATTENTION! Efforts are underway to change the meaning of this attribute.
See <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3494.htm>. */
<https://stackoverflow.com/questions/76847905/>. */
/* Applies to: functions, pointer to functions, function types. */
#ifndef _GL_ATTRIBUTE_REPRODUCIBLE
/* This may be revisited when gcc and clang support [[reproducible]] or possibly
@ -820,20 +823,21 @@ AC_DEFUN([gl_COMMON_BODY], [
/* _GL_ATTRIBUTE_UNSEQUENCED declares:
It is OK for a compiler to move a call, or omit a duplicate call
and reuse a cached return value, addressed by its arguments is the same.
and reuse a cached value returned either directly or indirectly via
a pointer, if the state addressed by its pointer arguments is the same;
however, pointer arguments cannot alias.
This attribute is safe for a function that is effectless, idempotent,
stateless, and independent; see ISO C 23 § 6.7.13.8 for a definition of
these terms.
(This attribute is stricter than _GL_ATTRIBUTE_REPRODUCIBLE because
the function must be stateless and independent. It differs from
_GL_ATTRIBUTE_CONST because the function need not return exactly
once and can depend on state accessed via its pointer arguments
that do not alias, or on other state that happens to have the
same value for all calls to the function.)
the function must be stateless and independent. Unlike
_GL_ATTRIBUTE_CONST the function need not return exactly once, and
can depend on state accessed via its pointer arguments or that
happens to have the same value for all calls to the function, but
the function cannot return a pointer to storage whose contents
change later.)
See also <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2956.htm> and
<https://stackoverflow.com/questions/76847905/>.
ATTENTION! Efforts are underway to change the meaning of this attribute.
See <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3494.htm>. */
<https://stackoverflow.com/questions/76847905/>. */
/* Applies to: functions, pointer to functions, function types. */
#ifndef _GL_ATTRIBUTE_UNSEQUENCED
/* This may be revisited when gcc and clang support [[unsequenced]] or possibly
@ -873,6 +877,21 @@ AC_DEFUN([gl_COMMON_BODY], [
# endif
#endif
/* _GL_UNNAMED (ID) is the "name" of an unnamed function parameter.
Each of the function's unnamed parameters should have a unique "name".
The "name" cannot be used. This ports both to C17 and earlier, which
lack unnamed parameters, and to C++ and later C, which have them. */
/* Applies to:
- function parameters. */
#ifndef _GL_UNNAMED
# if ((defined __STDC_VERSION__ ? __STDC_VERSION__ : 0) < 202311 \
&& !defined __cplusplus)
# define _GL_UNNAMED(id) unnamed_##id _GL_ATTRIBUTE_UNUSED
# else
# define _GL_UNNAMED(id)
# endif
#endif
/* The following attributes enable detection of multithread-safety problems
and resource leaks at compile-time, by clang ≥ 15, when the warning option
-Wthread-safety is enabled. For usage, see

21
m4/nanosleep.m4
View file

@ -1,5 +1,5 @@
# nanosleep.m4
# serial 47
# serial 48
dnl Copyright (C) 1999-2001, 2003-2025 Free Software Foundation, Inc.
dnl This file is free software; the Free Software Foundation
dnl gives unlimited permission to copy and/or distribute it,
@ -144,6 +144,25 @@ AC_DEFUN([gl_FUNC_NANOSLEEP],
;;
esac
else
# Replace the static inline function on mingw which requires linking to
# libwinpthreads.
AC_CACHE_CHECK([for static inline nanosleep],
[gl_cv_static_inline_nanosleep],
[AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM(
[[#include <time.h>]],
[[
static struct timespec ts1;
static struct timespec ts2;
return nanosleep (&ts1, &ts2);
]])
],
[gl_cv_static_inline_nanosleep=yes],
[gl_cv_static_inline_nanosleep=no])
])
if test $gl_cv_static_inline_nanosleep = yes; then
REPLACE_NANOSLEEP=1
fi
HAVE_NANOSLEEP=0
fi
LIBS=$gl_saved_LIBS