URL https://opencores.org/ocsvn/core_arm/core_arm/trunk

Subversion Repositories core_arm

[/] [core_arm/] [trunk/] [build/] [config/] [zconf.l] - Blame information for rev 4

Details | Compare with Previous | View Log


%option backup nostdinit noyywrap never-interactive full ecs
%option 8bit backup nodefault perf-report perf-report
%x COMMAND HELP STRING PARAM
%{
/*
 * Copyright (C) 2002 Roman Zippel 
 * Released under the terms of the GNU GPL v2.0.
 */
 
#include 
#include 
#include 
#include 
#include 
 
#define LKC_DIRECT_LINK
#include "lkc.h"
 
#define START_STRSIZE   16
 
char *text;
static char *text_ptr;
static int text_size, text_asize;
 
struct buffer {
        struct buffer *parent;
        YY_BUFFER_STATE state;
};
 
struct buffer *current_buf;
 
static int last_ts, first_ts;
 
static void zconf_endhelp(void);
static struct buffer *zconf_endfile(void);
 
void new_string(void)
{
        text = malloc(START_STRSIZE);
        text_asize = START_STRSIZE;
        text_ptr = text;
        text_size = 0;
        *text_ptr = 0;
}
 
void append_string(const char *str, int size)
{
        int new_size = text_size + size + 1;
        if (new_size > text_asize) {
                text = realloc(text, new_size);
                text_asize = new_size;
                text_ptr = text + text_size;
        }
        memcpy(text_ptr, str, size);
        text_ptr += size;
        text_size += size;
        *text_ptr = 0;
}
 
void alloc_string(const char *str, int size)
{
        text = malloc(size + 1);
        memcpy(text, str, size);
        text[size] = 0;
}
%}
 
ws      [ \n\t]
n       [A-Za-z0-9_]
 
%%
        int str = 0;
        int ts, i;
 
[ \t]*#.*\n     current_file->lineno++;
[ \t]*#.*
 
[ \t]*\n        current_file->lineno++; return T_EOL;
 
[ \t]+  {
        BEGIN(COMMAND);
}
 
.       {
        unput(yytext[0]);
        BEGIN(COMMAND);
}
 
 
{
        "mainmenu"              BEGIN(PARAM); return T_MAINMENU;
        "menu"                  BEGIN(PARAM); return T_MENU;
        "endmenu"               BEGIN(PARAM); return T_ENDMENU;
        "source"                BEGIN(PARAM); return T_SOURCE;
        "choice"                BEGIN(PARAM); return T_CHOICE;
        "endchoice"             BEGIN(PARAM); return T_ENDCHOICE;
        "comment"               BEGIN(PARAM); return T_COMMENT;
        "config"                BEGIN(PARAM); return T_CONFIG;
        "menuconfig"            BEGIN(PARAM); return T_MENUCONFIG;
        "help"                  BEGIN(PARAM); return T_HELP;
        "if"                    BEGIN(PARAM); return T_IF;
        "endif"                 BEGIN(PARAM); return T_ENDIF;
        "depends"               BEGIN(PARAM); return T_DEPENDS;
        "requires"              BEGIN(PARAM); return T_REQUIRES;
        "optional"              BEGIN(PARAM); return T_OPTIONAL;
        "default"               BEGIN(PARAM); return T_DEFAULT;
        "prompt"                BEGIN(PARAM); return T_PROMPT;
        "tristate"              BEGIN(PARAM); return T_TRISTATE;
        "def_tristate"          BEGIN(PARAM); return T_DEF_TRISTATE;
        "bool"                  BEGIN(PARAM); return T_BOOLEAN;
        "boolean"               BEGIN(PARAM); return T_BOOLEAN;
        "def_bool"              BEGIN(PARAM); return T_DEF_BOOLEAN;
        "def_boolean"           BEGIN(PARAM); return T_DEF_BOOLEAN;
        "int"                   BEGIN(PARAM); return T_INT;
        "hex"                   BEGIN(PARAM); return T_HEX;
        "string"                BEGIN(PARAM); return T_STRING;
        "select"                BEGIN(PARAM); return T_SELECT;
        "enable"                BEGIN(PARAM); return T_SELECT;
        "range"                 BEGIN(PARAM); return T_RANGE;
        {n}+    {
                alloc_string(yytext, yyleng);
                zconflval.string = text;
                return T_WORD;
        }
        .
        \n      current_file->lineno++; BEGIN(INITIAL);
}
 
{
        "&&"	return T_AND;
        "||"    return T_OR;
        "("     return T_OPEN_PAREN;
        ")"     return T_CLOSE_PAREN;
        "!"     return T_NOT;
        "="     return T_EQUAL;
        "!="    return T_UNEQUAL;
        "if"    return T_IF;
        "on"    return T_ON;
        \"|\'   {
                str = yytext[0];
                new_string();
                BEGIN(STRING);
        }
        \n      BEGIN(INITIAL); current_file->lineno++; return T_EOL;
        ---     /* ignore */
        ({n}|[-/.])+    {
                alloc_string(yytext, yyleng);
                zconflval.string = text;
                return T_WORD;
        }
        #.*     /* comment */
        \\\n    current_file->lineno++;
        .
        <> {
                BEGIN(INITIAL);
        }
}
 
{
        [^'"\\\n]+/\n   {
                append_string(yytext, yyleng);
                zconflval.string = text;
                return T_WORD_QUOTE;
        }
        [^'"\\\n]+      {
                append_string(yytext, yyleng);
        }
        \\.?/\n {
                append_string(yytext + 1, yyleng - 1);
                zconflval.string = text;
                return T_WORD_QUOTE;
        }
        \\.?    {
                append_string(yytext + 1, yyleng - 1);
        }
        \'|\"   {
                if (str == yytext[0]) {
                        BEGIN(PARAM);
                        zconflval.string = text;
                        return T_WORD_QUOTE;
                } else
                        append_string(yytext, 1);
        }
        \n      {
                printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno());
                current_file->lineno++;
                BEGIN(INITIAL);
                return T_EOL;
        }
        <>       {
                BEGIN(INITIAL);
        }
}
 
{
        [ \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] {
                current_file->lineno++;
                zconf_endhelp();
                return T_HELPTEXT;
        }
        [ \t]*\n        {
                current_file->lineno++;
                append_string("\n", 1);
        }
        [^ \t\n].* {
                append_string(yytext, yyleng);
                if (!first_ts)
                        first_ts = last_ts;
        }
        <>       {
                zconf_endhelp();
                return T_HELPTEXT;
        }
}
 
<>       {
        if (current_buf) {
                zconf_endfile();
                return T_EOF;
        }
        fclose(yyin);
        yyterminate();
}
 
%%
void zconf_starthelp(void)
{
        new_string();
        last_ts = first_ts = 0;
        BEGIN(HELP);
}
 
static void zconf_endhelp(void)
{
        zconflval.string = text;
        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");
        if (!f && name[0] != '/') {
                env = getenv(SRCTREE);
                if (env) {
                        sprintf(fullname, "%s/%s", env, name);
                        f = fopen(fullname, "r");
                }
        }
        return f;
}
 
void zconf_initscan(const char *name)
{
        yyin = zconf_fopen(name);
        if (!yyin) {
                printf("can't find file %s\n", name);
                exit(1);
        }
 
        current_buf = malloc(sizeof(*current_buf));
        memset(current_buf, 0, sizeof(*current_buf));
 
        current_file = file_lookup(name);
        current_file->lineno = 1;
        current_file->flags = FILE_BUSY;
}
 
void zconf_nextfile(const char *name)
{
        struct file *file = file_lookup(name);
        struct buffer *buf = malloc(sizeof(*buf));
        memset(buf, 0, sizeof(*buf));
 
        current_buf->state = YY_CURRENT_BUFFER;
        yyin = zconf_fopen(name);
        if (!yyin) {
                printf("%s:%d: can't open file \"%s\"\n", zconf_curname(), zconf_lineno(), name);
                exit(1);
        }
        yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
        buf->parent = current_buf;
        current_buf = buf;
 
        if (file->flags & FILE_BUSY) {
                printf("recursive scan (%s)?\n", name);
                exit(1);
        }
        if (file->flags & FILE_SCANNED) {
                printf("file %s already scanned?\n", name);
                exit(1);
        }
        file->flags |= FILE_BUSY;
        file->lineno = 1;
        file->parent = current_file;
        current_file = file;
}
 
static struct buffer *zconf_endfile(void)
{
        struct buffer *parent;
 
        current_file->flags |= FILE_SCANNED;
        current_file->flags &= ~FILE_BUSY;
        current_file = current_file->parent;
 
        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;
 
        return parent;
}
 
int zconf_lineno(void)
{
        if (current_buf)
                return current_file->lineno - 1;
        else
                return 0;
}
 
char *zconf_curname(void)
{
        if (current_buf)
                return current_file->name;
        else
                return "";
}

Browse

Tools

Subversion Repositories core_arm

[/] [core_arm/] [trunk/] [build/] [config/] [zconf.l] - Blame information for rev 4

Line No.	Rev	Author	Line
1	2	tarookumic	`%option backup nostdinit noyywrap never-interactive full ecs`
2			`%option 8bit backup nodefault perf-report perf-report`
3			`%x COMMAND HELP STRING PARAM`
4			`%{`
5			`/*`
6			`* Copyright (C) 2002 Roman Zippel`
7			`* Released under the terms of the GNU GPL v2.0.`
8			`*/`
9
10			`#include`
11			`#include`
12			`#include`
13			`#include`
14			`#include`
15
16			`#define LKC_DIRECT_LINK`
17			`#include "lkc.h"`
18
19			`#define START_STRSIZE 16`
20
21			`char *text;`
22			`static char *text_ptr;`
23			`static int text_size, text_asize;`
24
25			`struct buffer {`
26			`struct buffer *parent;`
27			`YY_BUFFER_STATE state;`
28			`};`
29
30			`struct buffer *current_buf;`
31
32			`static int last_ts, first_ts;`
33
34			`static void zconf_endhelp(void);`
35			`static struct buffer *zconf_endfile(void);`
36
37			`void new_string(void)`
38			`{`
39			`text = malloc(START_STRSIZE);`
40			`text_asize = START_STRSIZE;`
41			`text_ptr = text;`
42			`text_size = 0;`
43			`*text_ptr = 0;`
44			`}`
45
46			`void append_string(const char *str, int size)`
47			`{`
48			`int new_size = text_size + size + 1;`
49			`if (new_size > text_asize) {`
50			`text = realloc(text, new_size);`
51			`text_asize = new_size;`
52			`text_ptr = text + text_size;`
53			`}`
54			`memcpy(text_ptr, str, size);`
55			`text_ptr += size;`
56			`text_size += size;`
57			`*text_ptr = 0;`
58			`}`
59
60			`void alloc_string(const char *str, int size)`
61			`{`
62			`text = malloc(size + 1);`
63			`memcpy(text, str, size);`
64			`text[size] = 0;`
65			`}`
66			`%}`
67
68			`ws [ \n\t]`
69			`n [A-Za-z0-9_]`
70
71			`%%`
72			`int str = 0;`
73			`int ts, i;`
74
75			`[ \t]#.\n current_file->lineno++;`
76			`[ \t]#.`
77
78			`[ \t]*\n current_file->lineno++; return T_EOL;`
79
80			`[ \t]+ {`
81			`BEGIN(COMMAND);`
82			`}`
83
84			`. {`
85			`unput(yytext[0]);`
86			`BEGIN(COMMAND);`
87			`}`
88
89
90			`{`
91			`"mainmenu" BEGIN(PARAM); return T_MAINMENU;`
92			`"menu" BEGIN(PARAM); return T_MENU;`
93			`"endmenu" BEGIN(PARAM); return T_ENDMENU;`
94			`"source" BEGIN(PARAM); return T_SOURCE;`
95			`"choice" BEGIN(PARAM); return T_CHOICE;`
96			`"endchoice" BEGIN(PARAM); return T_ENDCHOICE;`
97			`"comment" BEGIN(PARAM); return T_COMMENT;`
98			`"config" BEGIN(PARAM); return T_CONFIG;`
99			`"menuconfig" BEGIN(PARAM); return T_MENUCONFIG;`
100			`"help" BEGIN(PARAM); return T_HELP;`
101			`"if" BEGIN(PARAM); return T_IF;`
102			`"endif" BEGIN(PARAM); return T_ENDIF;`
103			`"depends" BEGIN(PARAM); return T_DEPENDS;`
104			`"requires" BEGIN(PARAM); return T_REQUIRES;`
105			`"optional" BEGIN(PARAM); return T_OPTIONAL;`
106			`"default" BEGIN(PARAM); return T_DEFAULT;`
107			`"prompt" BEGIN(PARAM); return T_PROMPT;`
108			`"tristate" BEGIN(PARAM); return T_TRISTATE;`
109			`"def_tristate" BEGIN(PARAM); return T_DEF_TRISTATE;`
110			`"bool" BEGIN(PARAM); return T_BOOLEAN;`
111			`"boolean" BEGIN(PARAM); return T_BOOLEAN;`
112			`"def_bool" BEGIN(PARAM); return T_DEF_BOOLEAN;`
113			`"def_boolean" BEGIN(PARAM); return T_DEF_BOOLEAN;`
114			`"int" BEGIN(PARAM); return T_INT;`
115			`"hex" BEGIN(PARAM); return T_HEX;`
116			`"string" BEGIN(PARAM); return T_STRING;`
117			`"select" BEGIN(PARAM); return T_SELECT;`
118			`"enable" BEGIN(PARAM); return T_SELECT;`
119			`"range" BEGIN(PARAM); return T_RANGE;`
120			`{n}+ {`
121			`alloc_string(yytext, yyleng);`
122			`zconflval.string = text;`
123			`return T_WORD;`
124			`}`
125			`.`
126			`\n current_file->lineno++; BEGIN(INITIAL);`
127			`}`
128
129			`{`
130			`"&&" return T_AND;`
131			`"\|\|" return T_OR;`
132			`"(" return T_OPEN_PAREN;`
133			`")" return T_CLOSE_PAREN;`
134			`"!" return T_NOT;`
135			`"=" return T_EQUAL;`
136			`"!=" return T_UNEQUAL;`
137			`"if" return T_IF;`
138			`"on" return T_ON;`
139			`\"\|\' {`
140			`str = yytext[0];`
141			`new_string();`
142			`BEGIN(STRING);`
143			`}`
144			`\n BEGIN(INITIAL); current_file->lineno++; return T_EOL;`
145			`--- /* ignore */`
146			`({n}\|[-/.])+ {`
147			`alloc_string(yytext, yyleng);`
148			`zconflval.string = text;`
149			`return T_WORD;`
150			`}`
151			`#.* /* comment */`
152			`\\\n current_file->lineno++;`
153			`.`
154			`<> {`
155			`BEGIN(INITIAL);`
156			`}`
157			`}`
158
159			`{`
160			`[^'"\\\n]+/\n {`
161			`append_string(yytext, yyleng);`
162			`zconflval.string = text;`
163			`return T_WORD_QUOTE;`
164			`}`
165			`[^'"\\\n]+ {`
166			`append_string(yytext, yyleng);`
167			`}`
168			`\\.?/\n {`
169			`append_string(yytext + 1, yyleng - 1);`
170			`zconflval.string = text;`
171			`return T_WORD_QUOTE;`
172			`}`
173			`\\.? {`
174			`append_string(yytext + 1, yyleng - 1);`
175			`}`
176			`\'\|\" {`
177			`if (str == yytext[0]) {`
178			`BEGIN(PARAM);`
179			`zconflval.string = text;`
180			`return T_WORD_QUOTE;`
181			`} else`
182			`append_string(yytext, 1);`
183			`}`
184			`\n {`
185			`printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno());`
186			`current_file->lineno++;`
187			`BEGIN(INITIAL);`
188			`return T_EOL;`
189			`}`
190			`<> {`
191			`BEGIN(INITIAL);`
192			`}`
193			`}`
194
195			`{`
196			`[ \t]+ {`
197			`ts = 0;`
198			`for (i = 0; i < yyleng; i++) {`
199			`if (yytext[i] == '\t')`
200			`ts = (ts & ~7) + 8;`
201			`else`
202			`ts++;`
203			`}`
204			`last_ts = ts;`
205			`if (first_ts) {`
206			`if (ts < first_ts) {`
207			`zconf_endhelp();`
208			`return T_HELPTEXT;`
209			`}`
210			`ts -= first_ts;`
211			`while (ts > 8) {`
212			`append_string(" ", 8);`
213			`ts -= 8;`
214			`}`
215			`append_string(" ", ts);`
216			`}`
217			`}`
218			`[ \t]*\n/[^ \t\n] {`
219			`current_file->lineno++;`
220			`zconf_endhelp();`
221			`return T_HELPTEXT;`
222			`}`
223			`[ \t]*\n {`
224			`current_file->lineno++;`
225			`append_string("\n", 1);`
226			`}`
227			`[^ \t\n].* {`
228			`append_string(yytext, yyleng);`
229			`if (!first_ts)`
230			`first_ts = last_ts;`
231			`}`
232			`<> {`
233			`zconf_endhelp();`
234			`return T_HELPTEXT;`
235			`}`
236			`}`
237
238			`<> {`
239			`if (current_buf) {`
240			`zconf_endfile();`
241			`return T_EOF;`
242			`}`
243			`fclose(yyin);`
244			`yyterminate();`
245			`}`
246
247			`%%`
248			`void zconf_starthelp(void)`
249			`{`
250			`new_string();`
251			`last_ts = first_ts = 0;`
252			`BEGIN(HELP);`
253			`}`
254
255			`static void zconf_endhelp(void)`
256			`{`
257			`zconflval.string = text;`
258			`BEGIN(INITIAL);`
259			`}`
260
261
262			`/*`
263			`* Try to open specified file with following names:`
264			`* ./name`
265			`* $(srctree)/name`
266			`* The latter is used when srctree is separate from objtree`
267			`* when compiling the kernel.`
268			`* Return NULL if file is not found.`
269			`*/`
270			`FILE zconf_fopen(const char name)`
271			`{`
272			`char *env, fullname[PATH_MAX+1];`
273			`FILE *f;`
274
275			`f = fopen(name, "r");`
276			`if (!f && name[0] != '/') {`
277			`env = getenv(SRCTREE);`
278			`if (env) {`
279			`sprintf(fullname, "%s/%s", env, name);`
280			`f = fopen(fullname, "r");`
281			`}`
282			`}`
283			`return f;`
284			`}`
285
286			`void zconf_initscan(const char *name)`
287			`{`
288			`yyin = zconf_fopen(name);`
289			`if (!yyin) {`
290			`printf("can't find file %s\n", name);`
291			`exit(1);`
292			`}`
293
294			`current_buf = malloc(sizeof(*current_buf));`
295			`memset(current_buf, 0, sizeof(*current_buf));`
296
297			`current_file = file_lookup(name);`
298			`current_file->lineno = 1;`
299			`current_file->flags = FILE_BUSY;`
300			`}`
301
302			`void zconf_nextfile(const char *name)`
303			`{`
304			`struct file *file = file_lookup(name);`
305			`struct buffer buf = malloc(sizeof(buf));`
306			`memset(buf, 0, sizeof(*buf));`
307
308			`current_buf->state = YY_CURRENT_BUFFER;`
309			`yyin = zconf_fopen(name);`
310			`if (!yyin) {`
311			`printf("%s:%d: can't open file \"%s\"\n", zconf_curname(), zconf_lineno(), name);`
312			`exit(1);`
313			`}`
314			`yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));`
315			`buf->parent = current_buf;`
316			`current_buf = buf;`
317
318			`if (file->flags & FILE_BUSY) {`
319			`printf("recursive scan (%s)?\n", name);`
320			`exit(1);`
321			`}`
322			`if (file->flags & FILE_SCANNED) {`
323			`printf("file %s already scanned?\n", name);`
324			`exit(1);`
325			`}`
326			`file->flags \|= FILE_BUSY;`
327			`file->lineno = 1;`
328			`file->parent = current_file;`
329			`current_file = file;`
330			`}`
331
332			`static struct buffer *zconf_endfile(void)`
333			`{`
334			`struct buffer *parent;`
335
336			`current_file->flags \|= FILE_SCANNED;`
337			`current_file->flags &= ~FILE_BUSY;`
338			`current_file = current_file->parent;`
339
340			`parent = current_buf->parent;`
341			`if (parent) {`
342			`fclose(yyin);`
343			`yy_delete_buffer(YY_CURRENT_BUFFER);`
344			`yy_switch_to_buffer(parent->state);`
345			`}`
346			`free(current_buf);`
347			`current_buf = parent;`
348
349			`return parent;`
350			`}`
351
352			`int zconf_lineno(void)`
353			`{`
354			`if (current_buf)`
355			`return current_file->lineno - 1;`
356			`else`
357			`return 0;`
358			`}`
359
360			`char *zconf_curname(void)`
361			`{`
362			`if (current_buf)`
363			`return current_file->name;`
364			`else`
365			`return "";`
366			`}`