Code

Git 1.7.6.3
[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  */
16 #include "git-compat-util.h"
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.
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.
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.
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.  */
36 /* closeout.c - close standard output and standard error
37    Copyright (C) 1998-2007 Free Software Foundation, Inc.
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.
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.
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.  */
53 #include <errno.h>
54 #include <stdio.h>
55 #include <stdlib.h>
56 #include <string.h>
58 /* If true, substitution shall be performed on all variables.  */
59 static unsigned short int all_variables;
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);
66 int
67 main (int argc, char *argv[])
68 {
69   /* Default values for command line options.  */
70   /* unsigned short int show_variables = 0; */
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         }
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);
110   exit (EXIT_SUCCESS);
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))
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;
134         if (*string == '{')
135           string++;
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;
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;
160             if (valid)
161               callback (variable_start, variable_end - variable_start);
162           }
163       }
167 /* Print a variable to stdout, followed by a newline.  */
168 static void
169 print_variable (const char *var_ptr, size_t var_len)
171   fwrite (var_ptr, var_len, 1, stdout);
172   putchar ('\n');
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)
180   find_variables (string, &print_variable);
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
189   const char **item;
190   size_t nitems;
191   size_t nitems_max;
192 };
194 /* Initialize an empty list of strings.  */
195 static inline void
196 string_list_init (string_list_ty *slp)
198   slp->item = NULL;
199   slp->nitems = 0;
200   slp->nitems_max = 0;
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)
207   /* Grow the list.  */
208   if (slp->nitems >= slp->nitems_max)
209     {
210       size_t nbytes;
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     }
217   /* Add the string to the end of the list.  */
218   slp->item[slp->nitems++] = s;
221 /* Compare two strings given by reference.  */
222 static int
223 cmp_string (const void *pstr1, const void *pstr2)
225   const char *str1 = *(const char **)pstr1;
226   const char *str2 = *(const char **)pstr2;
228   return strcmp (str1, str2);
231 /* Sort a list of strings.  */
232 static inline void
233 string_list_sort (string_list_ty *slp)
235   if (slp->nitems > 0)
236     qsort (slp->item, slp->nitems, sizeof (slp->item[0]), cmp_string);
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)
243   size_t j;
245   for (j = 0; j < slp->nitems; ++j)
246     if (strcmp (slp->item[j], s) == 0)
247       return 1;
248   return 0;
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)
255   size_t j1, j2;
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);
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;
284 /* Set of variables on which to perform substitution.
285    Used only if !all_variables.  */
286 static string_list_ty variables_set;
288 /* Adds a variable to variables_set.  */
289 static void
290 note_variable (const char *var_ptr, size_t var_len)
292   char *string = xmalloc (var_len + 1);
293   memcpy (string, var_ptr, var_len);
294   string[var_len] = '\0';
296   string_list_append (&variables_set, string);
299 /* Stores the variables occurring in the string in variables_set.  */
300 static void
301 note_variables (const char *string)
303   string_list_init (&variables_set);
304   find_variables (string, &note_variable);
305   string_list_sort (&variables_set);
309 static int
310 do_getc (void)
312   int c = getc (stdin);
314   if (c == EOF)
315     {
316       if (ferror (stdin))
317         error ("error while reading standard input");
318     }
320   return c;
323 static inline void
324 do_ungetc (int c)
326   if (c != EOF)
327     ungetc (c, stdin);
330 /* Copies stdin to stdout, performing substitutions.  */
331 static void
332 subst_from_stdin (void)
334   static char *buffer;
335   static size_t bufmax;
336   static size_t buflen;
337   int c;
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;
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;
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;
371                   c = do_getc ();
372                 }
373               while ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')
374                      || (c >= '0' && c <= '9') || c == '_');
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                 }
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';
405                   /* Test whether the variable shall be substituted.  */
406                   if (!all_variables
407                       && !sorted_string_list_member (&variables_set, buffer))
408                     valid = 0;
409                 }
411               if (valid)
412                 {
413                   /* Substitute the variable's value from the environment.  */
414                   const char *env_value = getenv (buffer);
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     }