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