freebsd-dev/contrib/gcc/gengtype-lex.l
2003-07-11 03:40:53 +00:00

329 lines
7.5 KiB
Plaintext

/* -*- indented-text -*- */
/* Process source files and output type information.
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GCC.
GCC 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.
GCC 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 GCC; see the file COPYING. If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
%{
#include "hconfig.h"
#include "system.h"
#define malloc xmalloc
#define realloc xrealloc
#include "gengtype.h"
#include "gengtype-yacc.h"
#undef YY_USE_PROTOS
#define YY_DECL int yylex ()
static void update_lineno PARAMS ((const char *l, size_t len));
struct fileloc lexer_line;
int lexer_toplevel_done;
static void
update_lineno (l, len)
const char *l;
size_t len;
{
while (len-- > 0)
if (*l++ == '\n')
lexer_line.line++;
}
%}
ID [[:alpha:]_][[:alnum:]_]*
WS [[:space:]]+
IWORD short|long|(un)?signed|char|int|HOST_WIDE_INT|bool|size_t
ITYPE {IWORD}({WS}{IWORD})*
%x in_struct in_struct_comment in_comment in_yacc_escape
%option warn noyywrap nounput nodefault perf-report
%option 8bit never-interactive
%%
[^[:alnum:]_]typedef{WS}(struct|union){WS}{ID}{WS}?[*[:space:]]{WS}?{ID}{WS}?";" {
char *tagstart;
size_t taglen;
char *namestart;
size_t namelen;
int is_pointer = 0;
struct type *t;
int union_p;
tagstart = yytext + strlen (" typedef ");
while (ISSPACE (*tagstart))
tagstart++;
union_p = tagstart[0] == 'u';
tagstart += strlen ("union ");
while (ISSPACE (*tagstart))
tagstart++;
for (taglen = 1; ISIDNUM (tagstart[taglen]); taglen++)
;
for (namestart = tagstart + taglen;
! ISIDNUM (*namestart);
namestart++)
if (*namestart == '*')
is_pointer = 1;
for (namelen = 1; ISIDNUM (namestart[namelen]); namelen++)
;
t = find_structure (xmemdup (tagstart, taglen, taglen+1), union_p);
if (is_pointer)
t = create_pointer (t);
do_typedef (xmemdup (namestart, namelen, namelen+1), t, &lexer_line);
update_lineno (yytext, yyleng);
}
[^[:alnum:]_]typedef{WS}{ITYPE}{WS}{ID}{WS}?";" {
char *namestart;
size_t namelen;
struct type *t;
char *typestart;
size_t typelen;
for (namestart = yytext + yyleng - 2; ISSPACE (*namestart); namestart--)
;
for (namelen = 1; !ISSPACE (namestart[-namelen]); namelen++)
;
namestart -= namelen - 1;
for (typestart = yytext + strlen (" typedef ");
ISSPACE(*typestart);
typestart++)
;
for (typelen = namestart - typestart;
ISSPACE(typestart[typelen-1]);
typelen--)
;
t = create_scalar_type (typestart, typelen);
do_typedef (xmemdup (namestart, namelen, namelen+1), t, &lexer_line);
update_lineno (yytext, yyleng);
}
[^[:alnum:]_]typedef{WS}{ID}{WS}{ID}{WS}PARAMS {
char *namestart;
size_t namelen;
struct type *t;
for (namestart = yytext + yyleng - 7; ISSPACE (*namestart); namestart--)
;
for (namelen = 1; !ISSPACE (namestart[-namelen]); namelen++)
;
namestart -= namelen - 1;
t = create_scalar_type ("function type", sizeof ("function type")-1);
do_typedef (xmemdup (namestart, namelen, namelen+1), t, &lexer_line);
update_lineno (yytext, yyleng);
}
[^[:alnum:]_]typedef{WS}{ID}{WS}?"("{WS}?"*"{WS}?{ID}{WS}?")"{WS}?PARAMS {
char *namestart;
size_t namelen;
struct type *t;
for (namestart = yytext + yyleng - 7; !ISIDNUM (*namestart); namestart--)
;
for (namelen = 1; ISIDNUM (namestart[-namelen]); namelen++)
;
namestart -= namelen - 1;
t = create_scalar_type ("function type", sizeof ("function type")-1);
do_typedef (xmemdup (namestart, namelen, namelen+1), t, &lexer_line);
update_lineno (yytext, yyleng);
}
[^[:alnum:]_](typedef{WS})?(struct|union){WS}{ID}{WS}/"GTY" {
char *tagstart;
size_t taglen;
int typedef_p;
int union_p;
typedef_p = yytext[1] == 't';
if (typedef_p)
for (tagstart = yytext + strlen (" typedef ");
ISSPACE(*tagstart);
tagstart++)
;
else
tagstart = yytext + 1;
union_p = tagstart[0] == 'u';
tagstart += strlen ("union ");
while (ISSPACE (*tagstart))
tagstart++;
for (taglen = 1; ISIDNUM (tagstart[taglen]); taglen++)
;
yylval.t = find_structure (xmemdup (tagstart, taglen, taglen + 1), union_p);
BEGIN(in_struct);
update_lineno (yytext, yyleng);
return typedef_p ? ENT_TYPEDEF_STRUCT : ENT_STRUCT;
}
[^[:alnum:]_](extern|static){WS}/"GTY" {
BEGIN(in_struct);
update_lineno (yytext, yyleng);
return ENT_EXTERNSTATIC;
}
^"%union"{WS}"{"{WS}/"GTY" {
BEGIN(in_struct);
update_lineno (yytext, yyleng);
return ENT_YACCUNION;
}
<in_struct>{
"/*" { BEGIN(in_struct_comment); }
^"%{" { BEGIN(in_yacc_escape); }
{WS} { update_lineno (yytext, yyleng); }
"const"/[^[:alnum:]_] /* don't care */
"GTY"/[^[:alnum:]_] { return GTY_TOKEN; }
"union"/[^[:alnum:]_] { return UNION; }
"struct"/[^[:alnum:]_] { return STRUCT; }
"enum"/[^[:alnum:]_] { return ENUM; }
"ptr_alias"/[^[:alnum:]_] { return ALIAS; }
[0-9]+ { return NUM; }
"param"[0-9]*"_is"/[^[:alnum:]_] {
yylval.s = xmemdup (yytext, yyleng, yyleng+1);
return PARAM_IS;
}
{IWORD}({WS}{IWORD})*/[^[:alnum:]_] |
"ENUM_BITFIELD"{WS}?"("{WS}?{ID}{WS}?")" {
size_t len;
for (len = yyleng; ISSPACE (yytext[len-1]); len--)
;
yylval.t = create_scalar_type (yytext, len);
update_lineno (yytext, yyleng);
return SCALAR;
}
{ID}/[^[:alnum:]_] {
yylval.s = xmemdup (yytext, yyleng, yyleng+1);
return ID;
}
\"([^"\\]|\\.)*\" {
yylval.s = xmemdup (yytext+1, yyleng-2, yyleng-1);
return STRING;
}
"["[^\[\]]*"]" {
yylval.s = xmemdup (yytext+1, yyleng-2, yyleng-1);
return ARRAY;
}
^"%"{ID} {
yylval.s = xmemdup (yytext+1, yyleng-1, yyleng);
return PERCENT_ID;
}
"'"("\\".|[^\\])"'" {
yylval.s = xmemdup (yytext+1, yyleng-2, yyleng);
return CHAR;
}
[(){},*:<>] { return yytext[0]; }
[;=] {
if (lexer_toplevel_done)
{
BEGIN(INITIAL);
lexer_toplevel_done = 0;
}
return yytext[0];
}
^"%%" {
BEGIN(INITIAL);
return PERCENTPERCENT;
}
. {
error_at_line (&lexer_line, "unexpected character `%s'", yytext);
}
}
"/*" { BEGIN(in_comment); }
\n { lexer_line.line++; }
{ID} |
"'"("\\".|[^\\])"'" |
[^"/\n] /* do nothing */
\"([^"\\]|\\.|\\\n)*\" { update_lineno (yytext, yyleng); }
"/"/[^*] /* do nothing */
<in_comment,in_struct_comment>{
\n { lexer_line.line++; }
[^*\n]{16} |
[^*\n] /* do nothing */
"*"/[^/] /* do nothing */
}
<in_comment>"*/" { BEGIN(INITIAL); }
<in_struct_comment>"*/" { BEGIN(in_struct); }
<in_yacc_escape>{
\n { lexer_line.line++; }
[^%]{16} |
[^%] /* do nothing */
"%"/[^}] /* do nothing */
"%}" { BEGIN(in_struct); }
"%" {
error_at_line (&lexer_line,
"unterminated %%{; unexpected EOF");
}
}
["/] |
<in_struct_comment,in_comment>"*" {
error_at_line (&lexer_line,
"unterminated comment or string; unexpected EOF");
}
%%
void
yyerror (s)
const char *s;
{
error_at_line (&lexer_line, s);
}
void
parse_file (fname)
const char *fname;
{
yyin = fopen (fname, "r");
lexer_line.file = fname;
lexer_line.line = 1;
if (yyin == NULL)
{
perror (fname);
exit (1);
}
if (yyparse() != 0)
exit (1);
fclose (yyin);
}