FIXED: #1093 PL_initialise() no longer mutates the process LC_NUMERIC locale

initLocale() used to call setlocale(LC_NUMERIC, "") to bootstrap the
default PL_locale from localeconv().  As a side effect it changed the
embedder's process-wide decimal separator, breaking atof() and
printf("%f") in host code that expects the C locale.  Read the
environment's numeric conventions via newlocale()/uselocale() (POSIX
2008) instead, with a save/setlocale/restore fallback under L_LOCALE
for platforms without them.  locale_create/3 uses the same helper.

Also fix a latent bug in update_locale() that only surfaced with the
above change: Prolog setlocale/3 for unrelated categories (notably
LC_MESSAGES from os_user_lang/1 during boot) was unconditionally
re-reading localeconv() and clobbering the decimal_point picked up at
init time.  Gate the refresh on LC_NUMERIC / LC_ALL.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: JanWielemaker

cmake/Config.cmake

@@ -193,6 +193,8 @@ check_function_exists(setlocale HAVE_SETLOCALE)
 check_function_exists(mbsnrtowcs HAVE_MBSNRTOWCS)
 check_function_exists(mbcasescoll HAVE_MBCASESCOLL)
 check_function_exists(localeconv HAVE_LOCALECONV)
+check_function_exists(newlocale HAVE_NEWLOCALE)
+check_function_exists(uselocale HAVE_USELOCALE)
 check_function_exists(wcsdup HAVE_WCSDUP)
 check_function_exists(wcsxfrm HAVE_WCSXFRM)
 check_function_exists(wcwidth HAVE_WCWIDTH)

man/builtin.plx

@@ -7952,7 +7952,12 @@ integers from digit groups was discussed on the SWI-Prolog mailinglist.
 Most input in this discussion is from Ulrich Neumerkel and Richard
 O'Keefe. The predicates in this section were designed by Jan
 Wielemaker.} The system creates a default locale object named
-\const{default} from the system locale. This locale is used as the
+\const{default} from the environment's \const{LC_NUMERIC} locale
+without modifying the process locale.  This is important for
+applications that embed SWI-Prolog: PL_initialise() will not change
+the process-wide decimal separator used by \cfuncref{atof}{} or
+\cfuncref{printf}{} in the host application. See also
+\secref{embed-locale}. The \const{default} locale is used as the
 initial locale for the three standard streams as well as the
 \const{main} thread. Locale sensitive output predicates such as format/3
 get their locale from the stream to which they deliver their output. New

man/foreign.plx

@@ -5321,6 +5321,25 @@ signal may be changed using the \cmdlineoption{--sigalert=NUM} option or
 disabled using \verb$--sigalert=0$.
 
 
+\subsection{Locale and PL_initialise()}		\label{sec:embed-locale}
+
+PL_initialise() reads the numeric conventions (decimal point, thousands
+separator, digit grouping) of the environment's \const{LC_NUMERIC}
+locale for use by locale-sensitive predicates such as format/3 with
+\const{~:d} and \const{~:f} directives. See \secref{locale}. It does
+so without calling \cfuncref{setlocale}{}, so the embedder's process
+locale is left untouched and functions such as \cfuncref{atof}{} and
+\cfuncref{printf}{}(\const{"\%f"}) continue to use the decimal point
+that was in effect before PL_initialise() was called.
+
+PL_initialise() does call \cfuncref{setlocale}{} for \const{LC_CTYPE}
+(to pick up the multibyte encoding used for atoms and streams),
+\const{LC_TIME} and \const{LC_COLLATE}. Embedders that require a
+strict \const{"C"} locale for these categories should either arrange
+the environment before starting the process or reset the desired
+categories after PL_initialise() returns.
+
+
 
 \section{Linking embedded applications using swipl-ld}	\label{sec:plld}
 

src/config.h.cmake

@@ -93,6 +93,8 @@
 #cmakedefine HAVE_MP_BITCNT_T @HAVE_MP_BITCNT_T@
 #cmakedefine HAVE_MTRACE @HAVE_MTRACE@
 #cmakedefine HAVE_NANOSLEEP @HAVE_NANOSLEEP@
+#cmakedefine HAVE_NEWLOCALE @HAVE_NEWLOCALE@
+#cmakedefine HAVE_USELOCALE @HAVE_USELOCALE@
 #cmakedefine HAVE_NCURSES_CURSES_H @HAVE_NCURSES_CURSES_H@
 #cmakedefine HAVE_NCURSES_TERM_H @HAVE_NCURSES_TERM_H@
 #cmakedefine HAVE_NDIR_H @HAVE_NDIR_H@

src/os/pl-locale.c

@@ -119,6 +119,53 @@ init_locale_strings(PL_locale *l, struct lconv *conv)
 }
 
 
+/* Fill L with the LC_NUMERIC conventions for LNAME ("" == environment)
+ * without mutating the process-wide locale.  Returns true on success.
+ *
+ * PL_initialise() historically called setlocale(LC_NUMERIC, "") to
+ * bootstrap the default PL_locale from localeconv().  That silently
+ * changed the embedder's process locale, breaking atof() and printf
+ * "%f" in locales that use "," as the decimal separator (issue #1093).
+ * The POSIX-2008 newlocale()/uselocale() pair changes only the
+ * calling thread's locale, so localeconv() reads the requested
+ * conventions without touching the process locale.  Where those are
+ * unavailable we fall back to a save/setlocale/restore dance under
+ * L_LOCALE, which is safe during initialisation (single-threaded) and
+ * during locale_create/3 (already serialised on L_LOCALE).
+ */
+
+static bool
+fill_locale_from_name(PL_locale *l, const char *lname)
+{ bool rc;
+
+#if defined(HAVE_NEWLOCALE) && defined(HAVE_USELOCALE)
+  locale_t loc = newlocale(LC_NUMERIC_MASK, lname, (locale_t)0);
+  if ( !loc )
+    return false;
+  locale_t old = uselocale(loc);
+  rc = init_locale_strings(l, localeconv());
+  uselocale(old);
+  freelocale(loc);
+#else
+  PL_LOCK(L_LOCALE);
+  const char *saved = setlocale(LC_NUMERIC, NULL);
+  char *old = saved ? strdup(saved) : NULL;
+  if ( !setlocale(LC_NUMERIC, lname) )
+  { free(old);
+    PL_UNLOCK(L_LOCALE);
+    return false;
+  }
+  rc = init_locale_strings(l, localeconv());
+  if ( old )
+    setlocale(LC_NUMERIC, old);
+  free(old);
+  PL_UNLOCK(L_LOCALE);
+#endif
+
+  return rc;
+}
+
+
 static PL_locale *
 new_locale(PL_locale *proto)
 { PL_locale *new = PL_malloc(sizeof(*new));
@@ -131,8 +178,8 @@ new_locale(PL_locale *proto)
     { new->decimal_point = wcsdup(proto->decimal_point);
       new->thousands_sep = wcsdup(proto->thousands_sep);
       new->grouping      = strdup(proto->grouping);
-    } else
-    { init_locale_strings(new, localeconv());
+    } else if ( !fill_locale_from_name(new, "") )
+    { init_locale_strings(new, NULL);
     }
   }
 
@@ -161,8 +208,14 @@ free_locale(PL_locale *l)
 
 static void
 update_locale(PL_locale *l, int category, const char *locale)
-{ free_locale_strings(l);
-  init_locale_strings(l, localeconv());
+{ /* Only numeric conventions live in a PL_locale.  Refreshing them for
+   * unrelated categories such as LC_MESSAGES would clobber the values
+   * picked up at init time from the environment's LC_NUMERIC.
+   */
+  if ( category == LC_NUMERIC || category == LC_ALL )
+  { free_locale_strings(l);
+    init_locale_strings(l, localeconv());
+  }
 }
 
 
@@ -718,19 +771,17 @@ PRED_IMPL("locale_create", 3, locale_create, 0)
     { if ( strcmp(lname, "default") == 0 )
       { new = new_locale(NULL);
       } else
-      { const char *old;
-
-	PL_LOCK(L_LOCALE);
-	if ( (old=setlocale(LC_NUMERIC, lname)) )
-	{ new = new_locale(NULL);
-	  setlocale(LC_NUMERIC, old);
-	}
-	PL_UNLOCK(L_LOCALE);
-	if ( !old )
-	{ if ( errno == ENOENT )
-	    return PL_existence_error("locale", A2);
-	  else
-	    return PL_error(NULL, 0, MSG_ERRNO, ERR_SYSCALL, "setlocale");
+      { if ( (new = PL_malloc(sizeof(*new))) )
+	{ memset(new, 0, sizeof(*new));
+	  new->magic = LOCALE_MAGIC;
+	  if ( !fill_locale_from_name(new, lname) )
+	  { PL_free(new);
+	    new = NULL;
+	    if ( errno == ENOENT )
+	      return PL_existence_error("locale", A2);
+	    else
+	      return PL_error(NULL, 0, MSG_ERRNO, ERR_SYSCALL, "setlocale");
+	  }
 	}
       }
     } else
@@ -881,9 +932,10 @@ initLocale(void)
 { GET_LD
   PL_locale *def;
 
-  if ( !setlocale(LC_NUMERIC, "") )
-  { DEBUG(0, Sdprintf("Failed to set LC_NUMERIC locale\n"));
-  }
+  /* new_locale(NULL) queries the environment's LC_NUMERIC conventions
+   * via read_lconv() without touching the process locale, so an
+   * embedder's atof()/printf("%f") remain deterministic (issue #1093).
+   */
 
   if ( (def = new_locale(NULL)) )
   { alias_locale(def, ATOM_default);