struct function_table_entry
{
const char *name;
- int len;
- int required_args;
- int expand_args;
+ unsigned char len;
+ unsigned char minimum_args;
+ unsigned char maximum_args;
+ char expand_args;
char *(*func_ptr) PARAMS((char *output, char **argv, const char*funcname));
};
\f
const char *funcname;
{
/* expand only the first two. */
- char *varname = expand_argument (argv[0], argv[1] - 1);
- char *list = expand_argument (argv[1], argv[2] -1);
- char *body = savestring (argv[2], argv[3] - argv[2] - 1);
+ char *varname = expand_argument (argv[0], NULL);
+ char *list = expand_argument (argv[1], NULL);
+ char *body = argv[2];
int doneany = 0;
char *list_iterator = list;
pop_variable_scope ();
free (varname);
free (list);
- free (body);
return o;
}
const char *funcname;
{
char *begp = argv[0];
- char *endp = argv[1]-1;
+ char *endp = begp + strlen (argv[0]);
int result = 0;
/* Find the result of the condition: if we have a value, and it's not
if (begp < endp)
{
- char *expansion = expand_argument (begp, endp);
+ char *expansion = expand_argument (begp, NULL);
result = strlen (expansion);
free (expansion);
argv += 1 + !result;
- if (argv[0] != NULL && argv[1] != NULL)
+ if (argv[0])
{
char *expansion;
- char **argend = argv+1;
- /* If we're doing the else-clause, make sure we concatenate any
- potential extra arguments into the last argument. */
- if (!result)
- while (argend[1])
- ++argend;
-
- expansion = expand_argument (*argv, *argend-1);
+ expansion = expand_argument (argv[0], NULL);
o = variable_buffer_output (o, expansion, strlen (expansion));
+
free (expansion);
}
some efficiency by moving most often used functions to the start of the
table.
- If REQUIRED_ARGS is positive, the function takes exactly that many
- arguments. All subsequent text is included with the last argument. So,
- since $(sort a,b,c) takes only one argument, it will be the full string
- "a,b,c". If the value is negative, it's the minimum number of arguments.
- A function can have more, but if it has less an error is generated.
+ If MAXIMUM_ARGS is 0, that means there is no maximum and all
+ comma-separated values are treated as arguments.
EXPAND_ARGS means that all arguments should be expanded before invocation.
Functions that do namespace tricks (foreach) don't automatically expand. */
static struct function_table_entry function_table[] =
{
- /* Name/size */ /* ARG EXP? Function */
- { STRING_SIZE_TUPLE("addprefix"), 2, 1, func_addsuffix_addprefix},
- { STRING_SIZE_TUPLE("addsuffix"), 2, 1, func_addsuffix_addprefix},
- { STRING_SIZE_TUPLE("basename"), 1, 1, func_basename_dir},
- { STRING_SIZE_TUPLE("dir"), 1, 1, func_basename_dir},
- { STRING_SIZE_TUPLE("notdir"), 1, 1, func_notdir_suffix},
- { STRING_SIZE_TUPLE("subst"), 3, 1, func_subst},
- { STRING_SIZE_TUPLE("suffix"), 1, 1, func_notdir_suffix},
- { STRING_SIZE_TUPLE("filter"), 2, 1, func_filter_filterout},
- { STRING_SIZE_TUPLE("filter-out"), 2, 1, func_filter_filterout},
- { STRING_SIZE_TUPLE("findstring"), 2, 1, func_findstring},
- { STRING_SIZE_TUPLE("firstword"), 1, 1, func_firstword},
- { STRING_SIZE_TUPLE("join"), 2, 1, func_join},
- { STRING_SIZE_TUPLE("patsubst"), 3, 1, func_patsubst},
- { STRING_SIZE_TUPLE("shell"), 1, 1, func_shell},
- { STRING_SIZE_TUPLE("sort"), 1, 1, func_sort},
- { STRING_SIZE_TUPLE("strip"), 1, 1, func_strip},
- { STRING_SIZE_TUPLE("wildcard"), 1, 1, func_wildcard},
- { STRING_SIZE_TUPLE("word"), 2, 1, func_word},
- { STRING_SIZE_TUPLE("wordlist"), 3, 1, func_wordlist},
- { STRING_SIZE_TUPLE("words"), 1, 1, func_words},
- { STRING_SIZE_TUPLE("origin"), 1, 1, func_origin},
- { STRING_SIZE_TUPLE("foreach"), 3, 0, func_foreach},
- { STRING_SIZE_TUPLE("call"), -1, 1, func_call},
- { STRING_SIZE_TUPLE("error"), 1, 1, func_error},
- { STRING_SIZE_TUPLE("warning"), 1, 1, func_error},
- { STRING_SIZE_TUPLE("if"), -2, 0, func_if},
+ /* Name/size */ /* MIN MAX EXP? Function */
+ { STRING_SIZE_TUPLE("addprefix"), 2, 2, 1, func_addsuffix_addprefix},
+ { STRING_SIZE_TUPLE("addsuffix"), 2, 2, 1, func_addsuffix_addprefix},
+ { STRING_SIZE_TUPLE("basename"), 1, 1, 1, func_basename_dir},
+ { STRING_SIZE_TUPLE("dir"), 1, 1, 1, func_basename_dir},
+ { STRING_SIZE_TUPLE("notdir"), 1, 1, 1, func_notdir_suffix},
+ { STRING_SIZE_TUPLE("subst"), 3, 3, 1, func_subst},
+ { STRING_SIZE_TUPLE("suffix"), 1, 1, 1, func_notdir_suffix},
+ { STRING_SIZE_TUPLE("filter"), 2, 2, 1, func_filter_filterout},
+ { STRING_SIZE_TUPLE("filter-out"), 2, 2, 1, func_filter_filterout},
+ { STRING_SIZE_TUPLE("findstring"), 2, 2, 1, func_findstring},
+ { STRING_SIZE_TUPLE("firstword"), 1, 1, 1, func_firstword},
+ { STRING_SIZE_TUPLE("join"), 2, 2, 1, func_join},
+ { STRING_SIZE_TUPLE("patsubst"), 3, 3, 1, func_patsubst},
+ { STRING_SIZE_TUPLE("shell"), 1, 1, 1, func_shell},
+ { STRING_SIZE_TUPLE("sort"), 1, 1, 1, func_sort},
+ { STRING_SIZE_TUPLE("strip"), 1, 1, 1, func_strip},
+ { STRING_SIZE_TUPLE("wildcard"), 1, 1, 1, func_wildcard},
+ { STRING_SIZE_TUPLE("word"), 2, 2, 1, func_word},
+ { STRING_SIZE_TUPLE("wordlist"), 3, 3, 1, func_wordlist},
+ { STRING_SIZE_TUPLE("words"), 1, 1, 1, func_words},
+ { STRING_SIZE_TUPLE("origin"), 1, 1, 1, func_origin},
+ { STRING_SIZE_TUPLE("foreach"), 3, 3, 0, func_foreach},
+ { STRING_SIZE_TUPLE("call"), 1, 0, 0, func_call},
+ { STRING_SIZE_TUPLE("error"), 1, 1, 1, func_error},
+ { STRING_SIZE_TUPLE("warning"), 1, 1, 1, func_error},
+ { STRING_SIZE_TUPLE("if"), 2, 3, 0, func_if},
#ifdef EXPERIMENTAL
- { STRING_SIZE_TUPLE("eq"), 2, 1, func_eq},
- { STRING_SIZE_TUPLE("not"), 1, 1, func_not},
+ { STRING_SIZE_TUPLE("eq"), 2, 2, 1, func_eq},
+ { STRING_SIZE_TUPLE("not"), 1, 1, 1, func_not},
#endif
{ 0 }
};
char **argv;
struct function_table_entry *entry_p;
{
- int min = (entry_p->required_args > 0
- ? entry_p->required_args
- : -entry_p->required_args);
-
- if (argc < min)
+ if (argc < entry_p->minimum_args)
fatal (reading_file,
_("Insufficient number of arguments (%d) to function `%s'"),
argc, entry_p->name);
const struct function_table_entry *entry_p;
char openparen = (*stringp)[0];
char closeparen = openparen == '(' ? ')' : '}';
- char *beg = *stringp + 1;
- char *endref;
+ char *beg;
+ char *end;
int count = 0;
- char *argbeg;
register char *p;
char **argv, **argvp;
int nargs;
+ beg = *stringp + 1;
+
entry_p = lookup_function (function_table, beg);
if (!entry_p)
return 0;
- /* We have found a call to a builtin function. Find the end of the
- arguments, and do the function. */
-
- endref = beg + entry_p->len;
+ /* We found a builtin function. Find the beginning of its arguments (skip
+ whitespace after the name). */
- /* Space after function name isn't part of the args. */
- p = next_token (endref);
- argbeg = p;
+ beg = next_token (beg + entry_p->len);
/* Find the end of the function invocation, counting nested use of
whichever kind of parens we use. Since we're looking, count commas
to get a rough estimate of how many arguments we might have. The
count might be high, but it'll never be low. */
- for (nargs=1; *p != '\0'; ++p)
- if (*p == ',')
+ for (nargs=1, end=beg; *end != '\0'; ++end)
+ if (*end == ',')
++nargs;
- else if (*p == openparen)
+ else if (*end == openparen)
++count;
- else if (*p == closeparen && --count < 0)
+ else if (*end == closeparen && --count < 0)
break;
if (count >= 0)
_("unterminated call to function `%s': missing `%c'"),
entry_p->name, closeparen);
+ *stringp = end;
+
/* Get some memory to store the arg pointers. */
argvp = argv = (char **) alloca (sizeof(char *) * (nargs + 2));
- /* Chop the string into arguments, then store the end pointer and a nul.
- If REQUIRED_ARGS is positive, as soon as we hit that many assume the
- rest of the string is part of the last argument. */
- *argvp = argbeg;
- nargs = 1;
- while (entry_p->required_args < 0 || nargs < entry_p->required_args)
+ /* Chop the string into arguments, then a nul. As soon as we hit
+ MAXIMUM_ARGS (if it's >0) assume the rest of the string is part of the
+ last argument.
+
+ If we're expanding, store pointers to the expansion of each one. If
+ not, make a duplicate of the string and point into that, nul-terminating
+ each argument. */
+
+ if (!entry_p->expand_args)
{
- char *next = find_next_argument (openparen, closeparen, *argvp, p);
+ int len = end - beg;
- if (!next)
- break;
+ p = xmalloc (len+1);
+ memcpy (p, beg, len);
+ p[len] = '\0';
+ beg = p;
+ end = beg + len;
+ }
+
+ p = beg;
+ nargs = 0;
+ for (p=beg, nargs=0; p < end; ++argvp)
+ {
+ char *next;
- *(++argvp) = next+1;
++nargs;
- }
- *(++argvp) = p+1;
- *(++argvp) = 0;
+ if (nargs == entry_p->maximum_args
+ || (! (next = find_next_argument (openparen, closeparen, p, end))))
+ next = end;
- /* If we should expand, do it. */
- if (entry_p->expand_args)
- {
- for (argvp=argv; argvp[1] != 0; ++argvp)
- *argvp = expand_argument (*argvp, argvp[1]-1);
+ if (entry_p->expand_args)
+ *argvp = expand_argument (p, next);
+ else
+ {
+ *argvp = p;
+ *next = '\0';
+ }
- /* end pointer doesn't make sense for expanded stuff. */
- *argvp = 0;
+ p = next + 1;
}
+ *argvp = NULL;
/* Finally! Run the function... */
*op = expand_builtin_function (*op, nargs, argv, entry_p);
- /* If we allocated memory for the expanded args, free it again. */
+ /* Free memory. */
if (entry_p->expand_args)
for (argvp=argv; *argvp != 0; ++argvp)
free (*argvp);
-
- *stringp = p;
+ else
+ free (beg);
return 1;
}
const char *funcname;
{
char *fname;
+ char *cp;
int flen;
char *body;
int i;
const struct function_table_entry *entry_p;
- /* Calling nothing is a no-op. */
- if (*argv[0] == '\0')
- return o;
+ fname = expand_argument (argv[0], NULL);
/* There is no way to define a variable with a space in the name, so strip
- trailing whitespace as a favor to the user. */
-
- flen = strlen (argv[0]);
- fname = argv[0] + flen - 1;
- while (isspace ((unsigned char)*fname))
- --fname;
- fname[1] = '\0';
-
- flen = fname - argv[0] + 1;
- fname = argv[0];
+ leading and trailing whitespace as a favor to the user. */
+ cp = fname;
+ while (*cp != '\0' && isspace ((unsigned char)*cp))
+ ++cp;
+ argv[0] = cp;
+
+ cp += strlen(cp) - 1;
+ while (cp > argv[0] && isspace ((unsigned char)*cp))
+ --cp;
+ cp[1] = '\0';
+
+ /* Calling nothing is a no-op */
+ if (*argv[0] == '\0')
+ {
+ free (fname);
+ return o;
+ }
/* Are we invoking a builtin function? */
- entry_p = lookup_function (function_table, fname);
+ entry_p = lookup_function (function_table, argv[0]);
if (entry_p)
{
+ char **av;
+
+ free (fname);
+
+ /* How many arguments do we have? */
for (i=0; argv[i+1]; ++i)
- ;
+ ;
+
+ /* If we need to expand arguments, do it now. */
+ if (entry_p->expand_args)
+ for (av=argv+1; *av; ++av)
+ *av = expand_argument (*av, NULL);
+
+ o = expand_builtin_function (o, i, argv+1, entry_p);
- return expand_builtin_function (o, i, argv + 1, entry_p);
+ /* What we expanded we must free... */
+ if (entry_p->expand_args)
+ for (av=argv+1; *av; ++av)
+ free (*av);
+
+ return o;
}
- /* No, so the first argument is the name of a variable to be expanded and
- interpreted as a function. Create the variable reference. */
+ /* Not a builtin, so the first argument is the name of a variable to be
+ expanded and interpreted as a function. Create the variable
+ reference. */
+ flen = strlen (argv[0]);
+
body = alloca (flen + 4);
- body[0]='$';
- body[1]='(';
- strcpy (body + 2, fname);
- body[flen+2]=')';
- body[flen+3]= '\0';
+ body[0] = '$';
+ body[1] = '(';
+ memcpy (body + 2, fname, flen);
+ body[flen+2] = ')';
+ body[flen+3] = '\0';
/* Set up arguments $(1) .. $(N). $(0) is the function name. */
char num[11];
sprintf (num, "%d", i);
- define_variable (num, strlen (num), *argv, o_automatic, 0);
+ define_variable (num, strlen (num), *argv, o_automatic, 1);
}
/* Expand the body in the context of the arguments, adding the result to
pop_variable_scope ();
+ free (fname);
return o + strlen(o);
}
projects / platform / upstream / make.git / commitdiff