[mirror_ubuntu-jammy-kernel.git] / scripts / kconfig / preprocess.c

// SPDX-License-Identifier: GPL-2.0
//
// Copyright (C) 2018 Masahiro Yamada <yamada.masahiro@socionext.com>

#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "list.h"

#define ARRAY_SIZE(arr)		(sizeof(arr) / sizeof((arr)[0]))

static char *expand_string_with_args(const char *in, int argc, char *argv[]);

static void __attribute__((noreturn)) pperror(const char *format, ...)
{
	va_list ap;

	fprintf(stderr, "%s:%d: ", current_file->name, yylineno);
	va_start(ap, format);
	vfprintf(stderr, format, ap);
	va_end(ap);
	fprintf(stderr, "\n");

	exit(1);
}

/*
 * Environment variables
 */
static LIST_HEAD(env_list);

struct env {
	char *name;
	char *value;
	struct list_head node;
};

static void env_add(const char *name, const char *value)
{
	struct env *e;

	e = xmalloc(sizeof(*e));
	e->name = xstrdup(name);
	e->value = xstrdup(value);

	list_add_tail(&e->node, &env_list);
}

static void env_del(struct env *e)
{
	list_del(&e->node);
	free(e->name);
	free(e->value);
	free(e);
}

/* The returned pointer must be freed when done */
static char *env_expand(const char *name)
{
	struct env *e;
	const char *value;

	if (!*name)
		return NULL;

	list_for_each_entry(e, &env_list, node) {
		if (!strcmp(name, e->name))
			return xstrdup(e->value);
	}

	value = getenv(name);
	if (!value)
		return NULL;

	/*
	 * We need to remember all referenced environment variables.
	 * They will be written out to include/config/auto.conf.cmd
	 */
	env_add(name, value);

	return xstrdup(value);
}

void env_write_dep(FILE *f, const char *autoconfig_name)
{
	struct env *e, *tmp;

	list_for_each_entry_safe(e, tmp, &env_list, node) {
		fprintf(f, "ifneq \"$(%s)\" \"%s\"\n", e->name, e->value);
		fprintf(f, "%s: FORCE\n", autoconfig_name);
		fprintf(f, "endif\n");
		env_del(e);
	}
}

/*
 * Built-in functions
 */
struct function {
	const char *name;
	unsigned int min_args;
	unsigned int max_args;
	char *(*func)(int argc, char *argv[]);
};

static char *do_shell(int argc, char *argv[])
{
	FILE *p;
	char buf[256];
	char *cmd;
	size_t nread;
	int i;

	cmd = argv[0];

	p = popen(cmd, "r");
	if (!p) {
		perror(cmd);
		exit(1);
	}

	nread = fread(buf, 1, sizeof(buf), p);
	if (nread == sizeof(buf))
		nread--;

	/* remove trailing new lines */
	while (buf[nread - 1] == '\n')
		nread--;

	buf[nread] = 0;

	/* replace a new line with a space */
	for (i = 0; i < nread; i++) {
		if (buf[i] == '\n')
			buf[i] = ' ';
	}

	if (pclose(p) == -1) {
		perror(cmd);
		exit(1);
	}

	return xstrdup(buf);
}

static const struct function function_table[] = {
	/* Name		MIN	MAX	Function */
	{ "shell",	1,	1,	do_shell },
};

#define FUNCTION_MAX_ARGS		16

static char *function_expand(const char *name, int argc, char *argv[])
{
	const struct function *f;
	int i;

	for (i = 0; i < ARRAY_SIZE(function_table); i++) {
		f = &function_table[i];
		if (strcmp(f->name, name))
			continue;

		if (argc < f->min_args)
			pperror("too few function arguments passed to '%s'",
				name);

		if (argc > f->max_args)
			pperror("too many function arguments passed to '%s'",
				name);

		return f->func(argc, argv);
	}

	return NULL;
}

/*
 * Variables (and user-defined functions)
 */
static LIST_HEAD(variable_list);

struct variable {
	char *name;
	char *value;
	struct list_head node;
};

static struct variable *variable_lookup(const char *name)
{
	struct variable *v;

	list_for_each_entry(v, &variable_list, node) {
		if (!strcmp(name, v->name))
			return v;
	}

	return NULL;
}

static char *variable_expand(const char *name, int argc, char *argv[])
{
	struct variable *v;

	v = variable_lookup(name);
	if (!v)
		return NULL;

	return expand_string_with_args(v->value, argc, argv);
}

void variable_add(const char *name, const char *value)
{
	struct variable *v;

	v = variable_lookup(name);
	if (v) {
		free(v->value);
	} else {
		v = xmalloc(sizeof(*v));
		v->name = xstrdup(name);
		list_add_tail(&v->node, &variable_list);
	}

	v->value = xstrdup(value);
}

static void variable_del(struct variable *v)
{
	list_del(&v->node);
	free(v->name);
	free(v->value);
	free(v);
}

void variable_all_del(void)
{
	struct variable *v, *tmp;

	list_for_each_entry_safe(v, tmp, &variable_list, node)
		variable_del(v);
}

/*
 * Evaluate a clause with arguments.  argc/argv are arguments from the upper
 * function call.
 *
 * Returned string must be freed when done
 */
static char *eval_clause(const char *str, size_t len, int argc, char *argv[])
{
	char *tmp, *name, *res, *endptr, *prev, *p;
	int new_argc = 0;
	char *new_argv[FUNCTION_MAX_ARGS];
	int nest = 0;
	int i;
	unsigned long n;

	tmp = xstrndup(str, len);

	/*
	 * If variable name is '1', '2', etc.  It is generally an argument
	 * from a user-function call (i.e. local-scope variable).  If not
	 * available, then look-up global-scope variables.
	 */
	n = strtoul(tmp, &endptr, 10);
	if (!*endptr && n > 0 && n <= argc) {
		res = xstrdup(argv[n - 1]);
		goto free_tmp;
	}

	prev = p = tmp;

	/*
	 * Split into tokens
	 * The function name and arguments are separated by a comma.
	 * For example, if the function call is like this:
	 *   $(foo,$(x),$(y))
	 *
	 * The input string for this helper should be:
	 *   foo,$(x),$(y)
	 *
	 * and split into:
	 *   new_argv[0] = 'foo'
	 *   new_argv[1] = '$(x)'
	 *   new_argv[2] = '$(y)'
	 */
	while (*p) {
		if (nest == 0 && *p == ',') {
			*p = 0;
			if (new_argc >= FUNCTION_MAX_ARGS)
				pperror("too many function arguments");
			new_argv[new_argc++] = prev;
			prev = p + 1;
		} else if (*p == '(') {
			nest++;
		} else if (*p == ')') {
			nest--;
		}

		p++;
	}
	new_argv[new_argc++] = prev;

	/*
	 * Shift arguments
	 * new_argv[0] represents a function name or a variable name.  Put it
	 * into 'name', then shift the rest of the arguments.  This simplifies
	 * 'const' handling.
	 */
	name = expand_string_with_args(new_argv[0], argc, argv);
	new_argc--;
	for (i = 0; i < new_argc; i++)
		new_argv[i] = expand_string_with_args(new_argv[i + 1],
						      argc, argv);

	/* Search for variables */
	res = variable_expand(name, new_argc, new_argv);
	if (res)
		goto free;

	/* Look for built-in functions */
	res = function_expand(name, new_argc, new_argv);
	if (res)
		goto free;

	/* Last, try environment variable */
	if (new_argc == 0) {
		res = env_expand(name);
		if (res)
			goto free;
	}

	res = xstrdup("");
free:
	for (i = 0; i < new_argc; i++)
		free(new_argv[i]);
	free(name);
free_tmp:
	free(tmp);

	return res;
}

/*
 * Expand a string that follows '$'
 *
 * For example, if the input string is
 *     ($(FOO)$($(BAR)))$(BAZ)
 * this helper evaluates
 *     $($(FOO)$($(BAR)))
 * and returns a new string containing the expansion (note that the string is
 * recursively expanded), also advancing 'str' to point to the next character
 * after the corresponding closing parenthesis, in this case, *str will be
 *     $(BAR)
 */
static char *expand_dollar_with_args(const char **str, int argc, char *argv[])
{
	const char *p = *str;
	const char *q;
	int nest = 0;

	/*
	 * In Kconfig, variable/function references always start with "$(".
	 * Neither single-letter variables as in $A nor curly braces as in ${CC}
	 * are supported.  '$' not followed by '(' loses its special meaning.
	 */
	if (*p != '(') {
		*str = p;
		return xstrdup("$");
	}

	p++;
	q = p;
	while (*q) {
		if (*q == '(') {
			nest++;
		} else if (*q == ')') {
			if (nest-- == 0)
				break;
		}
		q++;
	}

	if (!*q)
		pperror("unterminated reference to '%s': missing ')'", p);

	/* Advance 'str' to after the expanded initial portion of the string */
	*str = q + 1;

	return eval_clause(p, q - p, argc, argv);
}

char *expand_dollar(const char **str)
{
	return expand_dollar_with_args(str, 0, NULL);
}

static char *__expand_string(const char **str, bool (*is_end)(char c),
			     int argc, char *argv[])
{
	const char *in, *p;
	char *expansion, *out;
	size_t in_len, out_len;

	out = xmalloc(1);
	*out = 0;
	out_len = 1;

	p = in = *str;

	while (1) {
		if (*p == '$') {
			in_len = p - in;
			p++;
			expansion = expand_dollar_with_args(&p, argc, argv);
			out_len += in_len + strlen(expansion);
			out = xrealloc(out, out_len);
			strncat(out, in, in_len);
			strcat(out, expansion);
			free(expansion);
			in = p;
			continue;
		}

		if (is_end(*p))
			break;

		p++;
	}

	in_len = p - in;
	out_len += in_len;
	out = xrealloc(out, out_len);
	strncat(out, in, in_len);

	/* Advance 'str' to the end character */
	*str = p;

	return out;
}

static bool is_end_of_str(char c)
{
	return !c;
}

/*
 * Expand variables and functions in the given string.  Undefined variables
 * expand to an empty string.
 * The returned string must be freed when done.
 */
static char *expand_string_with_args(const char *in, int argc, char *argv[])
{
	return __expand_string(&in, is_end_of_str, argc, argv);
}

char *expand_string(const char *in)
{
	return expand_string_with_args(in, 0, NULL);
}

static bool is_end_of_token(char c)
{
	/* Why are '.' and '/' valid characters for symbols? */
	return !(isalnum(c) || c == '_' || c == '-' || c == '.' || c == '/');
}

/*
 * Expand variables in a token.  The parsing stops when a token separater
 * (in most cases, it is a whitespace) is encountered.  'str' is updated to
 * point to the next character.
 *
 * The returned string must be freed when done.
 */
char *expand_one_token(const char **str)
{
	return __expand_string(str, is_end_of_token, 0, NULL);
}
Commit	Line	Data
104daea1 MY	1	// SPDX-License-Identifier: GPL-2.0
	2	//
	3	// Copyright (C) 2018 Masahiro Yamada <yamada.masahiro@socionext.com>
	4
	5	#include <stdarg.h>
	6	#include <stdbool.h>
	7	#include <stdio.h>
	8	#include <stdlib.h>
	9	#include <string.h>
	10
	11	#include "list.h"
	12
e298f3b4 MY	13	#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
	14
	15	static char expand_string_with_args(const char in, int argc, char *argv[]);
	16
104daea1 MY	17	static void __attribute__((noreturn)) pperror(const char *format, ...)
	18	{
	19	va_list ap;
	20
	21	fprintf(stderr, "%s:%d: ", current_file->name, yylineno);
	22	va_start(ap, format);
	23	vfprintf(stderr, format, ap);
	24	va_end(ap);
	25	fprintf(stderr, "\n");
	26
	27	exit(1);
	28	}
	29
	30	/*
	31	* Environment variables
	32	*/
	33	static LIST_HEAD(env_list);
	34
	35	struct env {
	36	char *name;
	37	char *value;
	38	struct list_head node;
	39	};
	40
	41	static void env_add(const char name, const char value)
	42	{
	43	struct env *e;
	44
	45	e = xmalloc(sizeof(*e));
	46	e->name = xstrdup(name);
	47	e->value = xstrdup(value);
	48
	49	list_add_tail(&e->node, &env_list);
	50	}
	51
	52	static void env_del(struct env *e)
	53	{
	54	list_del(&e->node);
	55	free(e->name);
	56	free(e->value);
	57	free(e);
	58	}
	59
	60	/* The returned pointer must be freed when done */
	61	static char env_expand(const char name)
	62	{
	63	struct env *e;
	64	const char *value;
	65
	66	if (!*name)
	67	return NULL;
	68
	69	list_for_each_entry(e, &env_list, node) {
	70	if (!strcmp(name, e->name))
	71	return xstrdup(e->value);
	72	}
	73
	74	value = getenv(name);
	75	if (!value)
	76	return NULL;
	77
	78	/*
	79	* We need to remember all referenced environment variables.
	80	* They will be written out to include/config/auto.conf.cmd
81	*/
82	env_add(name, value);
83
84	return xstrdup(value);
85	}
86
87	void env_write_dep(FILE f, const char autoconfig_name)
88	{
89	struct env e, tmp;
90
91	list_for_each_entry_safe(e, tmp, &env_list, node) {
92	fprintf(f, "ifneq \"$(%s)\" \"%s\"\n", e->name, e->value);
93	fprintf(f, "%s: FORCE\n", autoconfig_name);
94	fprintf(f, "endif\n");
95	env_del(e);
96	}
97	}
98
e298f3b4 MY	99	/*
	100	* Built-in functions
	101	*/
	102	struct function {
	103	const char *name;
	104	unsigned int min_args;
	105	unsigned int max_args;
	106	char (func)(int argc, char *argv[]);
	107	};
	108
2fd5b09c MY	109	static char do_shell(int argc, char argv[])
	110	{
	111	FILE *p;
	112	char buf[256];
	113	char *cmd;
	114	size_t nread;
	115	int i;
	116
	117	cmd = argv[0];
	118
	119	p = popen(cmd, "r");
	120	if (!p) {
	121	perror(cmd);
	122	exit(1);
	123	}
	124
	125	nread = fread(buf, 1, sizeof(buf), p);
	126	if (nread == sizeof(buf))
	127	nread--;
	128
	129	/* remove trailing new lines */
	130	while (buf[nread - 1] == '\n')
	131	nread--;
	132
	133	buf[nread] = 0;
	134
	135	/* replace a new line with a space */
	136	for (i = 0; i < nread; i++) {
	137	if (buf[i] == '\n')
	138	buf[i] = ' ';
	139	}
	140
	141	if (pclose(p) == -1) {
	142	perror(cmd);
	143	exit(1);
	144	}
	145
	146	return xstrdup(buf);
	147	}
	148
e298f3b4 MY	149	static const struct function function_table[] = {
e298f3b4 MY	150	/* Name MIN MAX Function */
2fd5b09c	151	{ "shell", 1, 1, do_shell },
e298f3b4 MY	152	};
	153
	154	#define FUNCTION_MAX_ARGS 16
	155
	156	static char function_expand(const char name, int argc, char *argv[])
104daea1	157	{
e298f3b4 MY	158	const struct function *f;
	159	int i;
	160
	161	for (i = 0; i < ARRAY_SIZE(function_table); i++) {
	162	f = &function_table[i];
	163	if (strcmp(f->name, name))
	164	continue;
	165
	166	if (argc < f->min_args)
	167	pperror("too few function arguments passed to '%s'",
	168	name);
	169
	170	if (argc > f->max_args)
	171	pperror("too many function arguments passed to '%s'",
	172	name);
	173
	174	return f->func(argc, argv);
	175	}
	176
	177	return NULL;
	178	}
	179
9ced3bdd MY	180	/*
	181	* Variables (and user-defined functions)
	182	*/
	183	static LIST_HEAD(variable_list);
	184
	185	struct variable {
	186	char *name;
	187	char *value;
	188	struct list_head node;
	189	};
	190
	191	static struct variable variable_lookup(const char name)
	192	{
	193	struct variable *v;
	194
	195	list_for_each_entry(v, &variable_list, node) {
	196	if (!strcmp(name, v->name))
	197	return v;
	198	}
	199
	200	return NULL;
	201	}
	202
	203	static char variable_expand(const char name, int argc, char *argv[])
	204	{
	205	struct variable *v;
	206
	207	v = variable_lookup(name);
	208	if (!v)
	209	return NULL;
	210
	211	return expand_string_with_args(v->value, argc, argv);
	212	}
	213
	214	void variable_add(const char name, const char value)
	215	{
	216	struct variable *v;
	217
	218	v = variable_lookup(name);
	219	if (v) {
	220	free(v->value);
	221	} else {
	222	v = xmalloc(sizeof(*v));
	223	v->name = xstrdup(name);
	224	list_add_tail(&v->node, &variable_list);
	225	}
	226
	227	v->value = xstrdup(value);
	228	}
	229
	230	static void variable_del(struct variable *v)
	231	{
	232	list_del(&v->node);
	233	free(v->name);
	234	free(v->value);
	235	free(v);
	236	}
	237
	238	void variable_all_del(void)
	239	{
	240	struct variable v, tmp;
	241
	242	list_for_each_entry_safe(v, tmp, &variable_list, node)
	243	variable_del(v);
244	}
245
e298f3b4 MY	246	/*
	247	* Evaluate a clause with arguments. argc/argv are arguments from the upper
	248	* function call.
	249	*
	250	* Returned string must be freed when done
	251	*/
	252	static char eval_clause(const char str, size_t len, int argc, char *argv[])
	253	{
9ced3bdd	254	char tmp, name, res, endptr, prev, p;
e298f3b4 MY	255	int new_argc = 0;
	256	char *new_argv[FUNCTION_MAX_ARGS];
	257	int nest = 0;
	258	int i;
9ced3bdd	259	unsigned long n;
104daea1 MY	260
	261	tmp = xstrndup(str, len);
	262
9ced3bdd MY	263	/*
	264	* If variable name is '1', '2', etc. It is generally an argument
	265	* from a user-function call (i.e. local-scope variable). If not
	266	* available, then look-up global-scope variables.
	267	*/
	268	n = strtoul(tmp, &endptr, 10);
	269	if (!*endptr && n > 0 && n <= argc) {
	270	res = xstrdup(argv[n - 1]);
	271	goto free_tmp;
	272	}
	273
e298f3b4 MY	274	prev = p = tmp;
	275
	276	/*
	277	* Split into tokens
	278	* The function name and arguments are separated by a comma.
	279	* For example, if the function call is like this:
	280	* $(foo,$(x),$(y))
	281	*
	282	* The input string for this helper should be:
	283	* foo,$(x),$(y)
	284	*
	285	* and split into:
	286	* new_argv[0] = 'foo'
	287	* new_argv[1] = '$(x)'
	288	* new_argv[2] = '$(y)'
	289	*/
	290	while (*p) {
	291	if (nest == 0 && *p == ',') {
	292	*p = 0;
	293	if (new_argc >= FUNCTION_MAX_ARGS)
	294	pperror("too many function arguments");
	295	new_argv[new_argc++] = prev;
	296	prev = p + 1;
	297	} else if (*p == '(') {
	298	nest++;
	299	} else if (*p == ')') {
	300	nest--;
	301	}
104daea1	302
e298f3b4 MY	303	p++;
	304	}
	305	new_argv[new_argc++] = prev;
	306
	307	/*
	308	* Shift arguments
	309	* new_argv[0] represents a function name or a variable name. Put it
	310	* into 'name', then shift the rest of the arguments. This simplifies
	311	* 'const' handling.
	312	*/
	313	name = expand_string_with_args(new_argv[0], argc, argv);
	314	new_argc--;
	315	for (i = 0; i < new_argc; i++)
	316	new_argv[i] = expand_string_with_args(new_argv[i + 1],
	317	argc, argv);
	318
9ced3bdd MY	319	/* Search for variables */
	320	res = variable_expand(name, new_argc, new_argv);
	321	if (res)
	322	goto free;
	323
e298f3b4 MY	324	/* Look for built-in functions */
e298f3b4 MY	325	res = function_expand(name, new_argc, new_argv);
104daea1 MY	326	if (res)
	327	goto free;
	328
e298f3b4 MY	329	/* Last, try environment variable */
	330	if (new_argc == 0) {
	331	res = env_expand(name);
	332	if (res)
	333	goto free;
	334	}
	335
104daea1 MY	336	res = xstrdup("");
104daea1 MY	337	free:
e298f3b4 MY	338	for (i = 0; i < new_argc; i++)
e298f3b4 MY	339	free(new_argv[i]);
104daea1	340	free(name);
9ced3bdd	341	free_tmp:
104daea1 MY	342	free(tmp);
	343
	344	return res;
	345	}
	346
	347	/*
	348	* Expand a string that follows '$'
	349	*
	350	* For example, if the input string is
	351	* ($(FOO)$($(BAR)))$(BAZ)
	352	* this helper evaluates
	353	* $($(FOO)$($(BAR)))
	354	* and returns a new string containing the expansion (note that the string is
	355	* recursively expanded), also advancing 'str' to point to the next character
	356	* after the corresponding closing parenthesis, in this case, *str will be
	357	* $(BAR)
	358	*/
e298f3b4	359	static char expand_dollar_with_args(const char str, int argc, char argv[])
104daea1 MY	360	{
	361	const char p = str;
	362	const char *q;
	363	int nest = 0;
	364
	365	/*
e298f3b4	366	* In Kconfig, variable/function references always start with "$(".
104daea1 MY	367	* Neither single-letter variables as in $A nor curly braces as in ${CC}
	368	* are supported. '$' not followed by '(' loses its special meaning.
	369	*/
	370	if (*p != '(') {
	371	*str = p;
	372	return xstrdup("$");
	373	}
	374
	375	p++;
	376	q = p;
	377	while (*q) {
	378	if (*q == '(') {
	379	nest++;
	380	} else if (*q == ')') {
	381	if (nest-- == 0)
	382	break;
	383	}
	384	q++;
	385	}
	386
	387	if (!*q)
	388	pperror("unterminated reference to '%s': missing ')'", p);
	389
	390	/* Advance 'str' to after the expanded initial portion of the string */
	391	*str = q + 1;
	392
e298f3b4 MY	393	return eval_clause(p, q - p, argc, argv);
	394	}
	395
	396	char expand_dollar(const char *str)
	397	{
	398	return expand_dollar_with_args(str, 0, NULL);
104daea1 MY	399	}
104daea1 MY	400
e298f3b4 MY	401	static char __expand_string(const char str, bool (is_end)(char c),
e298f3b4 MY	402	int argc, char *argv[])
104daea1 MY	403	{
	404	const char in, p;
	405	char expansion, out;
	406	size_t in_len, out_len;
	407
	408	out = xmalloc(1);
	409	*out = 0;
	410	out_len = 1;
	411
	412	p = in = *str;
	413
	414	while (1) {
	415	if (*p == '$') {
	416	in_len = p - in;
	417	p++;
e298f3b4	418	expansion = expand_dollar_with_args(&p, argc, argv);
104daea1 MY	419	out_len += in_len + strlen(expansion);
	420	out = xrealloc(out, out_len);
	421	strncat(out, in, in_len);
	422	strcat(out, expansion);
	423	free(expansion);
	424	in = p;
	425	continue;
	426	}
	427
	428	if (is_end(*p))
	429	break;
	430
	431	p++;
	432	}
	433
	434	in_len = p - in;
	435	out_len += in_len;
	436	out = xrealloc(out, out_len);
	437	strncat(out, in, in_len);
	438
	439	/* Advance 'str' to the end character */
	440	*str = p;
	441
	442	return out;
	443	}
	444
	445	static bool is_end_of_str(char c)
	446	{
	447	return !c;
	448	}
	449
	450	/*
e298f3b4	451	* Expand variables and functions in the given string. Undefined variables
104daea1 MY	452	* expand to an empty string.
	453	* The returned string must be freed when done.
	454	*/
e298f3b4 MY	455	static char expand_string_with_args(const char in, int argc, char *argv[])
	456	{
	457	return __expand_string(&in, is_end_of_str, argc, argv);
	458	}
	459
104daea1 MY	460	char expand_string(const char in)
104daea1 MY	461	{
e298f3b4	462	return expand_string_with_args(in, 0, NULL);
104daea1 MY	463	}
	464
	465	static bool is_end_of_token(char c)
	466	{
	467	/* Why are '.' and '/' valid characters for symbols? */
	468	return !(isalnum(c) \|\| c == '_' \|\| c == '-' \|\| c == '.' \|\| c == '/');
	469	}
	470
	471	/*
	472	* Expand variables in a token. The parsing stops when a token separater
	473	* (in most cases, it is a whitespace) is encountered. 'str' is updated to
	474	* point to the next character.
	475	*
	476	* The returned string must be freed when done.
	477	*/
	478	char expand_one_token(const char *str)
	479	{
e298f3b4	480	return __expand_string(str, is_end_of_token, 0, NULL);
104daea1	481	}