编译原理之(1)c的lex词法文件和yacc语法文件.

C的Lex词法文件
发信站: 瀚海星云 (2005年11月15日18:
02:26 星期二), 站内信件 WWWPOST

D            [
0-9]
L            [a
-zA-Z_]
H            [a
-fA-F0-9]
E            [Ee][
+-]?{D}+
FS            (f
|F|l|L)
IS            (u
|U|l|L)*

%{
#include 
<stdio.h>
#include 
"y.tab.h"

void count();
%}


%%
"/*"            { comment(); }

"auto"            { count(); return(AUTO); }
"break"            { count(); return(BREAK); }
"case"            { count(); return(CASE); }
"char"            { count(); return(CHAR); }
"const"            { count(); return(CONST); }
"continue"        { count(); return(CONTINUE); }
"default"        { count(); return(DEFAULT); }
"do"            { count(); return(DO); }
"double"        { count(); return(DOUBLE); }
"else"            { count(); return(ELSE); }
"enum"            { count(); return(ENUM); }
"extern"        { count(); return(EXTERN); }
"float"            { count(); return(FLOAT); }
"for"            { count(); return(FOR); }
"goto"            { count(); return(GOTO); }
"if"            { count(); return(IF); }
"int"            { count(); return(INT); }
"long"            { count(); return(LONG); }
"register"        { count(); return(REGISTER); }
"return"        { count(); return(RETURN); }
"short"            { count(); return(SHORT); }
"signed"        { count(); return(SIGNED); }
"sizeof"        { count(); return(SIZEOF); }
"static"        { count(); return(STATIC); }
"struct"        { count(); return(STRUCT); }
"switch"        { count(); return(SWITCH); }
"typedef"        { count(); return(TYPEDEF); }
"union"            { count(); return(UNION); }
"unsigned"        { count(); return(UNSIGNED); }
"void"            { count(); return(VOID); }
"volatile"        { count(); return(VOLATILE); }
"while"            { count(); return(WHILE); }

{L}({L}|{D})*        { count(); return(check_type()); }

0[xX]{H}+{IS}?        { count(); return(CONSTANT); }
0{D}+{IS}?        { count(); return(CONSTANT); }
{D}+{IS}?        { count(); return(CONSTANT); }
L
?'(\\.|[^\\'])+'    { count(); return(CONSTANT); }

{D}+{E}{FS}?        { count(); return(CONSTANT); }
{D}*"."{D}+({E})?{FS}?    { count(); return(CONSTANT); }
{D}+"."{D}*({E})?{FS}?    { count(); return(CONSTANT); }

L
?\"(\\.|[^\\"])*\"    { count(); return(STRING_LITERAL); }

""            { count(); return(ELLIPSIS); }
">>="            { count(); return(RIGHT_ASSIGN); }
"<<="            { count(); return(LEFT_ASSIGN); }
"+="            { count(); return(ADD_ASSIGN); }
"-="            { count(); return(SUB_ASSIGN); }
"*="            { count(); return(MUL_ASSIGN); }
"/="            { count(); return(DIV_ASSIGN); }
"%="            { count(); return(MOD_ASSIGN); }
"&="            { count(); return(AND_ASSIGN); }
"^="            { count(); return(XOR_ASSIGN); }
"|="            { count(); return(OR_ASSIGN); }
">>"            { count(); return(RIGHT_OP); }
"<<"            { count(); return(LEFT_OP); }
"++"            { count(); return(INC_OP); }
"--"            { count(); return(DEC_OP); }
"->"            { count(); return(PTR_OP); }
"&&"            { count(); return(AND_OP); }
"||"            { count(); return(OR_OP); }
"<="            { count(); return(LE_OP); }
">="            { count(); return(GE_OP); }
"=="            { count(); return(EQ_OP); }
"!="            { count(); return(NE_OP); }
";"            { count(); return(';'); }
(
"{"|"<%")        { count(); return('{'); }
(
"}"|"%>")        { count(); return('}'); }
","            { count(); return(','); }
":"            { count(); return(':'); }
"="            { count(); return('='); }
"("            { count(); return('('); }
")"            { count(); return(')'); }
(
"["|"<:")        { count(); return('['); }
(
"]"|":>")        { count(); return(']'); }
"."            { count(); return('.'); }
"&"            { count(); return('&'); }
"!"            { count(); return('!'); }
"~"            { count(); return('~'); }
"-"            { count(); return('-'); }
"+"            { count(); return('+'); }
"*"            { count(); return('*'); }
"/"            { count(); return('/'); }
"%"            { count(); return('%'); }
"<"            { count(); return('<'); }
">"            { count(); return('>'); }
"^"            { count(); return('^'); }
"|"            { count(); return('|'); }
"?"            { count(); return('?'); }

[ \t\v\n\f]        
{ count(); }
.            
/* ignore bad characters */ }

%%

yywrap()
{
    
return(1);
}



comment()
{
    
char c, c1;

loop:
    
while ((c = input()) != '*' && c != 0)
        putchar(c);

    
if ((c1 = input()) != '/' && c != 0)
    
{
        unput(c1);
        
goto loop;
    }


    
if (c != 0)
        putchar(c1);
}



int column = 0;

void count()
{
    
int i;

    
for (i = 0; yytext[i] != '\0'; i++)
        
if (yytext[i] == '\n')
            column 
= 0;
        
else if (yytext[i] == '\t')
            column 
+= 8 - (column % 8);
        
else
            column
++;

    ECHO;
}



int check_type()
{
/*
* pseudo code --- this is what it should check
*
*    if (yytext == type_name)
*        return(TYPE_NAME);
*
*    return(IDENTIFIER);
*/


/*
*    it actually will only return IDENTIFIER
*/


    
return(IDENTIFIER);
}



C的Yacc语法文件
发信站: 瀚海星云 (2005年11月15日18:
02:44 星期二), 站内信件 WWWPOST

%token IDENTIFIER CONSTANT STRING_LITERAL SIZEOF
%token PTR_OP INC_OP DEC_OP LEFT_OP RIGHT_OP LE_OP GE_OP EQ_OP NE_OP
%token AND_OP OR_OP MUL_ASSIGN DIV_ASSIGN MOD_ASSIGN ADD_ASSIGN
%token SUB_ASSIGN LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN
%token XOR_ASSIGN OR_ASSIGN TYPE_NAME

%token TYPEDEF EXTERN STATIC AUTO REGISTER
%token CHAR SHORT INT LONG SIGNED UNSIGNED FLOAT DOUBLE CONST VOLATILE VOID
%token STRUCT UNION ENUM ELLIPSIS

%token CASE DEFAULT IF ELSE SWITCH WHILE DO FOR GOTO CONTINUE BREAK RETURN

%start translation_unit
%%

primary_expression
    : IDENTIFIER
    
| CONSTANT
    
| STRING_LITERAL
    
| '(' expression ')'
    ;

postfix_expression
    : primary_expression
    
| postfix_expression '[' expression ']'
    
| postfix_expression '(' ')'
    
| postfix_expression '(' argument_expression_list ')'
    
| postfix_expression '.' IDENTIFIER
    
| postfix_expression PTR_OP IDENTIFIER
    
| postfix_expression INC_OP
    
| postfix_expression DEC_OP
    ;

argument_expression_list
    : assignment_expression
    
| argument_expression_list ',' assignment_expression
    ;

unary_expression
    : postfix_expression
    
| INC_OP unary_expression
    
| DEC_OP unary_expression
    
| unary_operator cast_expression
    
| SIZEOF unary_expression
    
| SIZEOF '(' type_name ')'
    ;

unary_operator
    : 
'&'
    
| '*'
    
| '+'
    
| '-'
    
| '~'
    
| '!'
    ;

cast_expression
    : unary_expression
    
| '(' type_name ')' cast_expression
    ;

multiplicative_expression
    : cast_expression
    
| multiplicative_expression '*' cast_expression
    
| multiplicative_expression '/' cast_expression
    
| multiplicative_expression '%' cast_expression
    ;

additive_expression
    : multiplicative_expression
    
| additive_expression '+' multiplicative_expression
    
| additive_expression '-' multiplicative_expression
    ;

shift_expression
    : additive_expression
    
| shift_expression LEFT_OP additive_expression
    
| shift_expression RIGHT_OP additive_expression
    ;

relational_expression
    : shift_expression
    
| relational_expression '<' shift_expression
    
| relational_expression '>' shift_expression
    
| relational_expression LE_OP shift_expression
    
| relational_expression GE_OP shift_expression
    ;

equality_expression
    : relational_expression
    
| equality_expression EQ_OP relational_expression
    
| equality_expression NE_OP relational_expression
    ;

and_expression
    : equality_expression
    
| and_expression '&' equality_expression
    ;

exclusive_or_expression
    : and_expression
    
| exclusive_or_expression '^' and_expression
    ;

inclusive_or_expression
    : exclusive_or_expression
    
| inclusive_or_expression '|' exclusive_or_expression
    ;

logical_and_expression
    : inclusive_or_expression
    
| logical_and_expression AND_OP inclusive_or_expression
    ;

logical_or_expression
    : logical_and_expression
    
| logical_or_expression OR_OP logical_and_expression
    ;

conditional_expression
    : logical_or_expression
    
| logical_or_expression '?' expression ':' conditional_expression
    ;

assignment_expression
    : conditional_expression
    
| unary_expression assignment_operator assignment_expression
    ;

assignment_operator
    : 
'='
    
| MUL_ASSIGN
    
| DIV_ASSIGN
    
| MOD_ASSIGN
    
| ADD_ASSIGN
    
| SUB_ASSIGN
    
| LEFT_ASSIGN
    
| RIGHT_ASSIGN
    
| AND_ASSIGN
    
| XOR_ASSIGN
    
| OR_ASSIGN
    ;

expression
    : assignment_expression
    
| expression ',' assignment_expression
    ;

constant_expression
    : conditional_expression
    ;

declaration
    : declaration_specifiers 
';'
    
| declaration_specifiers init_declarator_list ';'
    ;

declaration_specifiers
    : storage_class_specifier
    
| storage_class_specifier declaration_specifiers
    
| type_specifier
    
| type_specifier declaration_specifiers
    
| type_qualifier
    
| type_qualifier declaration_specifiers
    ;

init_declarator_list
    : init_declarator
    
| init_declarator_list ',' init_declarator
    ;

init_declarator
    : declarator
    
| declarator '=' initializer
    ;

storage_class_specifier
    : TYPEDEF
    
| EXTERN
    
| STATIC
    
| AUTO
    
| REGISTER
    ;

type_specifier
    : VOID
    
| CHAR
    
| SHORT
    
| INT
    
| LONG
    
| FLOAT
    
| DOUBLE
    
| SIGNED
    
| UNSIGNED
    
| struct_or_union_specifier
    
| enum_specifier
    
| TYPE_NAME
    ;

struct_or_union_specifier
    : struct_or_union IDENTIFIER 
'{' struct_declaration_list '}'
    
| struct_or_union '{' struct_declaration_list '}'
    
| struct_or_union IDENTIFIER
    ;

struct_or_union
    : STRUCT
    
| UNION
    ;

struct_declaration_list
    : struct_declaration
    
| struct_declaration_list struct_declaration
    ;

struct_declaration
    : specifier_qualifier_list struct_declarator_list 
';'
    ;

specifier_qualifier_list
    : type_specifier specifier_qualifier_list
    
| type_specifier
    
| type_qualifier specifier_qualifier_list
    
| type_qualifier
    ;

struct_declarator_list
    : struct_declarator
    
| struct_declarator_list ',' struct_declarator
    ;

struct_declarator
    : declarator
    
| ':' constant_expression
    
| declarator ':' constant_expression
    ;

enum_specifier
    : ENUM 
'{' enumerator_list '}'
    
| ENUM IDENTIFIER '{' enumerator_list '}'
    
| ENUM IDENTIFIER
    ;

enumerator_list
    : enumerator
    
| enumerator_list ',' enumerator
    ;

enumerator
    : IDENTIFIER
    
| IDENTIFIER '=' constant_expression
    ;

type_qualifier
    : CONST
    
| VOLATILE
    ;

declarator
    : pointer direct_declarator
    
| direct_declarator
    ;

direct_declarator
    : IDENTIFIER
    
| '(' declarator ')'
    
| direct_declarator '[' constant_expression ']'
    
| direct_declarator '[' ']'
    
| direct_declarator '(' parameter_type_list ')'
    
| direct_declarator '(' identifier_list ')'
    
| direct_declarator '(' ')'
    ;

pointer
    : 
'*'
    
| '*' type_qualifier_list
    
| '*' pointer
    
| '*' type_qualifier_list pointer
    ;

type_qualifier_list
    : type_qualifier
    
| type_qualifier_list type_qualifier
    ;


parameter_type_list
    : parameter_list
    
| parameter_list ',' ELLIPSIS
    ;

parameter_list
    : parameter_declaration
    
| parameter_list ',' parameter_declaration
    ;

parameter_declaration
    : declaration_specifiers declarator
    
| declaration_specifiers abstract_declarator
    
| declaration_specifiers
    ;

identifier_list
    : IDENTIFIER
    
| identifier_list ',' IDENTIFIER
    ;

type_name
    : specifier_qualifier_list
    
| specifier_qualifier_list abstract_declarator
    ;

abstract_declarator
    : pointer
    
| direct_abstract_declarator
    
| pointer direct_abstract_declarator
    ;

direct_abstract_declarator
    : 
'(' abstract_declarator ')'
    
| '[' ']'
    
| '[' constant_expression ']'
    
| direct_abstract_declarator '[' ']'
    
| direct_abstract_declarator '[' constant_expression ']'
    
| '(' ')'
    
| '(' parameter_type_list ')'
    
| direct_abstract_declarator '(' ')'
    
| direct_abstract_declarator '(' parameter_type_list ')'
    ;

initializer
    : assignment_expression
    
| '{' initializer_list '}'
    
| '{' initializer_list ',' '}'
    ;

initializer_list
    : initializer
    
| initializer_list ',' initializer
    ;

statement
    : labeled_statement
    
| compound_statement
    
| expression_statement
    
| selection_statement
    
| iteration_statement
    
| jump_statement
    ;

labeled_statement
    : IDENTIFIER 
':' statement
    
| CASE constant_expression ':' statement
    
| DEFAULT ':' statement
    ;

compound_statement
    : 
'{' '}'
    
| '{' statement_list '}'
    
| '{' declaration_list '}'
    
| '{' declaration_list statement_list '}'
    ;

declaration_list
    : declaration
    
| declaration_list declaration
    ;

statement_list
    : statement
    
| statement_list statement
    ;

expression_statement
    : 
';'
    
| expression ';'
    ;

selection_statement
    : IF 
'(' expression ')' statement
    
| IF '(' expression ')' statement ELSE statement
    
| SWITCH '(' expression ')' statement
    ;

iteration_statement
    : WHILE 
'(' expression ')' statement
    
| DO statement WHILE '(' expression ')' ';'
    
| FOR '(' expression_statement expression_statement ')' statement
    
| FOR '(' expression_statement expression_statement expression ')' statement
    ;

jump_statement
    : GOTO IDENTIFIER 
';'
    
| CONTINUE ';'
    
| BREAK ';'
    
| RETURN ';'
    
| RETURN expression ';'
    ;

translation_unit
    : external_declaration
    
| translation_unit external_declaration
    ;

external_declaration
    : function_definition
    
| declaration
    ;

function_definition
    : declaration_specifiers declarator declaration_list compound_statement
    
| declaration_specifiers declarator compound_statement
    
| declarator declaration_list compound_statement
    
| declarator compound_statement
    ;

%%
#include 
<stdio.h>

extern char yytext[];
extern int column;

yyerror(s)
char *s;
{
    fflush(stdout);
    printf(
"\n%*s\n%*s\n", column, "^", column, s);
}



--
※ 来源:·瀚海星云 bbs.ustc.edu.cn·[FROM: 
61.191.193.133]

Powered by Jekyll and Theme by solid

本站总访问量