; Grammar fixes for "native-compiled"

1. Prefer "native-compiled" to "native compiled".
The adjective "native-compiled" with the hyphen is generally more
consistent with the typical pattern in English, especially when the
compound modifies a noun (e.g., "native-compiled code").

2. Prefer "natively compiled" to "natively-compiled".
The adverb "natively" modifies "compiled", and it is standard not
to hyphenate an adverb + adjective combination when the adverb ends
in -ly (e.g., "code that is natively compiled").

For example, note that we say "high-speed internet" but "highly
performant code".

* Makefile.in (dest):
* configure.ac (HAVE_NATIVE_COMP):
* doc/emacs/building.texi (Lisp Libraries):
* doc/lispref/compile.texi (Native Compilation)
(Native-Compilation Functions, Native-Compilation Variables):
* doc/lispref/functions.texi (What Is a Function, Declare Form):
* doc/lispref/loading.texi (How Programs Do Loading, Library Search):
* etc/NEWS:
* etc/NEWS.28:
* etc/NEWS.29:
* etc/NEWS.30:
* lisp/emacs-lisp/comp-common.el (native-comp-never-optimize-functions)
(comp-function-type-spec):
* lisp/emacs-lisp/comp-cstr.el:
* lisp/subr.el (locate-eln-file):
* src/comp.c (SETJMP_NAME, syms_of_comp):
* src/data.c (Fsubrp, Fnative_comp_function_p, Fsubr_native_lambda_list):
* src/lread.c (Fload):
* src/pdumper.c (dump_do_dump_relocation):
* test/src/comp-tests.el (lambda-return2): Avoid grammatically incorrect
variations on "natively compiled" and "native-compiled".  (Bug#56727)

4 files changed, 21 insertions, 21 deletions

diff --git a/doc/emacs/building.texi b/doc/emacs/building.texi
index 1ee46d91a12..02ca71f069b 100644
--- a/doc/emacs/building.texi
+++ b/doc/emacs/building.texi
@@ -1580,7 +1580,7 @@ Emacs Lisp Reference Manual}.
 @cindex native compilation
   Emacs Lisp code can also be compiled into @dfn{native code}: machine
 code not unlike the one produced by a C or Fortran compiler.  Native
-code runs even faster than byte-code.  Natively-compiled Emacs Lisp
+code runs even faster than byte-code.  Natively compiled Emacs Lisp
 code is stored in files whose names end in @samp{.eln}.  @xref{Native
 Compilation,, Native Compilation, elisp, the Emacs Lisp Reference Manual}.
 
@@ -1660,7 +1660,7 @@ way, you don't need to modify the default value of @code{load-path}.
 
 @vindex native-comp-eln-load-path
   Similarly to @code{load-path}, the list of directories where Emacs
-looks for @file{*.eln} files with natively-compiled Lisp code is
+looks for @file{*.eln} files with native-compiled Lisp code is
 specified by the variable @code{native-comp-eln-load-path}.
 
 @cindex autoload
diff --git a/doc/lispref/compile.texi b/doc/lispref/compile.texi
index 060b5ccae4c..57e67001847 100644
--- a/doc/lispref/compile.texi
+++ b/doc/lispref/compile.texi
@@ -764,32 +764,32 @@ you to be able to native-compile Lisp code.
 
 @vindex native-compile@r{, a Lisp feature}
   To determine whether the current Emacs process can produce and load
-natively-compiled Lisp code, call
+natively compiled Lisp code, call
 @code{native-comp-available-p} (@pxref{Native-Compilation Functions}).
 
-  Unlike byte-compiled code, natively-compiled Lisp code is executed
+  Unlike byte-compiled code, native-compiled Lisp code is executed
 directly by the machine's hardware, and therefore runs at full speed
 that the host CPU can provide.  The resulting speedup generally
 depends on what the Lisp code does, but is usually 2.5 to 5 times
 faster than the corresponding byte-compiled code.
 
   Since native code is generally incompatible between different
-systems, the natively-compiled code is @emph{not} transportable from
+systems, the native-compiled code is @emph{not} transportable from
 one machine to another, it can only be used on the same machine where
 it was produced or on very similar ones (having the same CPU and
-run-time libraries).  The transportability of natively-compiled code
+run-time libraries).  The transportability of native-compiled code
 is the same as that of shared libraries (@file{.so} or @file{.dll}
 files).
 
-  Libraries of natively-compiled code include crucial dependencies on
+  Libraries of native-compiled code include crucial dependencies on
 Emacs Lisp primitives (@pxref{What Is a Function}) and their calling
-conventions, and thus Emacs usually won't load natively-compiled code
+conventions, and thus Emacs usually won't load native-compiled code
 produced by earlier or later Emacs versions; native compilation of the
 same Lisp code by a different Emacs version will usually produce a
-natively-compiled library under a unique file name that only that
+natively compiled library under a unique file name that only that
 version of Emacs will be able to load.  However, the use of unique
 file names enables several versions of the same Lisp library
-natively-compiled by several different versions of Emacs to be placed
+natively compiled by several different versions of Emacs to be placed
 within the same directory.
 
 @vindex no-native-compile
@@ -882,7 +882,7 @@ non-@code{nil}, tells the function to place the resulting @file{.eln}
 files in the last directory mentioned in
 @code{native-comp-eln-load-path} (@pxref{Library Search}); this is
 meant to be used as part of building an Emacs source tarball for the
-first time, when the natively-compiled files, which are absent from
+first time, when the native-compiled files, which are absent from
 the source tarball, should be generated in the build tree instead of
 the user's cache directory.
 @end defun
@@ -891,7 +891,7 @@ Native compilation can be run entirely asynchronously, in a subprocess
 of the main Emacs process.  This leaves the main Emacs process free to
 use while the compilation runs in the background.  This is the method
 used by Emacs to natively-compile any Lisp file or byte-compiled Lisp
-file that is loaded into Emacs, when no natively-compiled file for it
+file that is loaded into Emacs, when no native-compiled file for it
 is available.  Note that because of this use of a subprocess, native
 compilation may produce warning and errors which byte-compilation does
 not, and Lisp code may thus need to be modified to work correctly.  See
@@ -938,7 +938,7 @@ in any of the directories mentioned in the
 @deffn Command emacs-lisp-native-compile
 This command compiles the file visited by the current buffer into
 native code, if the file was changed since the last time it was
-natively-compiled.
+natively compiled.
 @end deffn
 
 @deffn Command emacs-lisp-native-compile-and-load
@@ -1125,13 +1125,13 @@ control this, use a separate variable, described below.
 This variable controls generation of trampolines.  A trampoline is a
 small piece of native code required to allow calling Lisp primitives,
 which were advised or redefined, from Lisp code that was
-natively-compiled with @code{native-comp-speed} set to 2 or greater.
+natively compiled with @code{native-comp-speed} set to 2 or greater.
 Emacs stores the generated trampolines on separate @file{*.eln} files.
 By default, this variable's value is @code{t}, which enables the
 generation of trampoline files; setting it to @code{nil} disables the
 generation of trampolines.  Note that if a trampoline needed for
 advising or redefining a primitive is not available and cannot be
-generated, calls to that primitive from natively-compiled Lisp will
+generated, calls to that primitive from native-compiled Lisp will
 ignore redefinitions and advices, and will behave as if the primitive
 was called directly from C.  Therefore, we don't recommend disabling
 the trampoline generation, unless you know that all the trampolines
diff --git a/doc/lispref/functions.texi b/doc/lispref/functions.texi
index 8ed992d3e79..024ff2b7d5a 100644
--- a/doc/lispref/functions.texi
+++ b/doc/lispref/functions.texi
@@ -223,7 +223,7 @@ that is not in the form of ELisp source code but something like
 machine code or byte code instead.  More specifically it returns
 @code{t} if the function is built-in (a.k.a.@: ``primitive'',
 @pxref{What Is a Function}), or byte-compiled (@pxref{Byte
-Compilation}), or natively-compiled (@pxref{Native Compilation}), or
+Compilation}), or native-compiled (@pxref{Native Compilation}), or
 a function loaded from a dynamic module (@pxref{Dynamic Modules}).
 @end defun
 
@@ -2868,7 +2868,7 @@ For description of additional types, see @ref{Lisp Data Types}).
 
 Declaring a function with an incorrect type produces undefined behavior
 and could lead to unexpected results or might even crash Emacs when
-natively-compiled code is loaded, if it was compiled with
+native-compiled code is loaded, if it was compiled with
 @code{compilation-safety} level of zero (@pxref{compilation-safety}).
 Note also that when redefining (or advising) a type-declared function,
 the replacement should respect the original signature to avoid such
diff --git a/doc/lispref/loading.texi b/doc/lispref/loading.texi
index 15922cf1e89..87ebb787250 100644
--- a/doc/lispref/loading.texi
+++ b/doc/lispref/loading.texi
@@ -117,7 +117,7 @@ If the option @code{load-prefer-newer} is non-@code{nil}, then when
 searching suffixes, @code{load} selects whichever version of a file
 (@samp{.elc}, @samp{.el}, etc.)@: has been modified most recently.
 In this case, @code{load} doesn't load the @samp{.eln}
-natively-compiled file even if it exists.
+native-compiled file even if it exists.
 
 If @var{filename} is a relative file name, such as @file{foo} or
 @file{baz/foo.bar}, @code{load} searches for the file using the variable
@@ -161,7 +161,7 @@ during compilation.  @xref{Compiling Macros}.
 
 Messages like @samp{Loading foo...} and @samp{Loading foo...done} appear
 in the echo area during loading unless @var{nomessage} is
-non-@code{nil}.  If a natively-compiled @samp{.eln} file is loaded,
+non-@code{nil}.  If a native-compiled @samp{.eln} file is loaded,
 the message says so.
 
 @cindex load errors
@@ -462,13 +462,13 @@ the shadowed files as a string.
 (@pxref{Native Compilation}), then when a @samp{.elc} byte-compiled
 file is found by searching @code{load-path}, Emacs will try to look
 for a corresponding @samp{.eln} file holding the corresponding
-natively-compiled code.  The natively-compiled files are looked up in
+native-compiled code.  The native-compiled files are looked up in
 the directories listed by the @code{native-comp-eln-load-path}.
 
 @vindex comp-native-version-dir
 @defvar native-comp-eln-load-path
 This variable holds a list of directories where Emacs looks for
-natively-compiled @samp{.eln} files.  File names in the list that are
+native-compiled @samp{.eln} files.  File names in the list that are
 not absolute are interpreted as relative to @code{invocation-directory}
 (@pxref{System Environment}).  The last directory in the list is the
 system directory, i.e.@: the directory with @samp{.eln} files