sh-i18n--envsubst.c - git - Git at Google

 /*
  * sh-i18n--envsubst.c - a stripped-down version of gettext's envsubst(1)
  *
  * Copyright (C) 2010 Ævar Arnfjörð Bjarmason
  *
  * This is a modified version of
  * 67d0871a8c:gettext-runtime/src/envsubst.c from the gettext.git
  * repository. It has been stripped down to only implement the
  * envsubst(1) features that we need in the git-sh-i18n fallbacks.
  *
  * The "Close standard error" part in main() is from
  * 8dac033df0:gnulib-local/lib/closeout.c. The copyright notices for
  * both files are reproduced immediately below.
  */

 #include "git-compat-util.h"

 /* Substitution of environment variables in shell format strings.
    Copyright (C) 2003-2007 Free Software Foundation, Inc.
    Written by Bruno Haible <bruno@clisp.org>, 2003.

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2, or (at your option)
    any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software Foundation,
    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */

 /* closeout.c - close standard output and standard error
    Copyright (C) 1998-2007 Free Software Foundation, Inc.

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2, or (at your option)
    any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software Foundation,
    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */

 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 /* If true, substitution shall be performed on all variables.  */
 static unsigned short int all_variables;

 /* Forward declaration of local functions.  */
 static void print_variables (const char *string);
 static void note_variables (const char *string);
 static void subst_from_stdin (void);

 int
 main (int argc, char *argv[])
 {
   /* Default values for command line options.  */
   /* unsigned short int show_variables = 0; */

   switch (argc)
 	{
 	case 1:
 	  error ("we won't substitute all variables on stdin for you");
 	  break;
 	  /*
 	  all_variables = 1;
       subst_from_stdin ();
 	  */
 	case 2:
 	  /* echo '$foo and $bar' | git sh-i18n--envsubst --variables '$foo and $bar' */
 	  all_variables = 0;
 	  note_variables (argv[1]);
       subst_from_stdin ();
 	  break;
 	case 3:
 	  /* git sh-i18n--envsubst --variables '$foo and $bar' */
 	  if (strcmp(argv[1], "--variables"))
 		error ("first argument must be --variables when two are given");
 	  /* show_variables = 1; */
       print_variables (argv[2]);
 	  break;
 	default:
 	  error ("too many arguments");
 	  break;
 	}

   /* Close standard error.  This is simpler than fwriteerror_no_ebadf, because
      upon failure we don't need an errno - all we can do at this point is to
      set an exit status.  */
   errno = 0;
   if (ferror (stderr) || fflush (stderr))
     {
       fclose (stderr);
       exit (EXIT_FAILURE);
     }
   if (fclose (stderr) && errno != EBADF)
     exit (EXIT_FAILURE);

   exit (EXIT_SUCCESS);
 }

 /* Parse the string and invoke the callback each time a $VARIABLE or
    ${VARIABLE} construct is seen, where VARIABLE is a nonempty sequence
    of ASCII alphanumeric/underscore characters, starting with an ASCII
    alphabetic/underscore character.
    We allow only ASCII characters, to avoid dependencies w.r.t. the current
    encoding: While "${\xe0}" looks like a variable access in ISO-8859-1
    encoding, it doesn't look like one in the BIG5, BIG5-HKSCS, GBK, GB18030,
    SHIFT_JIS, JOHAB encodings, because \xe0\x7d is a single character in these
    encodings.  */
 static void
 find_variables (const char *string,
 		void (*callback) (const char *var_ptr, size_t var_len))
 {
   for (; *string != '\0';)
     if (*string++ == '$')
       {
 	const char *variable_start;
 	const char *variable_end;
 	unsigned short int valid;
 	char c;

 	if (*string == '{')
 	  string++;

 	variable_start = string;
 	c = *string;
 	if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_')
 	  {
 	    do
 	      c = *++string;
 	    while ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')
 		   || (c >= '0' && c <= '9') || c == '_');
 	    variable_end = string;

 	    if (variable_start[-1] == '{')
 	      {
 		if (*string == '}')
 		  {
 		    string++;
 		    valid = 1;
 		  }
 		else
 		  valid = 0;
 	      }
 	    else
 	      valid = 1;

 	    if (valid)
 	      callback (variable_start, variable_end - variable_start);
 	  }
       }
 }


 /* Print a variable to stdout, followed by a newline.  */
 static void
 print_variable (const char *var_ptr, size_t var_len)
 {
   fwrite (var_ptr, var_len, 1, stdout);
   putchar ('\n');
 }

 /* Print the variables contained in STRING to stdout, each one followed by a
    newline.  */
 static void
 print_variables (const char *string)
 {
   find_variables (string, &print_variable);
 }


 /* Type describing list of immutable strings,
    implemented using a dynamic array.  */
 typedef struct string_list_ty string_list_ty;
 struct string_list_ty
 {
   const char **item;
   size_t nitems;
   size_t nitems_max;
 };

 /* Initialize an empty list of strings.  */
 static inline void
 string_list_init (string_list_ty *slp)
 {
   slp->item = NULL;
   slp->nitems = 0;
   slp->nitems_max = 0;
 }

 /* Append a single string to the end of a list of strings.  */
 static inline void
 string_list_append (string_list_ty *slp, const char *s)
 {
   /* Grow the list.  */
   if (slp->nitems >= slp->nitems_max)
     {
       size_t nbytes;

       slp->nitems_max = slp->nitems_max * 2 + 4;
       nbytes = slp->nitems_max * sizeof (slp->item[0]);
       slp->item = (const char **) xrealloc (slp->item, nbytes);
     }

   /* Add the string to the end of the list.  */
   slp->item[slp->nitems++] = s;
 }

 /* Compare two strings given by reference.  */
 static int
 cmp_string (const void *pstr1, const void *pstr2)
 {
   const char *str1 = *(const char **)pstr1;
   const char *str2 = *(const char **)pstr2;

   return strcmp (str1, str2);
 }

 /* Sort a list of strings.  */
 static inline void
 string_list_sort (string_list_ty *slp)
 {
   if (slp->nitems > 0)
     qsort (slp->item, slp->nitems, sizeof (slp->item[0]), cmp_string);
 }

 /* Test whether a string list contains a given string.  */
 static inline int
 string_list_member (const string_list_ty *slp, const char *s)
 {
   size_t j;

   for (j = 0; j < slp->nitems; ++j)
     if (strcmp (slp->item[j], s) == 0)
       return 1;
   return 0;
 }

 /* Test whether a sorted string list contains a given string.  */
 static int
 sorted_string_list_member (const string_list_ty *slp, const char *s)
 {
   size_t j1, j2;

   j1 = 0;
   j2 = slp->nitems;
   if (j2 > 0)
     {
       /* Binary search.  */
       while (j2 - j1 > 1)
 	{
 	  /* Here we know that if s is in the list, it is at an index j
 	     with j1 <= j < j2.  */
 	  size_t j = (j1 + j2) >> 1;
 	  int result = strcmp (slp->item[j], s);

 	  if (result > 0)
 	    j2 = j;
 	  else if (result == 0)
 	    return 1;
 	  else
 	    j1 = j + 1;
 	}
       if (j2 > j1)
 	if (strcmp (slp->item[j1], s) == 0)
 	  return 1;
     }
   return 0;
 }


 /* Set of variables on which to perform substitution.
    Used only if !all_variables.  */
 static string_list_ty variables_set;

 /* Adds a variable to variables_set.  */
 static void
 note_variable (const char *var_ptr, size_t var_len)
 {
   char *string = xmalloc (var_len + 1);
   memcpy (string, var_ptr, var_len);
   string[var_len] = '\0';

   string_list_append (&variables_set, string);
 }

 /* Stores the variables occurring in the string in variables_set.  */
 static void
 note_variables (const char *string)
 {
   string_list_init (&variables_set);
   find_variables (string, &note_variable);
   string_list_sort (&variables_set);
 }


 static int
 do_getc (void)
 {
   int c = getc (stdin);

   if (c == EOF)
     {
       if (ferror (stdin))
 	error ("error while reading standard input");
     }

   return c;
 }

 static inline void
 do_ungetc (int c)
 {
   if (c != EOF)
     ungetc (c, stdin);
 }

 /* Copies stdin to stdout, performing substitutions.  */
 static void
 subst_from_stdin (void)
 {
   static char *buffer;
   static size_t bufmax;
   static size_t buflen;
   int c;

   for (;;)
     {
       c = do_getc ();
       if (c == EOF)
 	break;
       /* Look for $VARIABLE or ${VARIABLE}.  */
       if (c == '$')
 	{
 	  unsigned short int opening_brace = 0;
 	  unsigned short int closing_brace = 0;

 	  c = do_getc ();
 	  if (c == '{')
 	    {
 	      opening_brace = 1;
 	      c = do_getc ();
 	    }
 	  if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_')
 	    {
 	      unsigned short int valid;

 	      /* Accumulate the VARIABLE in buffer.  */
 	      buflen = 0;
 	      do
 		{
 		  if (buflen >= bufmax)
 		    {
 		      bufmax = 2 * bufmax + 10;
 		      buffer = xrealloc (buffer, bufmax);
 		    }
 		  buffer[buflen++] = c;

 		  c = do_getc ();
 		}
 	      while ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')
 		     || (c >= '0' && c <= '9') || c == '_');

 	      if (opening_brace)
 		{
 		  if (c == '}')
 		    {
 		      closing_brace = 1;
 		      valid = 1;
 		    }
 		  else
 		    {
 		      valid = 0;
 		      do_ungetc (c);
 		    }
 		}
 	      else
 		{
 		  valid = 1;
 		  do_ungetc (c);
 		}

 	      if (valid)
 		{
 		  /* Terminate the variable in the buffer.  */
 		  if (buflen >= bufmax)
 		    {
 		      bufmax = 2 * bufmax + 10;
 		      buffer = xrealloc (buffer, bufmax);
 		    }
 		  buffer[buflen] = '\0';

 		  /* Test whether the variable shall be substituted.  */
 		  if (!all_variables
 		      && !sorted_string_list_member (&variables_set, buffer))
 		    valid = 0;
 		}

 	      if (valid)
 		{
 		  /* Substitute the variable's value from the environment.  */
 		  const char *env_value = getenv (buffer);

 		  if (env_value != NULL)
 		    fputs (env_value, stdout);
 		}
 	      else
 		{
 		  /* Perform no substitution at all.  Since the buffered input
 		     contains no other '$' than at the start, we can just
 		     output all the buffered contents.  */
 		  putchar ('$');
 		  if (opening_brace)
 		    putchar ('{');
 		  fwrite (buffer, buflen, 1, stdout);
 		  if (closing_brace)
 		    putchar ('}');
 		}
 	    }
 	  else
 	    {
 	      do_ungetc (c);
 	      putchar ('$');
 	      if (opening_brace)
 		putchar ('{');
 	    }
 	}
       else
 	putchar (c);
     }
 }
	/*
	* sh-i18n--envsubst.c - a stripped-down version of gettext's envsubst(1)
	*
	* Copyright (C) 2010 Ævar Arnfjörð Bjarmason
	*
	* This is a modified version of
	* 67d0871a8c:gettext-runtime/src/envsubst.c from the gettext.git
	* repository. It has been stripped down to only implement the
	* envsubst(1) features that we need in the git-sh-i18n fallbacks.
	*
	* The "Close standard error" part in main() is from
	* 8dac033df0:gnulib-local/lib/closeout.c. The copyright notices for
	* both files are reproduced immediately below.
	*/

	#include "git-compat-util.h"

	/* Substitution of environment variables in shell format strings.
	Copyright (C) 2003-2007 Free Software Foundation, Inc.
	Written by Bruno Haible <bruno@clisp.org>, 2003.

	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2, or (at your option)
	any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the Free Software Foundation,
	Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */

	/* closeout.c - close standard output and standard error
	Copyright (C) 1998-2007 Free Software Foundation, Inc.

	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2, or (at your option)
	any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the Free Software Foundation,
	Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */

	#include <errno.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	/* If true, substitution shall be performed on all variables. */
	static unsigned short int all_variables;

	/* Forward declaration of local functions. */
	static void print_variables (const char *string);
	static void note_variables (const char *string);
	static void subst_from_stdin (void);

	int
	main (int argc, char *argv[])
	{
	/* Default values for command line options. */
	/* unsigned short int show_variables = 0; */

	switch (argc)
	{
	case 1:
	error ("we won't substitute all variables on stdin for you");
	break;
	/*
	all_variables = 1;
	subst_from_stdin ();
	*/
	case 2:
	/* echo '$foo and $bar' \| git sh-i18n--envsubst --variables '$foo and $bar' */
	all_variables = 0;
	note_variables (argv[1]);
	subst_from_stdin ();
	break;
	case 3:
	/* git sh-i18n--envsubst --variables '$foo and $bar' */
	if (strcmp(argv[1], "--variables"))
	error ("first argument must be --variables when two are given");
	/* show_variables = 1; */
	print_variables (argv[2]);
	break;
	default:
	error ("too many arguments");
	break;
	}

	/* Close standard error. This is simpler than fwriteerror_no_ebadf, because
	upon failure we don't need an errno - all we can do at this point is to
	set an exit status. */
	errno = 0;
	if (ferror (stderr) \|\| fflush (stderr))
	{
	fclose (stderr);
	exit (EXIT_FAILURE);
	}
	if (fclose (stderr) && errno != EBADF)
	exit (EXIT_FAILURE);

	exit (EXIT_SUCCESS);
	}

	/* Parse the string and invoke the callback each time a $VARIABLE or
	${VARIABLE} construct is seen, where VARIABLE is a nonempty sequence
	of ASCII alphanumeric/underscore characters, starting with an ASCII
	alphabetic/underscore character.
	We allow only ASCII characters, to avoid dependencies w.r.t. the current
	encoding: While "${\xe0}" looks like a variable access in ISO-8859-1
	encoding, it doesn't look like one in the BIG5, BIG5-HKSCS, GBK, GB18030,
	SHIFT_JIS, JOHAB encodings, because \xe0\x7d is a single character in these
	encodings. */
	static void
	find_variables (const char *string,
	void (callback) (const char var_ptr, size_t var_len))
	{
	for (; *string != '\0';)
	if (*string++ == '$')
	{
	const char *variable_start;
	const char *variable_end;
	unsigned short int valid;
	char c;

	if (*string == '{')
	string++;

	variable_start = string;
	c = *string;
	if ((c >= 'A' && c <= 'Z') \|\| (c >= 'a' && c <= 'z') \|\| c == '_')
	{
	do
	c = *++string;
	while ((c >= 'A' && c <= 'Z') \|\| (c >= 'a' && c <= 'z')
	\|\| (c >= '0' && c <= '9') \|\| c == '_');
	variable_end = string;

	if (variable_start[-1] == '{')
	{
	if (*string == '}')
	{
	string++;
	valid = 1;
	}
	else
	valid = 0;
	}
	else
	valid = 1;

	if (valid)
	callback (variable_start, variable_end - variable_start);
	}
	}
	}


	/* Print a variable to stdout, followed by a newline. */
	static void
	print_variable (const char *var_ptr, size_t var_len)
	{
	fwrite (var_ptr, var_len, 1, stdout);
	putchar ('\n');
	}

	/* Print the variables contained in STRING to stdout, each one followed by a
	newline. */
	static void
	print_variables (const char *string)
	{
	find_variables (string, &print_variable);
	}


	/* Type describing list of immutable strings,
	implemented using a dynamic array. */
	typedef struct string_list_ty string_list_ty;
	struct string_list_ty
	{
	const char **item;
	size_t nitems;
	size_t nitems_max;
	};

	/* Initialize an empty list of strings. */
	static inline void
	string_list_init (string_list_ty *slp)
	{
	slp->item = NULL;
	slp->nitems = 0;
	slp->nitems_max = 0;
	}

	/* Append a single string to the end of a list of strings. */
	static inline void
	string_list_append (string_list_ty slp, const char s)
	{
	/* Grow the list. */
	if (slp->nitems >= slp->nitems_max)
	{
	size_t nbytes;

	slp->nitems_max = slp->nitems_max * 2 + 4;
	nbytes = slp->nitems_max * sizeof (slp->item[0]);
	slp->item = (const char **) xrealloc (slp->item, nbytes);
	}

	/* Add the string to the end of the list. */
	slp->item[slp->nitems++] = s;
	}

	/* Compare two strings given by reference. */
	static int
	cmp_string (const void pstr1, const void pstr2)
	{
	const char str1 = (const char **)pstr1;
	const char str2 = (const char **)pstr2;

	return strcmp (str1, str2);
	}

	/* Sort a list of strings. */
	static inline void
	string_list_sort (string_list_ty *slp)
	{
	if (slp->nitems > 0)
	qsort (slp->item, slp->nitems, sizeof (slp->item[0]), cmp_string);
	}

	/* Test whether a string list contains a given string. */
	static inline int
	string_list_member (const string_list_ty slp, const char s)
	{
	size_t j;

	for (j = 0; j < slp->nitems; ++j)
	if (strcmp (slp->item[j], s) == 0)
	return 1;
	return 0;
	}

	/* Test whether a sorted string list contains a given string. */
	static int
	sorted_string_list_member (const string_list_ty slp, const char s)
	{
	size_t j1, j2;

	j1 = 0;
	j2 = slp->nitems;
	if (j2 > 0)
	{
	/* Binary search. */
	while (j2 - j1 > 1)
	{
	/* Here we know that if s is in the list, it is at an index j
	with j1 <= j < j2. */
	size_t j = (j1 + j2) >> 1;
	int result = strcmp (slp->item[j], s);

	if (result > 0)
	j2 = j;
	else if (result == 0)
	return 1;
	else
	j1 = j + 1;
	}
	if (j2 > j1)
	if (strcmp (slp->item[j1], s) == 0)
	return 1;
	}
	return 0;
	}


	/* Set of variables on which to perform substitution.
	Used only if !all_variables. */
	static string_list_ty variables_set;

	/* Adds a variable to variables_set. */
	static void
	note_variable (const char *var_ptr, size_t var_len)
	{
	char *string = xmalloc (var_len + 1);
	memcpy (string, var_ptr, var_len);
	string[var_len] = '\0';

	string_list_append (&variables_set, string);
	}

	/* Stores the variables occurring in the string in variables_set. */
	static void
	note_variables (const char *string)
	{
	string_list_init (&variables_set);
	find_variables (string, &note_variable);
	string_list_sort (&variables_set);
	}


	static int
	do_getc (void)
	{
	int c = getc (stdin);

	if (c == EOF)
	{
	if (ferror (stdin))
	error ("error while reading standard input");
	}

	return c;
	}

	static inline void
	do_ungetc (int c)
	{
	if (c != EOF)
	ungetc (c, stdin);
	}

	/* Copies stdin to stdout, performing substitutions. */
	static void
	subst_from_stdin (void)
	{
	static char *buffer;
	static size_t bufmax;
	static size_t buflen;
	int c;

	for (;;)
	{
	c = do_getc ();
	if (c == EOF)
	break;
	/* Look for $VARIABLE or ${VARIABLE}. */
	if (c == '$')
	{
	unsigned short int opening_brace = 0;
	unsigned short int closing_brace = 0;

	c = do_getc ();
	if (c == '{')
	{
	opening_brace = 1;
	c = do_getc ();
	}
	if ((c >= 'A' && c <= 'Z') \|\| (c >= 'a' && c <= 'z') \|\| c == '_')
	{
	unsigned short int valid;

	/* Accumulate the VARIABLE in buffer. */
	buflen = 0;
	do
	{
	if (buflen >= bufmax)
	{
	bufmax = 2 * bufmax + 10;
	buffer = xrealloc (buffer, bufmax);
	}
	buffer[buflen++] = c;

	c = do_getc ();
	}
	while ((c >= 'A' && c <= 'Z') \|\| (c >= 'a' && c <= 'z')
	\|\| (c >= '0' && c <= '9') \|\| c == '_');

	if (opening_brace)
	{
	if (c == '}')
	{
	closing_brace = 1;
	valid = 1;
	}
	else
	{
	valid = 0;
	do_ungetc (c);
	}
	}
	else
	{
	valid = 1;
	do_ungetc (c);
	}

	if (valid)
	{
	/* Terminate the variable in the buffer. */
	if (buflen >= bufmax)
	{
	bufmax = 2 * bufmax + 10;
	buffer = xrealloc (buffer, bufmax);
	}
	buffer[buflen] = '\0';

	/* Test whether the variable shall be substituted. */
	if (!all_variables
	&& !sorted_string_list_member (&variables_set, buffer))
	valid = 0;
	}

	if (valid)
	{
	/* Substitute the variable's value from the environment. */
	const char *env_value = getenv (buffer);

	if (env_value != NULL)
	fputs (env_value, stdout);
	}
	else
	{
	/* Perform no substitution at all. Since the buffered input
	contains no other '$' than at the start, we can just
	output all the buffered contents. */
	putchar ('$');
	if (opening_brace)
	putchar ('{');
	fwrite (buffer, buflen, 1, stdout);
	if (closing_brace)
	putchar ('}');
	}
	}
	else
	{
	do_ungetc (c);
	putchar ('$');
	if (opening_brace)
	putchar ('{');
	}
	}
	else
	putchar (c);
	}
	}