[thirdparty/git.git] / sh-i18n--envsubst.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"
#include "trace2.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, see <http://www.gnu.org/licenses/>.  */

/* 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, see <http://www.gnu.org/licenses/>.  */

#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
cmd_main (int argc, const char *argv[])
{
  /* Default values for command line options.  */
  /* unsigned short int show_variables = 0; */

  trace2_cmd_name("sh-i18n--envsubst");

  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)
    {
      slp->nitems_max = slp->nitems_max * 2 + 4;
      REALLOC_ARRAY(slp->item, slp->nitems_max);
    }

  /* 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)
{
  QSORT(slp->item, slp->nitems, cmp_string);
}

/* 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 - j1) >> 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 = xmemdupz (var_ptr, var_len);

  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);
    }
}
Commit	Line	Data
ba67aaf2 ÆAB	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"
ee4512ed	17	#include "trace2.h"
ba67aaf2 ÆAB	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
48425792	34	along with this program; if not, see <http://www.gnu.org/licenses/>. */
ba67aaf2 ÆAB	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
48425792	50	along with this program; if not, see <http://www.gnu.org/licenses/>. */
ba67aaf2 ÆAB	51
ba67aaf2 ÆAB	52	#include <errno.h>
ba67aaf2 ÆAB	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
3f2e2297	66	cmd_main (int argc, const char *argv[])
ba67aaf2 ÆAB	67	{
ba67aaf2 ÆAB	68	/* Default values for command line options. */
600a6a68	69	/* unsigned short int show_variables = 0; */
ba67aaf2	70
ee4512ed JH	71	trace2_cmd_name("sh-i18n--envsubst");
ee4512ed JH	72
ba67aaf2 ÆAB	73	switch (argc)
	74	{
	75	case 1:
	76	error ("we won't substitute all variables on stdin for you");
8c92516f	77	break;
ba67aaf2 ÆAB	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");
600a6a68	92	/* show_variables = 1; */
ba67aaf2 ÆAB	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	{
ba67aaf2	212	slp->nitems_max = slp->nitems_max * 2 + 4;
2756ca43	213	REALLOC_ARRAY(slp->item, slp->nitems_max);
ba67aaf2 ÆAB	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	{
76dd98c1	234	QSORT(slp->item, slp->nitems, cmp_string);
ba67aaf2 ÆAB	235	}
ba67aaf2 ÆAB	236
ba67aaf2 ÆAB	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. */
568a05c5	252	size_t j = j1 + ((j2 - j1) >> 1);
ba67aaf2 ÆAB	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	{
5c0b13f8	278	char *string = xmemdupz (var_ptr, var_len);
ba67aaf2 ÆAB	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	}