各位，现急需一c程序，有意者，还来看看啊1

各位大虾，现急需一c程序，有意者，还来看看啊！！！！1
我们让学一个c语言语法分析程序，语言不限，但最好用c语言来实现！！！！！！

[解决办法]
http://dev.21tx.com/2005/05/12/15870.html
[解决办法]
没下文了啊?
没看明白什么
[解决办法]
Lex & Yacc
再加上C语言
我正在用这个做assembler
[解决办法]
ANSI C grammar, Lex specification
In 1985, Jeff Lee published this Lex specification together with a Yacc grammar for the April 30, 1985 ANSI C draft. Tom Stockfisch reposted both to net.sources in 1987; that original, as mentioned in the answer to question 17.25 of the comp.lang.c FAQ, can be ftp 'ed from ftp.uu.net, file usenet/net.sources/ansi.c.grammar.Z.
I intend to keep this version as close to the current C Standard grammar as possible; please let me know if you discover discrepancies.

Jutta Degener, 1995

--------------------------------------------

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); }
'(\\.|[^\\ '])+ '{ 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(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);
}

[解决办法]

ANSI C Yacc grammar
In 1985, Jeff Lee published his Yacc grammar (which is accompanied by a matching Lex specification) for the April 30, 1985 draft version of the ANSI C standard. Tom Stockfisch reposted it to net.sources in 1987; that original, as mentioned in the answer to question 17.25 of the comp.lang.c FAQ, can be ftp 'ed from ftp.uu.net, file usenet/net.sources/ansi.c.grammar.Z.
I intend to keep this version as close to the current C Standard grammar as possible; please let me know if you discover discrepancies.

Jutta Degener, 1995

--------------------------------------------

%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

各位现急需一c程序有意者还来看

热点推荐