分享好友 数控技术首页 数控技术分类 切换频道

C编译器LEX和YACC输入源文件

2019-07-03 00:00440

C编译器LEX和YACC输入源文件。

%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 unio 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_unio_specifier
 | enum_specifier
 | TYPE_NAME
 ;

struct_or_unio_specifier
 : struct_or_unio identifier { struct_declaration_list }
 | struct_or_unio { struct_declaration_list }
 | struct_or_unio identifier
 ;

struct_or_unio
 : STRUCT
 | unio
 ;

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 <stdio.h>

extern char yytext[];
extern int column;

yyerror(s)
char *s;
{
 fflush(stdout);
 printf("n%*sn%*sn", 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 <stdio.h>
#include "y.tab.h"

void count();
%}

%%
" }

%%

yywrap()
{
 return(1);
}

comment()
{
 char c, c1;

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

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

 if (c != 0)
  putcha(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()
{

 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
# define SHORT 289
# define INT 290
# define LONG 291
# define SIGNED 292
# define UNSIGNED 293
# define FLOAT 294
# define DOUBLE 295
# define ConST 296
# define VOLATILE 297
# define VOID 298
# define STRUCT 299
# define unio 300
# define ENUM 301
# define ELIPSIS 302
# define RANGE 303
# define CASE 304
# define DEFAULT 305
# define IF 306
# define ELSE 307
# define SWITCH 308
# define WHILE 309
# define DO 310
# define FOR 311
# define GOTO 312
# define ConTINUE 313
# define BREAK 314
# define RETURN 315
RogueMonster
else
  echo "will not over write ./y.tab.h"
fi
echo "Finished archive 1 of 1"
exit

|| Tom Stockfisch, UCSD Chemistry tps%chem@sdcsvax.UCSD

举报
收藏 0
打赏 0
轻松提高数控机床精度
随着我国经济的飞速发展，数控机床作为新一代工作母机，在机械制造中已得到广泛的应用，精密加工技术的迅速发展和零件加工精度的

0评论2025-01-04312

加工中心刀具长度补偿怎么用？
在数控加工中，刀具长度补偿是一种重要的措施，用于消除机床变形、热变形等因素引起的误差，保证加工精度，从而提高培训效率，减

0评论2024-12-18400

加工中心主轴定位角度怎么调？
　　在数控加工领域，加工中心主轴的定位角度是影响加工精度和效率的重要因素之一。正确调整主轴的定位角度可以提高加工质量，减

0评论2024-12-11496

简述机器人加装电主轴就选Kasite 4060ER-S的理由
　　近年来，随着科技的不断发展，机器人作业已经渗透到各个领域，尤其在工业制造领域，更加随处可见。高精密切割、铣削、雕刻、

0评论2024-05-20707

机器人主轴怎么选?Kasite高速电主轴满足你的需求
　　机器人发展到现在越来越受到人们的欢迎和重视，现在很多传统行业都在生产作业中引入了工业机器人，随着机器人的改进和优化，

0评论2023-10-231208

机械臂加装2.2KW大力矩电主轴，就选MSIY-80电主轴
机械臂想加装大力矩电主轴，用于铸钢等硬质材料去毛刺，铣削等加工，可以考虑MSIY-80电主轴，外径80mm，重量4.8公斤，可搭配轴向或径向浮动刀柄配套使用。

0评论2023-08-261203

每天早上打开数控机床时有没有必要热机？
工厂使用精密数控机床（加工中心、电火花、慢走丝等机床）进行高精密加工，你是否有这样的经验：每天早上开机进行加工，首件的加

0评论2023-08-151093