c语法.c

语言的语法,格式严紧,对于处理yacc,lex有帮助!

X 
Xparameter_type_list 
X : parameter_list 
X | parameter_list ',' ELIPSIS 
X ; 
X 
Xparameter_list 
X : parameter_declaration 
X | parameter_list ',' parameter_declaration 
X ; 
X 
Xparameter_declaration 
X : type_specifier_list declarator 
X | type_name 
X ; 
X 
Xtype_name 
X : type_specifier_list 
X | type_specifier_list abstract_declarator 
X ; 
X 
Xabstract_declarator 
X : pointer 
X | abstract_declarator2 
X | pointer abstract_declarator2 
X ; 
X 
Xabstract_declarator2 
X : '(' abstract_declarator ')' 
X | '[' ']' 
X | '[' constant_expr ']' 
X | abstract_declarator2 '[' ']' 
X | abstract_declarator2 '[' constant_expr ']' 
X | '(' ')' 
X | '(' parameter_type_list ')' 
X | abstract_declarator2 '(' ')' 
X | abstract_declarator2 '(' parameter_type_list ')' 
X ; 
X 
Xinitializer 
X : assignment_expr 
X | '{' initializer_list '}' 
X | '{' initializer_list ',' '}' 
X ; 
X 
Xinitializer_list 
X : initializer 
X | initializer_list ',' initializer 
X ; 
X 
Xstatement 
X : labeled_statement 
X | compound_statement 
X | expression_statement 
X | selection_statement 
X | iteration_statement 
X | jump_statement 
X ; 
X 
Xlabeled_statement 
X : identifier ':' statement 
X | CASE constant_expr ':' statement 
X | DEFAULT ':' statement 
X ; 
X 
Xcompound_statement 
X : '{' '}' 
X | '{' statement_list '}' 
X | '{' declaration_list '}' 
X | '{' declaration_list statement_list '}' 
X ; 
X 
Xdeclaration_list 
X : declaration 
X | declaration_list declaration 
X ; 
X 
Xstatement_list 
X : statement 
X | statement_list statement 
X ; 
X 
Xexpression_statement 
X : ';' 
X | expr ';' 
X ; 
X 
Xselection_statement 
X : IF '(' expr ')' statement 
X | IF '(' expr ')' statement ELSE statement 
X | SWITCH '(' expr ')' statement 
X ; 
X 
Xiteration_statement 
X : WHILE '(' expr ')' statement 
X | DO statement WHILE '(' expr ')' ';' 
X | FOR '(' ';' ';' ')' statement 
X | FOR '(' ';' ';' expr ')' statement 
X | FOR '(' ';' expr ';' ')' statement 
X | FOR '(' ';' expr ';' expr ')' statement 
X | FOR '(' expr ';' ';' ')' statement 
X | FOR '(' expr ';' ';' expr ')' statement 
X | FOR '(' expr ';' expr ';' ')' statement 
X | FOR '(' expr ';' expr ';' expr ')' statement 
X ; 
X 
Xjump_statement 
X : GOTO identifier ';' 
X | CONTINUE ';' 
X | BREAK ';' 
X | RETURN ';' 
X | RETURN expr ';' 
X ; 
X 
Xfile 
X : external_definition 
X | file external_definition 
X ; 
X 
Xexternal_definition 
X : function_definition 
X | declaration 
X ; 
X 
Xfunction_definition 
X : declarator function_body 
X | declaration_specifiers declarator function_body 
X ; 
X 
Xfunction_body 
X : compound_statement 
X | declaration_list compound_statement 
X ; 
X 
Xidentifier 
X : IDENTIFIER 
X ; 
X%% 
X 
X#include <stdio.h> 
X 
Xextern char yytext[]; 
Xextern int column; 
X 
Xyyerror(s) 
Xchar *s; 
X{ 
X fflush(stdout); 
X printf("\n%*s\n%*s\n", column, "^", column, s); 
X} 
SHAR_EOF 
chmod 0644 gram.y || echo "restore of gram.y fails" 
echo "x - extracting main.c (Text)" 
sed 's/^X//' << 'SHAR_EOF' > main.c && 
Xmain() 
X{ 
X int yyparse(); 
X 
X return(yyparse()); 
X} 
SHAR_EOF 
chmod 0644 main.c || echo "restore of main.c fails" 
echo "x - extracting scan.l (Text)" 
sed 's/^X//' << 'SHAR_EOF' > scan.l && 
XD   [0-9] 
XL   [a-zA-Z_] 
XH   [a-fA-F0-9] 
XE   [Ee][+-]?{D}+ 
XFS   (f|F|l|L) 
XIS   (u|U|l|L)* 
X 
X%{ 
X#include <stdio.h> 
X#include "y.tab.h" 
X 
Xvoid count(); 
X%} 
X 
X%% 
X"/*"   { comment(); } 
X 
X"auto"   { count(); return(AUTO); } 
X"break"   { count(); return(BREAK); } 
X"case"   { count(); return(CASE); } 
X"char"   { count(); return(CHAR); } 
X"const"   { count(); return(CONST); } 
X"continue"  { count(); return(CONTINUE); } 
X"default"  { count(); return(DEFAULT); } 
X"do"   { count(); return(DO); } 
X"double"  { count(); return(DOUBLE); } 
X"else"   { count(); return(ELSE); } 
X"enum"   { count(); return(ENUM); } 
X"extern"  { count(); return(EXTERN); } 
X"float"   { count(); return(FLOAT); } 
X"for"   { count(); return(FOR); } 
X"goto"   { count(); return(GOTO); } 
X"if"   { count(); return(IF); } 
X"int"   { count(); return(INT); } 
X"long"   { count(); return(LONG); } 
X"register"  { count(); return(REGISTER); } 
X"return"  { count(); return(RETURN); } 
X"short"   { count(); return(SHORT); } 
X"signed"  { count(); return(SIGNED); } 
X"sizeof"  { count(); return(SIZEOF); } 
X"static"  { count(); return(STATIC); } 
X"struct"  { count(); return(STRUCT); } 
X"switch"  { count(); return(SWITCH); } 
X"typedef"  { count(); return(TYPEDEF); } 
X"union"   { count(); return(UNION); } 
X"unsigned"  { count(); return(UNSIGNED); } 
X"void"   { count(); return(VOID); } 
X"volatile"  { count(); return(VOLATILE); } 
X"while"   { count(); return(WHILE); } 
X 
X{L}({L}|{D})*  { count(); return(check_type()); } 
X 
X0[xX]{H}+{IS}?  { count(); return(CONSTANT); } 
X0[xX]{H}+{IS}?  { count(); return(CONSTANT); } 
X0{D}+{IS}?  { count(); return(CONSTANT); } 
X0{D}+{IS}?  { count(); return(CONSTANT); } 
X{D}+{IS}?  { count(); return(CONSTANT); } 
X{D}+{IS}?  { count(); return(CONSTANT); } 
X'(\\.|[^\\'])+'  { count(); return(CONSTANT); } 
X 
X{D}+{E}{FS}?  { count(); return(CONSTANT); } 
X{D}*"."{D}+({E})?{FS}? { count(); return(CONSTANT); } 
X{D}+"."{D}*({E})?{FS}? { count(); return(CONSTANT); } 
X 
X\"(\\.|[^\\"])*\" { count(); return(STRING_LITERAL); } 
X 
X">>="   { count(); return(RIGHT_ASSIGN); } 
X"<<="   { count(); return(LEFT_ASSIGN); } 
X"+="   { count(); return(ADD_ASSIGN); } 
X"-="   { count(); return(SUB_ASSIGN); } 
X"*="   { count(); return(MUL_ASSIGN); } 
X"/="   { count(); return(DIV_ASSIGN); } 
X"%="   { count(); return(MOD_ASSIGN); } 
X"&="   { count(); return(AND_ASSIGN); } 
X"^="   { count(); return(XOR_ASSIGN); } 
X"|="   { count(); return(OR_ASSIGN); } 
X">>"   { count(); return(RIGHT_OP); } 
X"<<"   { count(); return(LEFT_OP); } 
X"++"   { count(); return(INC_OP); } 
X"--"   { count(); return(DEC_OP); } 
X"->"   { count(); return(PTR_OP); } 
X"&&"   { count(); return(AND_OP); } 
X"||"   { count(); return(OR_OP); } 
X"<="   { count(); return(LE_OP); } 
X">="   { count(); return(GE_OP); } 
X"=="   { count(); return(EQ_OP); } 
X"!="   { count(); return(NE_OP); } 
X";"   { count(); return(';'); } 
X"{"   { count(); return('{'); } 
X"}"   { count(); return('}'); } 
X","   { count(); return(','); } 
X":"   { count(); return(':'); } 
X"="   { count(); return('='); } 
X"("   { count(); return('('); } 
X")"   { count(); return(')'); } 
X"["   { count(); return('['); } 
X"]"   { count(); return(']'); } 
X"."   { count(); return('.'); } 
X"&"   { count(); return('&'); } 
X"!"   { count(); return('!'); } 
X"~"   { count(); return('~'); } 
X"-"   { count(); return('-'); } 
X"+"   { count(); return('+'); } 
X"*"   { count(); return('*'); } 
X"/"   { count(); return('/'); } 
X"%"   { count(); return('%'); } 
X"<"   { count(); return('<'); } 
X">"   { count(); return('>'); } 
X"^"   { count(); return('^'); } 
X"|"   { count(); return('|'); } 
X"?"   { count(); return('?'); } 
X 
X[ \t\v\n\f]  { count(); } 
X.   { /* ignore bad characters */ } 
X 
X%% 
X 
Xyywrap() 
X{ 
X return(1); 
X} 
X 
Xcomment() 
X{ 
X char c, c1; 
X 
Xloop: 
X while ((c = input()) != '*' && c != 0) 
X  putchar(c); 
X 
X if ((c1 = input()) != '/' && c != 0) 
X { 
X  unput(c1); 
X  goto loop; 
X } 
X 
X if (c != 0) 
X  putchar(c1); 
X} 
X 
Xint column = 0; 
X 
Xvoid count() 
X{ 
X int i; 
X 
X for (i = 0; yytext[i] != '\0'; i++) 
X  if (yytext[i] == '\n') 
X   column = 0; 
X  else if (yytext[i] == '\t') 
X   column += 8 - (column % 8); 
X  else 
X   column++; 
X 
X ECHO; 
X} 
X 
Xint check_type() 
X{ 
X/* 
X* pseudo code --- this is what it should check 
X* 
X* if (yytext == type_name) 
X*  return(TYPE_NAME); 
X* 
X* return(IDENTIFIER); 
X*/ 
X 

X/* 
X* it actually will only return IDENTIFIER 
X*/ 
X 
X return(IDENTIFIER); 
X} 
SHAR_EOF 
chmod 0644 scan.l || echo "restore of scan.l fails" 
exit 0 
  
-- 
We work in the dark 
We do what we can 
We give what we have 
Our doubt is our passion, and our passion is our task 
The rest is the madness of art.