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