2018-12-18 13:13:35 +01:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
|
|
|
/*
|
|
|
|
* Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
|
|
|
|
*/
|
2011-06-07 19:34:05 +02:00
|
|
|
%option nostdinit noyywrap never-interactive full ecs
|
2018-03-22 18:00:14 +01:00
|
|
|
%option 8bit nodefault yylineno
|
2018-12-11 12:01:10 +01:00
|
|
|
%x ASSIGN_VAL HELP STRING
|
2005-04-17 00:20:36 +02:00
|
|
|
%{
|
|
|
|
|
kconfig: support user-defined function and recursively expanded variable
Now, we got a basic ability to test compiler capability in Kconfig.
config CC_HAS_STACKPROTECTOR
def_bool $(shell,($(CC) -Werror -fstack-protector -E -x c /dev/null -o /dev/null 2>/dev/null) && echo y || echo n)
This works, but it is ugly to repeat this long boilerplate.
We want to describe like this:
config CC_HAS_STACKPROTECTOR
bool
default $(cc-option,-fstack-protector)
It is straight-forward to add a new function, but I do not like to
hard-code specialized functions like that. Hence, here is another
feature, user-defined function. This works as a textual shorthand
with parameterization.
A user-defined function is defined by using the = operator, and can
be referenced in the same way as built-in functions. A user-defined
function in Make is referenced like $(call my-func,arg1,arg2), but I
omitted the 'call' to make the syntax shorter.
The definition of a user-defined function contains $(1), $(2), etc.
in its body to reference the parameters. It is grammatically valid
to pass more or fewer arguments when calling it. We already exploit
this feature in our makefiles; scripts/Kbuild.include defines cc-option
which takes two arguments at most, but most of the callers pass only
one argument.
By the way, a variable is supported as a subset of this feature since
a variable is "a user-defined function with zero argument". In this
context, I mean "variable" as recursively expanded variable. I will
add a different flavored variable in the next commit.
The code above can be written as follows:
[Example Code]
success = $(shell,($(1)) >/dev/null 2>&1 && echo y || echo n)
cc-option = $(success,$(CC) -Werror $(1) -E -x c /dev/null -o /dev/null)
config CC_HAS_STACKPROTECTOR
def_bool $(cc-option,-fstack-protector)
[Result]
$ make -s alldefconfig && tail -n 1 .config
CONFIG_CC_HAS_STACKPROTECTOR=y
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
2018-05-28 11:21:49 +02:00
|
|
|
#include <assert.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <limits.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
#include "lkc.h"
|
2019-01-24 11:47:30 +01:00
|
|
|
#include "parser.tab.h"
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2018-12-11 12:00:49 +01:00
|
|
|
#define YY_DECL static int yylex1(void)
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#define START_STRSIZE 16
|
|
|
|
|
2005-11-09 06:34:53 +01:00
|
|
|
static struct {
|
|
|
|
struct file *file;
|
|
|
|
int lineno;
|
|
|
|
} current_pos;
|
|
|
|
|
2018-12-11 12:01:08 +01:00
|
|
|
static int prev_prev_token = T_EOL;
|
2018-12-11 12:00:49 +01:00
|
|
|
static int prev_token = T_EOL;
|
2005-11-09 06:34:51 +01:00
|
|
|
static char *text;
|
2005-04-17 00:20:36 +02:00
|
|
|
static int text_size, text_asize;
|
|
|
|
|
|
|
|
struct buffer {
|
2014-06-10 12:08:13 +02:00
|
|
|
struct buffer *parent;
|
|
|
|
YY_BUFFER_STATE state;
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
struct buffer *current_buf;
|
|
|
|
|
|
|
|
static int last_ts, first_ts;
|
|
|
|
|
kconfig: reference environment variables directly and remove 'option env='
To get access to environment variables, Kconfig needs to define a
symbol using "option env=" syntax. It is tedious to add a symbol entry
for each environment variable given that we need to define much more
such as 'CC', 'AS', 'srctree' etc. to evaluate the compiler capability
in Kconfig.
Adding '$' for symbol references is grammatically inconsistent.
Looking at the code, the symbols prefixed with 'S' are expanded by:
- conf_expand_value()
This is used to expand 'arch/$ARCH/defconfig' and 'defconfig_list'
- sym_expand_string_value()
This is used to expand strings in 'source' and 'mainmenu'
All of them are fixed values independent of user configuration. So,
they can be changed into the direct expansion instead of symbols.
This change makes the code much cleaner. The bounce symbols 'SRCARCH',
'ARCH', 'SUBARCH', 'KERNELVERSION' are gone.
sym_init() hard-coding 'UNAME_RELEASE' is also gone. 'UNAME_RELEASE'
should be replaced with an environment variable.
ARCH_DEFCONFIG is a normal symbol, so it should be simply referenced
without '$' prefix.
The new syntax is addicted by Make. The variable reference needs
parentheses, like $(FOO), but you can omit them for single-letter
variables, like $F. Yet, in Makefiles, people tend to use the
parenthetical form for consistency / clarification.
At this moment, only the environment variable is supported, but I will
extend the concept of 'variable' later on.
The variables are expanded in the lexer so we can simplify the token
handling on the parser side.
For example, the following code works.
[Example code]
config MY_TOOLCHAIN_LIST
string
default "My tools: CC=$(CC), AS=$(AS), CPP=$(CPP)"
[Result]
$ make -s alldefconfig && tail -n 1 .config
CONFIG_MY_TOOLCHAIN_LIST="My tools: CC=gcc, AS=as, CPP=gcc -E"
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Reviewed-by: Kees Cook <keescook@chromium.org>
2018-05-28 11:21:40 +02:00
|
|
|
static char *expand_token(const char *in, size_t n);
|
|
|
|
static void append_expanded_string(const char *in);
|
2005-04-17 00:20:36 +02:00
|
|
|
static void zconf_endhelp(void);
|
2005-11-09 06:34:53 +01:00
|
|
|
static void zconf_endfile(void);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-10-15 21:13:36 +02:00
|
|
|
static void new_string(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2012-11-06 15:32:08 +01:00
|
|
|
text = xmalloc(START_STRSIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
text_asize = START_STRSIZE;
|
|
|
|
text_size = 0;
|
2005-11-09 06:34:51 +01:00
|
|
|
*text = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2009-10-15 21:13:36 +02:00
|
|
|
static void append_string(const char *str, int size)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int new_size = text_size + size + 1;
|
|
|
|
if (new_size > text_asize) {
|
2005-11-09 06:34:51 +01:00
|
|
|
new_size += START_STRSIZE - 1;
|
|
|
|
new_size &= -START_STRSIZE;
|
2018-02-08 17:19:07 +01:00
|
|
|
text = xrealloc(text, new_size);
|
2005-04-17 00:20:36 +02:00
|
|
|
text_asize = new_size;
|
|
|
|
}
|
2005-11-09 06:34:51 +01:00
|
|
|
memcpy(text + text_size, str, size);
|
2005-04-17 00:20:36 +02:00
|
|
|
text_size += size;
|
2005-11-09 06:34:51 +01:00
|
|
|
text[text_size] = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2009-10-15 21:13:36 +02:00
|
|
|
static void alloc_string(const char *str, int size)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2012-11-06 15:32:08 +01:00
|
|
|
text = xmalloc(size + 1);
|
2005-04-17 00:20:36 +02:00
|
|
|
memcpy(text, str, size);
|
|
|
|
text[size] = 0;
|
|
|
|
}
|
2015-07-12 09:41:50 +02:00
|
|
|
|
|
|
|
static void warn_ignored_character(char chr)
|
|
|
|
{
|
|
|
|
fprintf(stderr,
|
|
|
|
"%s:%d:warning: ignoring unsupported character '%c'\n",
|
2018-12-11 12:00:44 +01:00
|
|
|
current_file->name, yylineno, chr);
|
2015-07-12 09:41:50 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
%}
|
|
|
|
|
2015-07-12 09:41:50 +02:00
|
|
|
n [A-Za-z0-9_-]
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
%%
|
|
|
|
int str = 0;
|
|
|
|
int ts, i;
|
|
|
|
|
2018-12-11 12:01:10 +01:00
|
|
|
#.* /* ignore comment */
|
|
|
|
[ \t]* /* whitespaces */
|
|
|
|
\\\n /* escaped new line */
|
|
|
|
\n return T_EOL;
|
|
|
|
"allnoconfig_y" return T_ALLNOCONFIG_Y;
|
|
|
|
"bool" return T_BOOL;
|
|
|
|
"choice" return T_CHOICE;
|
|
|
|
"comment" return T_COMMENT;
|
|
|
|
"config" return T_CONFIG;
|
|
|
|
"def_bool" return T_DEF_BOOL;
|
|
|
|
"def_tristate" return T_DEF_TRISTATE;
|
|
|
|
"default" return T_DEFAULT;
|
|
|
|
"defconfig_list" return T_DEFCONFIG_LIST;
|
|
|
|
"depends" return T_DEPENDS;
|
|
|
|
"endchoice" return T_ENDCHOICE;
|
|
|
|
"endif" return T_ENDIF;
|
|
|
|
"endmenu" return T_ENDMENU;
|
|
|
|
"help"|"---help---" return T_HELP;
|
|
|
|
"hex" return T_HEX;
|
|
|
|
"if" return T_IF;
|
|
|
|
"imply" return T_IMPLY;
|
|
|
|
"int" return T_INT;
|
|
|
|
"mainmenu" return T_MAINMENU;
|
|
|
|
"menu" return T_MENU;
|
|
|
|
"menuconfig" return T_MENUCONFIG;
|
|
|
|
"modules" return T_MODULES;
|
|
|
|
"on" return T_ON;
|
|
|
|
"option" return T_OPTION;
|
|
|
|
"optional" return T_OPTIONAL;
|
|
|
|
"prompt" return T_PROMPT;
|
|
|
|
"range" return T_RANGE;
|
|
|
|
"select" return T_SELECT;
|
|
|
|
"source" return T_SOURCE;
|
|
|
|
"string" return T_STRING;
|
|
|
|
"tristate" return T_TRISTATE;
|
|
|
|
"visible" return T_VISIBLE;
|
|
|
|
"||" return T_OR;
|
|
|
|
"&&" return T_AND;
|
|
|
|
"=" return T_EQUAL;
|
|
|
|
"!=" return T_UNEQUAL;
|
|
|
|
"<" return T_LESS;
|
|
|
|
"<=" return T_LESS_EQUAL;
|
|
|
|
">" return T_GREATER;
|
|
|
|
">=" return T_GREATER_EQUAL;
|
|
|
|
"!" return T_NOT;
|
|
|
|
"(" return T_OPEN_PAREN;
|
|
|
|
")" return T_CLOSE_PAREN;
|
|
|
|
":=" return T_COLON_EQUAL;
|
|
|
|
"+=" return T_PLUS_EQUAL;
|
|
|
|
\"|\' {
|
|
|
|
str = yytext[0];
|
|
|
|
new_string();
|
|
|
|
BEGIN(STRING);
|
|
|
|
}
|
|
|
|
{n}+ {
|
|
|
|
alloc_string(yytext, yyleng);
|
|
|
|
yylval.string = text;
|
|
|
|
return T_WORD;
|
|
|
|
}
|
|
|
|
({n}|$)+ {
|
|
|
|
/* this token includes at least one '$' */
|
|
|
|
yylval.string = expand_token(yytext, yyleng);
|
|
|
|
if (strlen(yylval.string))
|
|
|
|
return T_WORD;
|
|
|
|
free(yylval.string);
|
|
|
|
}
|
|
|
|
. warn_ignored_character(*yytext);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
kconfig: support user-defined function and recursively expanded variable
Now, we got a basic ability to test compiler capability in Kconfig.
config CC_HAS_STACKPROTECTOR
def_bool $(shell,($(CC) -Werror -fstack-protector -E -x c /dev/null -o /dev/null 2>/dev/null) && echo y || echo n)
This works, but it is ugly to repeat this long boilerplate.
We want to describe like this:
config CC_HAS_STACKPROTECTOR
bool
default $(cc-option,-fstack-protector)
It is straight-forward to add a new function, but I do not like to
hard-code specialized functions like that. Hence, here is another
feature, user-defined function. This works as a textual shorthand
with parameterization.
A user-defined function is defined by using the = operator, and can
be referenced in the same way as built-in functions. A user-defined
function in Make is referenced like $(call my-func,arg1,arg2), but I
omitted the 'call' to make the syntax shorter.
The definition of a user-defined function contains $(1), $(2), etc.
in its body to reference the parameters. It is grammatically valid
to pass more or fewer arguments when calling it. We already exploit
this feature in our makefiles; scripts/Kbuild.include defines cc-option
which takes two arguments at most, but most of the callers pass only
one argument.
By the way, a variable is supported as a subset of this feature since
a variable is "a user-defined function with zero argument". In this
context, I mean "variable" as recursively expanded variable. I will
add a different flavored variable in the next commit.
The code above can be written as follows:
[Example Code]
success = $(shell,($(1)) >/dev/null 2>&1 && echo y || echo n)
cc-option = $(success,$(CC) -Werror $(1) -E -x c /dev/null -o /dev/null)
config CC_HAS_STACKPROTECTOR
def_bool $(cc-option,-fstack-protector)
[Result]
$ make -s alldefconfig && tail -n 1 .config
CONFIG_CC_HAS_STACKPROTECTOR=y
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
2018-05-28 11:21:49 +02:00
|
|
|
<ASSIGN_VAL>{
|
|
|
|
[^[:blank:]\n]+.* {
|
|
|
|
alloc_string(yytext, yyleng);
|
|
|
|
yylval.string = text;
|
|
|
|
return T_ASSIGN_VAL;
|
|
|
|
}
|
|
|
|
\n { BEGIN(INITIAL); return T_EOL; }
|
|
|
|
.
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
<STRING>{
|
kconfig: reference environment variables directly and remove 'option env='
To get access to environment variables, Kconfig needs to define a
symbol using "option env=" syntax. It is tedious to add a symbol entry
for each environment variable given that we need to define much more
such as 'CC', 'AS', 'srctree' etc. to evaluate the compiler capability
in Kconfig.
Adding '$' for symbol references is grammatically inconsistent.
Looking at the code, the symbols prefixed with 'S' are expanded by:
- conf_expand_value()
This is used to expand 'arch/$ARCH/defconfig' and 'defconfig_list'
- sym_expand_string_value()
This is used to expand strings in 'source' and 'mainmenu'
All of them are fixed values independent of user configuration. So,
they can be changed into the direct expansion instead of symbols.
This change makes the code much cleaner. The bounce symbols 'SRCARCH',
'ARCH', 'SUBARCH', 'KERNELVERSION' are gone.
sym_init() hard-coding 'UNAME_RELEASE' is also gone. 'UNAME_RELEASE'
should be replaced with an environment variable.
ARCH_DEFCONFIG is a normal symbol, so it should be simply referenced
without '$' prefix.
The new syntax is addicted by Make. The variable reference needs
parentheses, like $(FOO), but you can omit them for single-letter
variables, like $F. Yet, in Makefiles, people tend to use the
parenthetical form for consistency / clarification.
At this moment, only the environment variable is supported, but I will
extend the concept of 'variable' later on.
The variables are expanded in the lexer so we can simplify the token
handling on the parser side.
For example, the following code works.
[Example code]
config MY_TOOLCHAIN_LIST
string
default "My tools: CC=$(CC), AS=$(AS), CPP=$(CPP)"
[Result]
$ make -s alldefconfig && tail -n 1 .config
CONFIG_MY_TOOLCHAIN_LIST="My tools: CC=gcc, AS=as, CPP=gcc -E"
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Reviewed-by: Kees Cook <keescook@chromium.org>
2018-05-28 11:21:40 +02:00
|
|
|
"$".* append_expanded_string(yytext);
|
|
|
|
[^$'"\\\n]+ {
|
2005-04-17 00:20:36 +02:00
|
|
|
append_string(yytext, yyleng);
|
|
|
|
}
|
|
|
|
\\.? {
|
|
|
|
append_string(yytext + 1, yyleng - 1);
|
|
|
|
}
|
|
|
|
\'|\" {
|
|
|
|
if (str == yytext[0]) {
|
2018-12-11 12:01:10 +01:00
|
|
|
BEGIN(INITIAL);
|
2018-01-11 16:50:50 +01:00
|
|
|
yylval.string = text;
|
2005-04-17 00:20:36 +02:00
|
|
|
return T_WORD_QUOTE;
|
|
|
|
} else
|
|
|
|
append_string(yytext, 1);
|
|
|
|
}
|
|
|
|
\n {
|
2018-02-06 01:34:41 +01:00
|
|
|
fprintf(stderr,
|
|
|
|
"%s:%d:warning: multi-line strings not supported\n",
|
|
|
|
zconf_curname(), zconf_lineno());
|
2018-12-11 12:00:48 +01:00
|
|
|
unput('\n');
|
2005-04-17 00:20:36 +02:00
|
|
|
BEGIN(INITIAL);
|
2018-12-11 12:00:48 +01:00
|
|
|
yylval.string = text;
|
|
|
|
return T_WORD_QUOTE;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
<<EOF>> {
|
|
|
|
BEGIN(INITIAL);
|
2018-12-11 12:00:45 +01:00
|
|
|
yylval.string = text;
|
|
|
|
return T_WORD_QUOTE;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
<HELP>{
|
|
|
|
[ \t]+ {
|
|
|
|
ts = 0;
|
|
|
|
for (i = 0; i < yyleng; i++) {
|
|
|
|
if (yytext[i] == '\t')
|
|
|
|
ts = (ts & ~7) + 8;
|
|
|
|
else
|
|
|
|
ts++;
|
|
|
|
}
|
|
|
|
last_ts = ts;
|
|
|
|
if (first_ts) {
|
|
|
|
if (ts < first_ts) {
|
|
|
|
zconf_endhelp();
|
|
|
|
return T_HELPTEXT;
|
|
|
|
}
|
|
|
|
ts -= first_ts;
|
|
|
|
while (ts > 8) {
|
|
|
|
append_string(" ", 8);
|
|
|
|
ts -= 8;
|
|
|
|
}
|
|
|
|
append_string(" ", ts);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
[ \t]*\n/[^ \t\n] {
|
|
|
|
zconf_endhelp();
|
|
|
|
return T_HELPTEXT;
|
|
|
|
}
|
|
|
|
[ \t]*\n {
|
|
|
|
append_string("\n", 1);
|
|
|
|
}
|
|
|
|
[^ \t\n].* {
|
2008-01-11 23:55:20 +01:00
|
|
|
while (yyleng) {
|
|
|
|
if ((yytext[yyleng-1] != ' ') && (yytext[yyleng-1] != '\t'))
|
|
|
|
break;
|
|
|
|
yyleng--;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
append_string(yytext, yyleng);
|
|
|
|
if (!first_ts)
|
|
|
|
first_ts = last_ts;
|
|
|
|
}
|
|
|
|
<<EOF>> {
|
|
|
|
zconf_endhelp();
|
|
|
|
return T_HELPTEXT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
<<EOF>> {
|
2018-12-11 12:00:50 +01:00
|
|
|
BEGIN(INITIAL);
|
|
|
|
|
2018-12-11 12:00:51 +01:00
|
|
|
if (prev_token != T_EOL && prev_token != T_HELPTEXT)
|
|
|
|
fprintf(stderr, "%s:%d:warning: no new line at end of file\n",
|
|
|
|
current_file->name, yylineno);
|
|
|
|
|
2005-11-09 06:34:53 +01:00
|
|
|
if (current_file) {
|
2005-04-17 00:20:36 +02:00
|
|
|
zconf_endfile();
|
2005-11-09 06:34:53 +01:00
|
|
|
return T_EOL;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
fclose(yyin);
|
|
|
|
yyterminate();
|
|
|
|
}
|
|
|
|
|
|
|
|
%%
|
2018-12-11 12:00:49 +01:00
|
|
|
|
|
|
|
/* second stage lexer */
|
|
|
|
int yylex(void)
|
|
|
|
{
|
|
|
|
int token;
|
|
|
|
|
|
|
|
repeat:
|
|
|
|
token = yylex1();
|
|
|
|
|
2018-12-11 12:01:09 +01:00
|
|
|
if (prev_token == T_EOL || prev_token == T_HELPTEXT) {
|
|
|
|
if (token == T_EOL) {
|
|
|
|
/* Do not pass unneeded T_EOL to the parser. */
|
|
|
|
goto repeat;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* For the parser, update file/lineno at the first token
|
|
|
|
* of each statement. Generally, \n is a statement
|
|
|
|
* terminator in Kconfig, but it is not always true
|
|
|
|
* because \n could be escaped by a backslash.
|
|
|
|
*/
|
|
|
|
current_pos.file = current_file;
|
|
|
|
current_pos.lineno = yylineno;
|
|
|
|
}
|
|
|
|
}
|
2018-12-11 12:00:49 +01:00
|
|
|
|
2018-12-11 12:01:08 +01:00
|
|
|
if (prev_prev_token == T_EOL && prev_token == T_WORD &&
|
|
|
|
(token == T_EQUAL || token == T_COLON_EQUAL || token == T_PLUS_EQUAL))
|
|
|
|
BEGIN(ASSIGN_VAL);
|
|
|
|
|
|
|
|
prev_prev_token = prev_token;
|
2018-12-11 12:00:49 +01:00
|
|
|
prev_token = token;
|
|
|
|
|
|
|
|
return token;
|
|
|
|
}
|
|
|
|
|
kconfig: reference environment variables directly and remove 'option env='
To get access to environment variables, Kconfig needs to define a
symbol using "option env=" syntax. It is tedious to add a symbol entry
for each environment variable given that we need to define much more
such as 'CC', 'AS', 'srctree' etc. to evaluate the compiler capability
in Kconfig.
Adding '$' for symbol references is grammatically inconsistent.
Looking at the code, the symbols prefixed with 'S' are expanded by:
- conf_expand_value()
This is used to expand 'arch/$ARCH/defconfig' and 'defconfig_list'
- sym_expand_string_value()
This is used to expand strings in 'source' and 'mainmenu'
All of them are fixed values independent of user configuration. So,
they can be changed into the direct expansion instead of symbols.
This change makes the code much cleaner. The bounce symbols 'SRCARCH',
'ARCH', 'SUBARCH', 'KERNELVERSION' are gone.
sym_init() hard-coding 'UNAME_RELEASE' is also gone. 'UNAME_RELEASE'
should be replaced with an environment variable.
ARCH_DEFCONFIG is a normal symbol, so it should be simply referenced
without '$' prefix.
The new syntax is addicted by Make. The variable reference needs
parentheses, like $(FOO), but you can omit them for single-letter
variables, like $F. Yet, in Makefiles, people tend to use the
parenthetical form for consistency / clarification.
At this moment, only the environment variable is supported, but I will
extend the concept of 'variable' later on.
The variables are expanded in the lexer so we can simplify the token
handling on the parser side.
For example, the following code works.
[Example code]
config MY_TOOLCHAIN_LIST
string
default "My tools: CC=$(CC), AS=$(AS), CPP=$(CPP)"
[Result]
$ make -s alldefconfig && tail -n 1 .config
CONFIG_MY_TOOLCHAIN_LIST="My tools: CC=gcc, AS=as, CPP=gcc -E"
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Reviewed-by: Kees Cook <keescook@chromium.org>
2018-05-28 11:21:40 +02:00
|
|
|
static char *expand_token(const char *in, size_t n)
|
|
|
|
{
|
|
|
|
char *out;
|
|
|
|
int c;
|
|
|
|
char c2;
|
|
|
|
const char *rest, *end;
|
|
|
|
|
|
|
|
new_string();
|
|
|
|
append_string(in, n);
|
|
|
|
|
|
|
|
/* get the whole line because we do not know the end of token. */
|
|
|
|
while ((c = input()) != EOF) {
|
|
|
|
if (c == '\n') {
|
|
|
|
unput(c);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
c2 = c;
|
|
|
|
append_string(&c2, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
rest = text;
|
|
|
|
out = expand_one_token(&rest);
|
|
|
|
|
|
|
|
/* push back unused characters to the input stream */
|
|
|
|
end = rest + strlen(rest);
|
|
|
|
while (end > rest)
|
|
|
|
unput(*--end);
|
|
|
|
|
|
|
|
free(text);
|
|
|
|
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void append_expanded_string(const char *str)
|
|
|
|
{
|
|
|
|
const char *end;
|
|
|
|
char *res;
|
|
|
|
|
|
|
|
str++;
|
|
|
|
|
|
|
|
res = expand_dollar(&str);
|
|
|
|
|
|
|
|
/* push back unused characters to the input stream */
|
|
|
|
end = str + strlen(str);
|
|
|
|
while (end > str)
|
|
|
|
unput(*--end);
|
|
|
|
|
|
|
|
append_string(res, strlen(res));
|
|
|
|
|
|
|
|
free(res);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
void zconf_starthelp(void)
|
|
|
|
{
|
|
|
|
new_string();
|
|
|
|
last_ts = first_ts = 0;
|
|
|
|
BEGIN(HELP);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void zconf_endhelp(void)
|
|
|
|
{
|
2018-01-11 16:50:50 +01:00
|
|
|
yylval.string = text;
|
2005-04-17 00:20:36 +02:00
|
|
|
BEGIN(INITIAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to open specified file with following names:
|
|
|
|
* ./name
|
|
|
|
* $(srctree)/name
|
|
|
|
* The latter is used when srctree is separate from objtree
|
|
|
|
* when compiling the kernel.
|
|
|
|
* Return NULL if file is not found.
|
|
|
|
*/
|
|
|
|
FILE *zconf_fopen(const char *name)
|
|
|
|
{
|
|
|
|
char *env, fullname[PATH_MAX+1];
|
|
|
|
FILE *f;
|
|
|
|
|
|
|
|
f = fopen(name, "r");
|
2007-05-05 22:49:00 +02:00
|
|
|
if (!f && name != NULL && name[0] != '/') {
|
2005-04-17 00:20:36 +02:00
|
|
|
env = getenv(SRCTREE);
|
|
|
|
if (env) {
|
2019-05-10 21:28:52 +02:00
|
|
|
snprintf(fullname, sizeof(fullname),
|
|
|
|
"%s/%s", env, name);
|
2005-04-17 00:20:36 +02:00
|
|
|
f = fopen(fullname, "r");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return f;
|
|
|
|
}
|
|
|
|
|
|
|
|
void zconf_initscan(const char *name)
|
|
|
|
{
|
|
|
|
yyin = zconf_fopen(name);
|
|
|
|
if (!yyin) {
|
2018-02-06 01:34:41 +01:00
|
|
|
fprintf(stderr, "can't find file %s\n", name);
|
2005-04-17 00:20:36 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2012-11-06 15:32:08 +01:00
|
|
|
current_buf = xmalloc(sizeof(*current_buf));
|
2005-04-17 00:20:36 +02:00
|
|
|
memset(current_buf, 0, sizeof(*current_buf));
|
|
|
|
|
|
|
|
current_file = file_lookup(name);
|
2018-03-22 18:00:14 +01:00
|
|
|
yylineno = 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void zconf_nextfile(const char *name)
|
|
|
|
{
|
2011-02-24 19:36:42 +01:00
|
|
|
struct file *iter;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct file *file = file_lookup(name);
|
2012-11-06 15:32:08 +01:00
|
|
|
struct buffer *buf = xmalloc(sizeof(*buf));
|
2005-04-17 00:20:36 +02:00
|
|
|
memset(buf, 0, sizeof(*buf));
|
|
|
|
|
|
|
|
current_buf->state = YY_CURRENT_BUFFER;
|
2010-09-04 22:09:26 +02:00
|
|
|
yyin = zconf_fopen(file->name);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!yyin) {
|
2018-02-06 01:34:41 +01:00
|
|
|
fprintf(stderr, "%s:%d: can't open file \"%s\"\n",
|
|
|
|
zconf_curname(), zconf_lineno(), file->name);
|
2005-04-17 00:20:36 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
|
|
|
|
buf->parent = current_buf;
|
|
|
|
current_buf = buf;
|
|
|
|
|
2018-03-22 18:00:14 +01:00
|
|
|
current_file->lineno = yylineno;
|
2018-03-22 18:00:13 +01:00
|
|
|
file->parent = current_file;
|
|
|
|
|
|
|
|
for (iter = current_file; iter; iter = iter->parent) {
|
|
|
|
if (!strcmp(iter->name, file->name)) {
|
2018-02-06 01:34:41 +01:00
|
|
|
fprintf(stderr,
|
2018-03-22 18:00:12 +01:00
|
|
|
"Recursive inclusion detected.\n"
|
|
|
|
"Inclusion path:\n"
|
2018-03-22 18:00:13 +01:00
|
|
|
" current file : %s\n", file->name);
|
|
|
|
iter = file;
|
2018-03-02 08:05:12 +01:00
|
|
|
do {
|
2011-02-24 19:36:42 +01:00
|
|
|
iter = iter->parent;
|
2018-03-22 18:00:12 +01:00
|
|
|
fprintf(stderr, " included from: %s:%d\n",
|
2018-03-02 08:05:12 +01:00
|
|
|
iter->name, iter->lineno - 1);
|
2018-03-22 18:00:13 +01:00
|
|
|
} while (strcmp(iter->name, file->name));
|
2011-02-24 19:36:42 +01:00
|
|
|
exit(1);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2018-03-22 18:00:13 +01:00
|
|
|
|
2018-03-22 18:00:14 +01:00
|
|
|
yylineno = 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
current_file = file;
|
|
|
|
}
|
|
|
|
|
2005-11-09 06:34:53 +01:00
|
|
|
static void zconf_endfile(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct buffer *parent;
|
|
|
|
|
|
|
|
current_file = current_file->parent;
|
2018-03-22 18:00:14 +01:00
|
|
|
if (current_file)
|
|
|
|
yylineno = current_file->lineno;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
parent = current_buf->parent;
|
|
|
|
if (parent) {
|
|
|
|
fclose(yyin);
|
|
|
|
yy_delete_buffer(YY_CURRENT_BUFFER);
|
|
|
|
yy_switch_to_buffer(parent->state);
|
|
|
|
}
|
|
|
|
free(current_buf);
|
|
|
|
current_buf = parent;
|
|
|
|
}
|
|
|
|
|
|
|
|
int zconf_lineno(void)
|
|
|
|
{
|
2005-11-09 06:34:53 +01:00
|
|
|
return current_pos.lineno;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2010-09-04 22:03:30 +02:00
|
|
|
const char *zconf_curname(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-11-09 06:34:53 +01:00
|
|
|
return current_pos.file ? current_pos.file->name : "<none>";
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|