您的位置：網站首頁 > CAM

C編譯器LEX及YACC輸入源文件介紹

時間:2011-03-01 09:39:08 來源:

　　本文介紹了C編譯器LEX及YACC輸入源文件相關內容。

　　/*YACC--LALR(1) PARSER*/

　　%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 ELIPSIS RANGE

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

　　%start file

　　primary_expr

　　: identifier

　　| CONSTANT

　　| STRING_LITERAL

　　| '(' expr ')'

　　;

　　postfix_expr

　　: primary_expr

　　| postfix_expr '[' expr ']'

　　| postfix_expr '(' ')'

　　| postfix_expr '(' argument_expr_list ')'

　　| postfix_expr '.' identifier

　　| postfix_expr PTR_OP identifier

　　| postfix_expr INC_OP

　　| postfix_expr DEC_OP

　　;

　　argument_expr_list

　　: assignment_expr

　　| argument_expr_list ',' assignment_expr

　　;

　　unary_expr

　　: postfix_expr

　　| INC_OP unary_expr

　　| DEC_OP unary_expr

　　| unary_operator cast_expr

　　| SIZEOF unary_expr

　　| SIZEOF '(' type_name ')'

　　;

　　unary_operator

　　: '&'

　　| '*'

　　| '+'

　　| '-'

　　| '~'

　　| '!'

　　;

　　cast_expr

　　: unary_expr

　　| '(' type_name ')' cast_expr

　　;

　　multiplicative_expr

　　: cast_expr

　　| multiplicative_expr '*' cast_expr

　　| multiplicative_expr '/' cast_expr

　　| multiplicative_expr '%' cast_expr

　　additive_expr

　　: multiplicative_expr

　　| additive_expr '+' multiplicative_expr

　　| additive_expr '-' multiplicative_expr

　　;

　　shift_expr

　　: additive_expr

　　| shift_expr LEFT_OP additive_expr

　　| shift_expr RIGHT_OP additive_expr

　　;

　　relational_expr

　　: shift_expr

　　| relational_expr '<' shift_expr

　　| relational_expr '>' shift_expr

　　| relational_expr LE_OP shift_expr

　　| relational_expr GE_OP shift_expr

　　;

　　equality_expr

　　: relational_expr

　　| equality_expr EQ_OP relational_expr

　　| equality_expr NE_OP relational_expr

　　;

　　and_expr

　　: equality_expr

　　| and_expr '&' equality_expr

　　;

　　exclusive_or_expr

　　: and_expr

　　| exclusive_or_expr '^' and_expr

　　;

　　inclusive_or_expr

　　: exclusive_or_expr

　　| inclusive_or_expr '|' exclusive_or_expr

　　;

　　logical_and_expr

　　: inclusive_or_expr

　　| logical_and_expr AND_OP inclusive_or_expr

　　;

　　logical_or_expr

　　: logical_and_expr

　　| logical_or_expr OR_OP logical_and_expr

　　;

　　conditional_expr

　　: logical_or_expr

　　| logical_or_expr '?' logical_or_expr ':' conditional_expr

　　;

　　assignment_expr

　　: conditional_expr

　　| unary_expr assignment_operator assignment_expr

　　;

　　assignment_operator

　　: '='

　　| MUL_ASSIGN

　　| DIV_ASSIGN

　　| MOD_ASSIGN

　　| ADD_ASSIGN

　　| SUB_ASSIGN

　　| LEFT_ASSIGN

　　| RIGHT_ASSIGN

　　| AND_ASSIGN

　　| XOR_ASSIGN

　　| OR_ASSIGN

　　;

　　expr

　　: assignment_expr

　　| expr ',' assignment_expr

　　;

　　constant_expr

　　: conditional_expr

　　;

　　declaration

　　: declaration_specifiers ';'

　　| declaration_specifiers init_declarator_list ';'

　　;

　　declaration_specifiers

　　: storage_class_specifier

　　| storage_class_specifier declaration_specifiers

　　| type_specifier

　　| type_specifier 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

　　: CHAR

　　| SHORT

　　| INT

　　| LONG

　　| SIGNED

　　| UNSIGNED

　　| FLOAT

　　| DOUBLE

　　| CONST

　　| VOLATILE

　　| VOID

　　| 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

　　: type_specifier_list struct_declarator_list ';'

　　;

　　struct_declarator_list

　　: struct_declarator

　　| struct_declarator_list ',' struct_declarator

　　;

　　struct_declarator

　　: declarator

　　| ':' constant_expr

　　| declarator ':' constant_expr

　　;

　　enum_specifier

　　: ENUM '{' enumerator_list '}'

　　| ENUM identifier '{' enumerator_list '}'

　　| ENUM identifier

　　;

　　enumerator_list

　　: enumerator

　　| enumerator_list ',' enumerator

　　;

　　enumerator

　　: identifier

　　| identifier '=' constant_expr

　　;

　　declarator

　　: declarator2

　　| pointer declarator2

　　;

　　declarator2

　　: identifier

　　| '(' declarator ')'

　　| declarator2 '[' ']'

　　| declarator2 '[' constant_expr ']'

　　| declarator2 '(' ')'

　　| declarator2 '(' parameter_type_list ')'

　　| declarator2 '(' parameter_identifier_list ')'

　　;

　　pointer

　　: '*'

　　| '*' type_specifier_list

　　| '*' pointer

　　| '*' type_specifier_list pointer

　　;

　　type_specifier_list

　　: type_specifier

　　| type_specifier_list type_specifier

　　;

　　parameter_identifier_list

　　: identifier_list

　　| identifier_list ',' ELIPSIS

　　;

　　identifier_list

　　: identifier

　　| identifier_list ',' identifier

　　;

　　parameter_type_list

　　: parameter_list

　　| parameter_list ',' ELIPSIS

　　;

　　parameter_list

　　: parameter_declaration

　　| parameter_list ',' parameter_declaration

　　;

　　parameter_declaration

　　: type_specifier_list declarator

　　| type_name

　　;

　　type_name

　　: type_specifier_list

　　| type_specifier_list abstract_declarator

　　;

　　abstract_declarator

　　: pointer

　　| abstract_declarator2

　　| pointer abstract_declarator2

　　;

　　abstract_declarator2

　　: '(' abstract_declarator ')'

　　| '[' ']'

　　| '[' constant_expr ']'

　　| abstract_declarator2 '[' ']'

　　| abstract_declarator2 '[' constant_expr ']'

　　| '(' ')'

　　| '(' parameter_type_list ')'

　　| abstract_declarator2 '(' ')'

　　| abstract_declarator2 '(' parameter_type_list ')'

　　;

　　initializer

　　: assignment_expr

　　| '{' 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_expr ':' 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

　　: ';'

　　| expr ';'

　　;

　　selection_statement

　　: IF '(' expr ')' statement

　　| IF '(' expr ')' statement ELSE statement

　　| SWITCH '(' expr ')' statement

　　;

　　iteration_statement

　　: WHILE '(' expr ')' statement

　　| DO statement WHILE '(' expr ')' ';'

　　| FOR '(' ';' ';' ')' statement

　　| FOR '(' ';' ';' expr ')' statement

　　| FOR '(' ';' expr ';' ')' statement

　　| FOR '(' ';' expr ';' expr ')' statement

　　| FOR '(' expr ';' ';' ')' statement

　　| FOR '(' expr ';' ';' expr ')' statement

　　| FOR '(' expr ';' expr ';' ')' statement

　　| FOR '(' expr ';' expr ';' expr ')' statement

　　;

　　jump_statement

　　: GOTO identifier ';'

　　| CONTINUE ';'

　　| BREAK ';'

　　| RETURN ';'

　　| RETURN expr ';'

　　;

　　file

　　: external_definition

　　| file external_definition

　　;

　　external_definition

　　: function_definition

　　| declaration

　　;

　　function_definition

　　: declarator function_body

　　| declaration_specifiers declarator function_body

　　;

　　function_body

　　: compound_statement

　　| declaration_list compound_statement

　　;

　　identifier

　　: IDENTIFIER

　　;

　　#include

　　extern char yytext[];

　　extern int column;

　　yyerror(s)

　　char *s;

　　{

　　fflush(stdout);

　　printf(" %*s %*s ", column, "^", column, s);

　　}

　　main()

　　{

　　int yyparse();

　　return(yyparse());

　　}

　　RogueMonster

　　else

　　echo "will not over write ./main.c"

　　if `test ! -s ./scan.l`

　　then

　　echo "writting ./scan.l"

　　cat > ./scan.l << 'RogueMonster'

　　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

　　#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); }

　　'(\.|[^\'])+' { count(); return(CONSTANT); }

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

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

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

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

　　">>=" { 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('?'); }

　　[ tv 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] != '