PostgreSQL Source Code  git master
win32setlocale.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * win32setlocale.c
4  * Wrapper to work around bugs in Windows setlocale() implementation
5  *
6  * Copyright (c) 2011-2019, PostgreSQL Global Development Group
7  *
8  * IDENTIFICATION
9  * src/port/win32setlocale.c
10  *
11  *
12  * The setlocale() function in Windows is broken in two ways. First, it
13  * has a problem with locale names that have a dot in the country name. For
14  * example:
15  *
16  * "Chinese (Traditional)_Hong Kong S.A.R..950"
17  *
18  * For some reason, setlocale() doesn't accept that as argument, even though
19  * setlocale(LC_ALL, NULL) returns exactly that. Fortunately, it accepts
20  * various alternative names for such countries, so to work around the broken
21  * setlocale() function, we map the troublemaking locale names to accepted
22  * aliases, before calling setlocale().
23  *
24  * The second problem is that the locale name for "Norwegian (Bokmål)"
25  * contains a non-ASCII character. That's problematic, because it's not clear
26  * what encoding the locale name itself is supposed to be in, when you
27  * haven't yet set a locale. Also, it causes problems when the cluster
28  * contains databases with different encodings, as the locale name is stored
29  * in the pg_database system catalog. To work around that, when setlocale()
30  * returns that locale name, map it to a pure-ASCII alias for the same
31  * locale.
32  *-------------------------------------------------------------------------
33  */
34 
35 #include "c.h"
36 
37 #undef setlocale
38 
39 struct locale_map
40 {
41  /*
42  * String in locale name to replace. Can be a single string (end is NULL),
43  * or separate start and end strings. If two strings are given, the locale
44  * name must contain both of them, and everything between them is
45  * replaced. This is used for a poor-man's regexp search, allowing
46  * replacement of "start.*end".
47  */
48  const char *locale_name_start;
49  const char *locale_name_end;
50 
51  const char *replacement; /* string to replace the match with */
52 };
53 
54 /*
55  * Mappings applied before calling setlocale(), to the argument.
56  */
57 static const struct locale_map locale_map_argument[] = {
58  /*
59  * "HKG" is listed here:
60  * http://msdn.microsoft.com/en-us/library/cdax410z%28v=vs.71%29.aspx
61  * (Country/Region Strings).
62  *
63  * "ARE" is the ISO-3166 three-letter code for U.A.E. It is not on the
64  * above list, but seems to work anyway.
65  */
66  {"Hong Kong S.A.R.", NULL, "HKG"},
67  {"U.A.E.", NULL, "ARE"},
68 
69  /*
70  * The ISO-3166 country code for Macau S.A.R. is MAC, but Windows doesn't
71  * seem to recognize that. And Macau isn't listed in the table of accepted
72  * abbreviations linked above. Fortunately, "ZHM" seems to be accepted as
73  * an alias for "Chinese (Traditional)_Macau S.A.R..950". I'm not sure
74  * where "ZHM" comes from, must be some legacy naming scheme. But hey, it
75  * works.
76  *
77  * Note that unlike HKG and ARE, ZHM is an alias for the *whole* locale
78  * name, not just the country part.
79  *
80  * Some versions of Windows spell it "Macau", others "Macao".
81  */
82  {"Chinese (Traditional)_Macau S.A.R..950", NULL, "ZHM"},
83  {"Chinese_Macau S.A.R..950", NULL, "ZHM"},
84  {"Chinese (Traditional)_Macao S.A.R..950", NULL, "ZHM"},
85  {"Chinese_Macao S.A.R..950", NULL, "ZHM"},
86  {NULL, NULL, NULL}
87 };
88 
89 /*
90  * Mappings applied after calling setlocale(), to its return value.
91  */
92 static const struct locale_map locale_map_result[] = {
93  /*
94  * "Norwegian (Bokmål)" locale name contains the a-ring character.
95  * Map it to a pure-ASCII alias.
96  *
97  * It's not clear what encoding setlocale() uses when it returns the
98  * locale name, so to play it safe, we search for "Norwegian (Bok*l)".
99  *
100  * Just to make life even more complicated, some versions of Windows spell
101  * the locale name without parentheses. Translate that too.
102  */
103  {"Norwegian (Bokm", "l)_Norway", "Norwegian_Norway"},
104  {"Norwegian Bokm", "l_Norway", "Norwegian_Norway"},
105  {NULL, NULL, NULL}
106 };
107 
108 #define MAX_LOCALE_NAME_LEN 100
109 
110 static const char *
111 map_locale(const struct locale_map *map, const char *locale)
112 {
113  static char aliasbuf[MAX_LOCALE_NAME_LEN];
114  int i;
115 
116  /* Check if the locale name matches any of the problematic ones. */
117  for (i = 0; map[i].locale_name_start != NULL; i++)
118  {
119  const char *needle_start = map[i].locale_name_start;
120  const char *needle_end = map[i].locale_name_end;
121  const char *replacement = map[i].replacement;
122  char *match;
123  char *match_start = NULL;
124  char *match_end = NULL;
125 
126  match = strstr(locale, needle_start);
127  if (match)
128  {
129  /*
130  * Found a match for the first part. If this was a two-part
131  * replacement, find the second part.
132  */
133  match_start = match;
134  if (needle_end)
135  {
136  match = strstr(match_start + strlen(needle_start), needle_end);
137  if (match)
138  match_end = match + strlen(needle_end);
139  else
140  match_start = NULL;
141  }
142  else
143  match_end = match_start + strlen(needle_start);
144  }
145 
146  if (match_start)
147  {
148  /* Found a match. Replace the matched string. */
149  int matchpos = match_start - locale;
150  int replacementlen = strlen(replacement);
151  char *rest = match_end;
152  int restlen = strlen(rest);
153 
154  /* check that the result fits in the static buffer */
155  if (matchpos + replacementlen + restlen + 1 > MAX_LOCALE_NAME_LEN)
156  return NULL;
157 
158  memcpy(&aliasbuf[0], &locale[0], matchpos);
159  memcpy(&aliasbuf[matchpos], replacement, replacementlen);
160  /* includes null terminator */
161  memcpy(&aliasbuf[matchpos + replacementlen], rest, restlen + 1);
162 
163  return aliasbuf;
164  }
165  }
166 
167  /* no match, just return the original string */
168  return locale;
169 }
170 
171 char *
172 pgwin32_setlocale(int category, const char *locale)
173 {
174  const char *argument;
175  char *result;
176 
177  if (locale == NULL)
178  argument = NULL;
179  else
180  argument = map_locale(locale_map_argument, locale);
181 
182  /* Call the real setlocale() function */
183  result = setlocale(category, argument);
184 
185  /*
186  * setlocale() is specified to return a "char *" that the caller is
187  * forbidden to modify, so casting away the "const" is innocuous.
188  */
189  if (result)
190  result = unconstify(char *, map_locale(locale_map_result, result));
191 
192  return result;
193 }
const char * locale_name_end
#define setlocale(a, b)
Definition: win32_port.h:408
static const char * map_locale(const struct locale_map *map, const char *locale)
static const struct locale_map locale_map_argument[]
char * pgwin32_setlocale(int category, const char *locale)
#define unconstify(underlying_type, expr)
Definition: c.h:1188
const char * replacement
const char * locale_name_start
static const struct locale_map locale_map_result[]
#define MAX_LOCALE_NAME_LEN
int i
static char * locale
Definition: initdb.c:125