git.oblomov.eu Git - git/blob - 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           break;
  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");
  91           /* show_variables = 1; */
  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 }