Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
branch: jc/index-v4
Fetching contributors…

Cannot retrieve contributors at this time

445 lines (386 sloc) 10.958 kb
/*
* 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);
}
}
Jump to Line
Something went wrong with that request. Please try again.