您的位置:网站首页 > 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"

  fi

  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[xX]{H}+{IS}? { count(); return(CONSTANT); }

  0{D}+{IS}? { count(); return(CONSTANT); }

  0{D}+{IS}? { count(); return(CONSTANT); }

  {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] != ''; i++)

  if (yytext[i] == ' ')

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

  }

  RogueMonster

  else

  echo "will not over write ./scan.l"

  fi

  if `test ! -s ./y.tab.h`

  then

  echo "writting ./y.tab.h"

  cat > ./y.tab.h << 'RogueMonster'

  # define IDENTIFIER 257

  # define CONSTANT 258

  # define STRING_LITERAL 259

  # define SIZEOF 260

  # define PTR_OP 261

  # define INC_OP 262

  # define DEC_OP 263

  # define LEFT_OP 264

  # define RIGHT_OP 265

  # define LE_OP 266

  # define GE_OP 267

  # define EQ_OP 268

  # define NE_OP 269

  # define AND_OP 270

  # define OR_OP 271

  # define MUL_ASSIGN 272

  # define DIV_ASSIGN 273

  # define MOD_ASSIGN 274

  # define ADD_ASSIGN 275

  # define SUB_ASSIGN 276

  # define LEFT_ASSIGN 277

  # define RIGHT_ASSIGN 278

  # define AND_ASSIGN 279

  # define XOR_ASSIGN 280

  # define OR_ASSIGN 281

  # define TYPE_NAME 282

  # define TYPEDEF 283

  # define EXTERN 284

  # define STATIC 285

  # define AUTO 286

  # define REGISTER 287

  # define CHAR 288