sh-i18n--envsubst.c: do not #include getopt.h
[git/git.git] / sh-i18n--envsubst.c
1 /*
2 * sh-i18n--envsubst.c - a stripped-down version of gettext's envsubst(1)
3 *
4 * Copyright (C) 2010 Ævar Arnfjörð Bjarmason
5 *
6 * This is a modified version of
7 * 67d0871a8c:gettext-runtime/src/envsubst.c from the gettext.git
8 * repository. It has been stripped down to only implement the
9 * envsubst(1) features that we need in the git-sh-i18n fallbacks.
10 *
11 * The "Close standard error" part in main() is from
12 * 8dac033df0:gnulib-local/lib/closeout.c. The copyright notices for
13 * both files are reproduced immediately below.
14 */
15
16 #include "git-compat-util.h"
17
18 /* Substitution of environment variables in shell format strings.
19 Copyright (C) 2003-2007 Free Software Foundation, Inc.
20 Written by Bruno Haible <bruno@clisp.org>, 2003.
21
22 This program is free software; you can redistribute it and/or modify
23 it under the terms of the GNU General Public License as published by
24 the Free Software Foundation; either version 2, or (at your option)
25 any later version.
26
27 This program is distributed in the hope that it will be useful,
28 but WITHOUT ANY WARRANTY; without even the implied warranty of
29 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 GNU General Public License for more details.
31
32 You should have received a copy of the GNU General Public License
33 along with this program; if not, write to the Free Software Foundation,
34 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
35
36 /* closeout.c - close standard output and standard error
37 Copyright (C) 1998-2007 Free Software Foundation, Inc.
38
39 This program is free software; you can redistribute it and/or modify
40 it under the terms of the GNU General Public License as published by
41 the Free Software Foundation; either version 2, or (at your option)
42 any later version.
43
44 This program is distributed in the hope that it will be useful,
45 but WITHOUT ANY WARRANTY; without even the implied warranty of
46 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
47 GNU General Public License for more details.
48
49 You should have received a copy of the GNU General Public License
50 along with this program; if not, write to the Free Software Foundation,
51 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
52
53 #include <errno.h>
54 #include <stdio.h>
55 #include <stdlib.h>
56 #include <string.h>
57
58 /* If true, substitution shall be performed on all variables. */
59 static unsigned short int all_variables;
60
61 /* Forward declaration of local functions. */
62 static void print_variables (const char *string);
63 static void note_variables (const char *string);
64 static void subst_from_stdin (void);
65
66 int
67 main (int argc, char *argv[])
68 {
69 /* Default values for command line options. */
70 unsigned short int show_variables = 0;
71
72 switch (argc)
73 {
74 case 1:
75 error ("we won't substitute all variables on stdin for you");
76 /*
77 all_variables = 1;
78 subst_from_stdin ();
79 */
80 case 2:
81 /* echo '$foo and $bar' | git sh-i18n--envsubst --variables '$foo and $bar' */
82 all_variables = 0;
83 note_variables (argv[1]);
84 subst_from_stdin ();
85 break;
86 case 3:
87 /* git sh-i18n--envsubst --variables '$foo and $bar' */
88 if (strcmp(argv[1], "--variables"))
89 error ("first argument must be --variables when two are given");
90 show_variables = 1;
91 print_variables (argv[2]);
92 break;
93 default:
94 error ("too many arguments");
95 break;
96 }
97
98 /* Close standard error. This is simpler than fwriteerror_no_ebadf, because
99 upon failure we don't need an errno - all we can do at this point is to
100 set an exit status. */
101 errno = 0;
102 if (ferror (stderr) || fflush (stderr))
103 {
104 fclose (stderr);
105 exit (EXIT_FAILURE);
106 }
107 if (fclose (stderr) && errno != EBADF)
108 exit (EXIT_FAILURE);
109
110 exit (EXIT_SUCCESS);
111 }
112
113 /* Parse the string and invoke the callback each time a $VARIABLE or
114 ${VARIABLE} construct is seen, where VARIABLE is a nonempty sequence
115 of ASCII alphanumeric/underscore characters, starting with an ASCII
116 alphabetic/underscore character.
117 We allow only ASCII characters, to avoid dependencies w.r.t. the current
118 encoding: While "${\xe0}" looks like a variable access in ISO-8859-1
119 encoding, it doesn't look like one in the BIG5, BIG5-HKSCS, GBK, GB18030,
120 SHIFT_JIS, JOHAB encodings, because \xe0\x7d is a single character in these
121 encodings. */
122 static void
123 find_variables (const char *string,
124 void (*callback) (const char *var_ptr, size_t var_len))
125 {
126 for (; *string != '\0';)
127 if (*string++ == '$')
128 {
129 const char *variable_start;
130 const char *variable_end;
131 unsigned short int valid;
132 char c;
133
134 if (*string == '{')
135 string++;
136
137 variable_start = string;
138 c = *string;
139 if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_')
140 {
141 do
142 c = *++string;
143 while ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')
144 || (c >= '0' && c <= '9') || c == '_');
145 variable_end = string;
146
147 if (variable_start[-1] == '{')
148 {
149 if (*string == '}')
150 {
151 string++;
152 valid = 1;
153 }
154 else
155 valid = 0;
156 }
157 else
158 valid = 1;
159
160 if (valid)
161 callback (variable_start, variable_end - variable_start);
162 }
163 }
164 }
165
166
167 /* Print a variable to stdout, followed by a newline. */
168 static void
169 print_variable (const char *var_ptr, size_t var_len)
170 {
171 fwrite (var_ptr, var_len, 1, stdout);
172 putchar ('\n');
173 }
174
175 /* Print the variables contained in STRING to stdout, each one followed by a
176 newline. */
177 static void
178 print_variables (const char *string)
179 {
180 find_variables (string, &print_variable);
181 }
182
183
184 /* Type describing list of immutable strings,
185 implemented using a dynamic array. */
186 typedef struct string_list_ty string_list_ty;
187 struct string_list_ty
188 {
189 const char **item;
190 size_t nitems;
191 size_t nitems_max;
192 };
193
194 /* Initialize an empty list of strings. */
195 static inline void
196 string_list_init (string_list_ty *slp)
197 {
198 slp->item = NULL;
199 slp->nitems = 0;
200 slp->nitems_max = 0;
201 }
202
203 /* Append a single string to the end of a list of strings. */
204 static inline void
205 string_list_append (string_list_ty *slp, const char *s)
206 {
207 /* Grow the list. */
208 if (slp->nitems >= slp->nitems_max)
209 {
210 size_t nbytes;
211
212 slp->nitems_max = slp->nitems_max * 2 + 4;
213 nbytes = slp->nitems_max * sizeof (slp->item[0]);
214 slp->item = (const char **) xrealloc (slp->item, nbytes);
215 }
216
217 /* Add the string to the end of the list. */
218 slp->item[slp->nitems++] = s;
219 }
220
221 /* Compare two strings given by reference. */
222 static int
223 cmp_string (const void *pstr1, const void *pstr2)
224 {
225 const char *str1 = *(const char **)pstr1;
226 const char *str2 = *(const char **)pstr2;
227
228 return strcmp (str1, str2);
229 }
230
231 /* Sort a list of strings. */
232 static inline void
233 string_list_sort (string_list_ty *slp)
234 {
235 if (slp->nitems > 0)
236 qsort (slp->item, slp->nitems, sizeof (slp->item[0]), cmp_string);
237 }
238
239 /* Test whether a string list contains a given string. */
240 static inline int
241 string_list_member (const string_list_ty *slp, const char *s)
242 {
243 size_t j;
244
245 for (j = 0; j < slp->nitems; ++j)
246 if (strcmp (slp->item[j], s) == 0)
247 return 1;
248 return 0;
249 }
250
251 /* Test whether a sorted string list contains a given string. */
252 static int
253 sorted_string_list_member (const string_list_ty *slp, const char *s)
254 {
255 size_t j1, j2;
256
257 j1 = 0;
258 j2 = slp->nitems;
259 if (j2 > 0)
260 {
261 /* Binary search. */
262 while (j2 - j1 > 1)
263 {
264 /* Here we know that if s is in the list, it is at an index j
265 with j1 <= j < j2. */
266 size_t j = (j1 + j2) >> 1;
267 int result = strcmp (slp->item[j], s);
268
269 if (result > 0)
270 j2 = j;
271 else if (result == 0)
272 return 1;
273 else
274 j1 = j + 1;
275 }
276 if (j2 > j1)
277 if (strcmp (slp->item[j1], s) == 0)
278 return 1;
279 }
280 return 0;
281 }
282
283
284 /* Set of variables on which to perform substitution.
285 Used only if !all_variables. */
286 static string_list_ty variables_set;
287
288 /* Adds a variable to variables_set. */
289 static void
290 note_variable (const char *var_ptr, size_t var_len)
291 {
292 char *string = xmalloc (var_len + 1);
293 memcpy (string, var_ptr, var_len);
294 string[var_len] = '\0';
295
296 string_list_append (&variables_set, string);
297 }
298
299 /* Stores the variables occurring in the string in variables_set. */
300 static void
301 note_variables (const char *string)
302 {
303 string_list_init (&variables_set);
304 find_variables (string, &note_variable);
305 string_list_sort (&variables_set);
306 }
307
308
309 static int
310 do_getc (void)
311 {
312 int c = getc (stdin);
313
314 if (c == EOF)
315 {
316 if (ferror (stdin))
317 error ("error while reading standard input");
318 }
319
320 return c;
321 }
322
323 static inline void
324 do_ungetc (int c)
325 {
326 if (c != EOF)
327 ungetc (c, stdin);
328 }
329
330 /* Copies stdin to stdout, performing substitutions. */
331 static void
332 subst_from_stdin (void)
333 {
334 static char *buffer;
335 static size_t bufmax;
336 static size_t buflen;
337 int c;
338
339 for (;;)
340 {
341 c = do_getc ();
342 if (c == EOF)
343 break;
344 /* Look for $VARIABLE or ${VARIABLE}. */
345 if (c == '$')
346 {
347 unsigned short int opening_brace = 0;
348 unsigned short int closing_brace = 0;
349
350 c = do_getc ();
351 if (c == '{')
352 {
353 opening_brace = 1;
354 c = do_getc ();
355 }
356 if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_')
357 {
358 unsigned short int valid;
359
360 /* Accumulate the VARIABLE in buffer. */
361 buflen = 0;
362 do
363 {
364 if (buflen >= bufmax)
365 {
366 bufmax = 2 * bufmax + 10;
367 buffer = xrealloc (buffer, bufmax);
368 }
369 buffer[buflen++] = c;
370
371 c = do_getc ();
372 }
373 while ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')
374 || (c >= '0' && c <= '9') || c == '_');
375
376 if (opening_brace)
377 {
378 if (c == '}')
379 {
380 closing_brace = 1;
381 valid = 1;
382 }
383 else
384 {
385 valid = 0;
386 do_ungetc (c);
387 }
388 }
389 else
390 {
391 valid = 1;
392 do_ungetc (c);
393 }
394
395 if (valid)
396 {
397 /* Terminate the variable in the buffer. */
398 if (buflen >= bufmax)
399 {
400 bufmax = 2 * bufmax + 10;
401 buffer = xrealloc (buffer, bufmax);
402 }
403 buffer[buflen] = '\0';
404
405 /* Test whether the variable shall be substituted. */
406 if (!all_variables
407 && !sorted_string_list_member (&variables_set, buffer))
408 valid = 0;
409 }
410
411 if (valid)
412 {
413 /* Substitute the variable's value from the environment. */
414 const char *env_value = getenv (buffer);
415
416 if (env_value != NULL)
417 fputs (env_value, stdout);
418 }
419 else
420 {
421 /* Perform no substitution at all. Since the buffered input
422 contains no other '$' than at the start, we can just
423 output all the buffered contents. */
424 putchar ('$');
425 if (opening_brace)
426 putchar ('{');
427 fwrite (buffer, buflen, 1, stdout);
428 if (closing_brace)
429 putchar ('}');
430 }
431 }
432 else
433 {
434 do_ungetc (c);
435 putchar ('$');
436 if (opening_brace)
437 putchar ('{');
438 }
439 }
440 else
441 putchar (c);
442 }
443 }