Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Newer
Older
100644 445 lines (386 sloc) 10.958 kb
ba67aaf @avar git-sh-i18n--envsubst: our own envsubst(1) for eval_gettext()
avar authored
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. */
600a6a6 @mjg sh-18n: quell "unused variable" warning
mjg authored
70 /* unsigned short int show_variables = 0; */
ba67aaf @avar git-sh-i18n--envsubst: our own envsubst(1) for eval_gettext()
avar authored
71
72 switch (argc)
73 {
74 case 1:
75 error ("we won't substitute all variables on stdin for you");
8c92516 sh-i18n--envsubst: do not crash when no arguments are given
Johannes Sixt authored
76 break;
ba67aaf @avar git-sh-i18n--envsubst: our own envsubst(1) for eval_gettext()
avar authored
77 /*
78 all_variables = 1;
79 subst_from_stdin ();
80 */
81 case 2:
82 /* echo '$foo and $bar' | git sh-i18n--envsubst --variables '$foo and $bar' */
83 all_variables = 0;
84 note_variables (argv[1]);
85 subst_from_stdin ();
86 break;
87 case 3:
88 /* git sh-i18n--envsubst --variables '$foo and $bar' */
89 if (strcmp(argv[1], "--variables"))
90 error ("first argument must be --variables when two are given");
600a6a6 @mjg sh-18n: quell "unused variable" warning
mjg authored
91 /* show_variables = 1; */
ba67aaf @avar git-sh-i18n--envsubst: our own envsubst(1) for eval_gettext()
avar authored
92 print_variables (argv[2]);
93 break;
94 default:
95 error ("too many arguments");
96 break;
97 }
98
99 /* Close standard error. This is simpler than fwriteerror_no_ebadf, because
100 upon failure we don't need an errno - all we can do at this point is to
101 set an exit status. */
102 errno = 0;
103 if (ferror (stderr) || fflush (stderr))
104 {
105 fclose (stderr);
106 exit (EXIT_FAILURE);
107 }
108 if (fclose (stderr) && errno != EBADF)
109 exit (EXIT_FAILURE);
110
111 exit (EXIT_SUCCESS);
112 }
113
114 /* Parse the string and invoke the callback each time a $VARIABLE or
115 ${VARIABLE} construct is seen, where VARIABLE is a nonempty sequence
116 of ASCII alphanumeric/underscore characters, starting with an ASCII
117 alphabetic/underscore character.
118 We allow only ASCII characters, to avoid dependencies w.r.t. the current
119 encoding: While "${\xe0}" looks like a variable access in ISO-8859-1
120 encoding, it doesn't look like one in the BIG5, BIG5-HKSCS, GBK, GB18030,
121 SHIFT_JIS, JOHAB encodings, because \xe0\x7d is a single character in these
122 encodings. */
123 static void
124 find_variables (const char *string,
125 void (*callback) (const char *var_ptr, size_t var_len))
126 {
127 for (; *string != '\0';)
128 if (*string++ == '$')
129 {
130 const char *variable_start;
131 const char *variable_end;
132 unsigned short int valid;
133 char c;
134
135 if (*string == '{')
136 string++;
137
138 variable_start = string;
139 c = *string;
140 if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_')
141 {
142 do
143 c = *++string;
144 while ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')
145 || (c >= '0' && c <= '9') || c == '_');
146 variable_end = string;
147
148 if (variable_start[-1] == '{')
149 {
150 if (*string == '}')
151 {
152 string++;
153 valid = 1;
154 }
155 else
156 valid = 0;
157 }
158 else
159 valid = 1;
160
161 if (valid)
162 callback (variable_start, variable_end - variable_start);
163 }
164 }
165 }
166
167
168 /* Print a variable to stdout, followed by a newline. */
169 static void
170 print_variable (const char *var_ptr, size_t var_len)
171 {
172 fwrite (var_ptr, var_len, 1, stdout);
173 putchar ('\n');
174 }
175
176 /* Print the variables contained in STRING to stdout, each one followed by a
177 newline. */
178 static void
179 print_variables (const char *string)
180 {
181 find_variables (string, &print_variable);
182 }
183
184
185 /* Type describing list of immutable strings,
186 implemented using a dynamic array. */
187 typedef struct string_list_ty string_list_ty;
188 struct string_list_ty
189 {
190 const char **item;
191 size_t nitems;
192 size_t nitems_max;
193 };
194
195 /* Initialize an empty list of strings. */
196 static inline void
197 string_list_init (string_list_ty *slp)
198 {
199 slp->item = NULL;
200 slp->nitems = 0;
201 slp->nitems_max = 0;
202 }
203
204 /* Append a single string to the end of a list of strings. */
205 static inline void
206 string_list_append (string_list_ty *slp, const char *s)
207 {
208 /* Grow the list. */
209 if (slp->nitems >= slp->nitems_max)
210 {
211 size_t nbytes;
212
213 slp->nitems_max = slp->nitems_max * 2 + 4;
214 nbytes = slp->nitems_max * sizeof (slp->item[0]);
215 slp->item = (const char **) xrealloc (slp->item, nbytes);
216 }
217
218 /* Add the string to the end of the list. */
219 slp->item[slp->nitems++] = s;
220 }
221
222 /* Compare two strings given by reference. */
223 static int
224 cmp_string (const void *pstr1, const void *pstr2)
225 {
226 const char *str1 = *(const char **)pstr1;
227 const char *str2 = *(const char **)pstr2;
228
229 return strcmp (str1, str2);
230 }
231
232 /* Sort a list of strings. */
233 static inline void
234 string_list_sort (string_list_ty *slp)
235 {
236 if (slp->nitems > 0)
237 qsort (slp->item, slp->nitems, sizeof (slp->item[0]), cmp_string);
238 }
239
240 /* Test whether a string list contains a given string. */
241 static inline int
242 string_list_member (const string_list_ty *slp, const char *s)
243 {
244 size_t j;
245
246 for (j = 0; j < slp->nitems; ++j)
247 if (strcmp (slp->item[j], s) == 0)
248 return 1;
249 return 0;
250 }
251
252 /* Test whether a sorted string list contains a given string. */
253 static int
254 sorted_string_list_member (const string_list_ty *slp, const char *s)
255 {
256 size_t j1, j2;
257
258 j1 = 0;
259 j2 = slp->nitems;
260 if (j2 > 0)
261 {
262 /* Binary search. */
263 while (j2 - j1 > 1)
264 {
265 /* Here we know that if s is in the list, it is at an index j
266 with j1 <= j < j2. */
267 size_t j = (j1 + j2) >> 1;
268 int result = strcmp (slp->item[j], s);
269
270 if (result > 0)
271 j2 = j;
272 else if (result == 0)
273 return 1;
274 else
275 j1 = j + 1;
276 }
277 if (j2 > j1)
278 if (strcmp (slp->item[j1], s) == 0)
279 return 1;
280 }
281 return 0;
282 }
283
284
285 /* Set of variables on which to perform substitution.
286 Used only if !all_variables. */
287 static string_list_ty variables_set;
288
289 /* Adds a variable to variables_set. */
290 static void
291 note_variable (const char *var_ptr, size_t var_len)
292 {
293 char *string = xmalloc (var_len + 1);
294 memcpy (string, var_ptr, var_len);
295 string[var_len] = '\0';
296
297 string_list_append (&variables_set, string);
298 }
299
300 /* Stores the variables occurring in the string in variables_set. */
301 static void
302 note_variables (const char *string)
303 {
304 string_list_init (&variables_set);
305 find_variables (string, &note_variable);
306 string_list_sort (&variables_set);
307 }
308
309
310 static int
311 do_getc (void)
312 {
313 int c = getc (stdin);
314
315 if (c == EOF)
316 {
317 if (ferror (stdin))
318 error ("error while reading standard input");
319 }
320
321 return c;
322 }
323
324 static inline void
325 do_ungetc (int c)
326 {
327 if (c != EOF)
328 ungetc (c, stdin);
329 }
330
331 /* Copies stdin to stdout, performing substitutions. */
332 static void
333 subst_from_stdin (void)
334 {
335 static char *buffer;
336 static size_t bufmax;
337 static size_t buflen;
338 int c;
339
340 for (;;)
341 {
342 c = do_getc ();
343 if (c == EOF)
344 break;
345 /* Look for $VARIABLE or ${VARIABLE}. */
346 if (c == '$')
347 {
348 unsigned short int opening_brace = 0;
349 unsigned short int closing_brace = 0;
350
351 c = do_getc ();
352 if (c == '{')
353 {
354 opening_brace = 1;
355 c = do_getc ();
356 }
357 if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_')
358 {
359 unsigned short int valid;
360
361 /* Accumulate the VARIABLE in buffer. */
362 buflen = 0;
363 do
364 {
365 if (buflen >= bufmax)
366 {
367 bufmax = 2 * bufmax + 10;
368 buffer = xrealloc (buffer, bufmax);
369 }
370 buffer[buflen++] = c;
371
372 c = do_getc ();
373 }
374 while ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')
375 || (c >= '0' && c <= '9') || c == '_');
376
377 if (opening_brace)
378 {
379 if (c == '}')
380 {
381 closing_brace = 1;
382 valid = 1;
383 }
384 else
385 {
386 valid = 0;
387 do_ungetc (c);
388 }
389 }
390 else
391 {
392 valid = 1;
393 do_ungetc (c);
394 }
395
396 if (valid)
397 {
398 /* Terminate the variable in the buffer. */
399 if (buflen >= bufmax)
400 {
401 bufmax = 2 * bufmax + 10;
402 buffer = xrealloc (buffer, bufmax);
403 }
404 buffer[buflen] = '\0';
405
406 /* Test whether the variable shall be substituted. */
407 if (!all_variables
408 && !sorted_string_list_member (&variables_set, buffer))
409 valid = 0;
410 }
411
412 if (valid)
413 {
414 /* Substitute the variable's value from the environment. */
415 const char *env_value = getenv (buffer);
416
417 if (env_value != NULL)
418 fputs (env_value, stdout);
419 }
420 else
421 {
422 /* Perform no substitution at all. Since the buffered input
423 contains no other '$' than at the start, we can just
424 output all the buffered contents. */
425 putchar ('$');
426 if (opening_brace)
427 putchar ('{');
428 fwrite (buffer, buflen, 1, stdout);
429 if (closing_brace)
430 putchar ('}');
431 }
432 }
433 else
434 {
435 do_ungetc (c);
436 putchar ('$');
437 if (opening_brace)
438 putchar ('{');
439 }
440 }
441 else
442 putchar (c);
443 }
444 }
Something went wrong with that request. Please try again.