开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 汇编语言 > 查看源码
parse.y
资源名称：C语言编译器.rar　[点击查看]
上传用户：wqdrylgs
上传日期：2007-02-09
资源大小：65k
文件大小：12k
源码类别：

汇编语言

开发平台：

WINDOWS

parse.y：源码内容
  1. %{
  2. #define YYPARSER /* distinguishes Yacc output from other code files */
  4. #include "globals.h"
  5. #include "util.h"
  6. #include "scan.h"
  7. #include "parse.h"
  10. static char * savedFunName; /* for use in assignments */
  11. static char * savedIdName;
  12. static int savedLineNo;  /* ditto */
  13. static TreeNode * savedTree; /* stores syntax tree for later return */
  15. %}
  17. %token ENDFILE ERROR 
  18. %token INT CHAR FLOAT IF ELSE WHILE VOID RETURN BREAK CONTINUE
  19. %token ID NUM FNUM SCHAR
  20. %token PLUS SUB MUT DIV LT LE GT GE EQ NEQ AND OR NOT ASSIGN SEMI COMMA LP RP LSP RSP LFP RFP 
  23. %union { TreeNode * ptree;
  24.          Type type; 
  25.        }
  26.        
  27. %type <ptree> program dec_list dec var_dec fun_dec fun_def params param_list param comp_stmt local_dec stmt_list stmt 
  28.               exp_stmt sele_stmt iter_stmt return_stmt exp var simple_exp factor call args arg_list
  29.               id_list 
  30. %type <type> type_spec
  32. %left COMMA
  33. %right ASSIGN
  34. %left OR    
  35. %left AND
  36. %left EQ NEQ
  37. %left LT LE GT GE
  38. %left PLUS SUB
  39. %left MUT DIV
  40. %left LP RP LSP RSP LFP RFP
  42. %right ELSE
  44. %include {
  45.     void yyerror(const char * message);
  46. TreeNode * parse(void);
  47. }
  49. %% /* Grammar for C_minus */
  51. program     : dec_list
  52.                  { savedTree = $1;} 
  53.             ;
  54. dec_list    : dec_list dec
  55. { TreeNode * t = $1;
  56.   if (t != NULL)
  57.   { while (t->sibling != NULL)
  58. t = t->sibling;
  59. t->sibling = $2;
  60. $$ = $1; }
  61.   else $$ = $2;
  62. }                  
  63.             | dec  
  64.                 { $$ = $1; }
  65.             ;
  66. dec         : var_dec { $$ = $1; }
  67.             | fun_dec { $$ = $1; }
  68.             | fun_def   { $$ = $1; }
  69.             ;
  70. id          : ID { savedIdName = copyString(tokenString); }
  71.             ;
  72. fid         : { savedFunName = savedIdName; }
  73.             ;
  74. var_dec     : type_spec id_list SEMI
  75. { if($1 == Void)
  76.   ;
  77.   // err
  78.   else
  79.     {
  80.   $$ = newDecNode(VarK); 
  81.   $$ -> type = $1;
  82.   $$ -> child[0] = $2;
  83. }
  84. } 
  85.             ;
  86. id_list     : id_list COMMA var
  87.                 { 
  88.                   TreeNode * t = $1;
  89.   if (t != NULL)
  90.   { while (t->sibling != NULL)
  91. t = t->sibling;
  92. t->sibling = $3;
  93. $$ = $1; }
  94.   else $$ = $3;
  95.                 } // i,str[5],j
  96.             | var { $$ = $1; }
  97.             | id_list COMMA id ASSIGN simple_exp
  98.               { 
  99.   TreeNode * new_node = newStmtNode(AssignK);
  100.   TreeNode * t = $1;
  101.   if (t != NULL)
  102.   { while (t->sibling != NULL)
  103. t = t->sibling;
  104. t->sibling = new_node;
  105. $$ = $1; }
  106.   else $$ = new_node;
  107.               }
  108.             | id ASSIGN simple_exp
  109.               { 
  110.  $$ = newStmtNode(AssignK);
  111.  $$ -> child[0] = newExpNode(IdK);
  112.  $$ -> child[0] -> attr.name = savedIdName;
  113.  $$ -> child[1] = $3;
  114.               }
  115.             ; 
  116. type_spec   : INT { $$ = Integer; }         
  117.             | FLOAT { $$ = Float; }         
  118.             | CHAR { $$ = Char; }         
  119.             | VOID { $$ = Void; }         
  120.             ;
  121. fun_def     : type_spec id fid LP params RP comp_stmt 
  122. { $$ = newDecNode(FunDefK);
  123.   $$ -> attr.name = savedFunName;
  124.   $$ -> type = $1;
  125.   $$ -> child[0] = $5;
  126.   $$ -> child[1] = $7; 
  127. }
  128.             | id fid LP params RP comp_stmt
  129. { $$ = newDecNode(FunDefK);
  130.   $$ -> attr.name = savedFunName;
  131.   $$ -> type = Void;
  132.   $$ -> child[0] = $4;
  133.   $$ -> child[1] = $6; 
  134. }
  135.             ;
  136. fun_dec     : type_spec id fid LP params RP SEMI
  137. { $$ = newDecNode(FunDecK);
  138.   $$ -> attr.name = savedFunName;
  139.   $$ -> type = $1;
  140.   $$ -> child[0] = $5;
  141.   $$ -> child[1] = NULL;
  142. }
  143. | id fid LP params RP SEMI
  144. { $$ = newDecNode(FunDecK);
  145.   $$ -> attr.name = savedFunName;
  146.   $$ -> type = Void;
  147.   $$ -> child[0] = $4;
  148.   $$ -> child[1] = NULL;
  149. }
  150.             ;             
  151. params      : param_list
  152.                 { $$ = $1; }
  153.             | 
  154. { $$ = NULL; }
  155.             ;         
  156. param_list  : param_list COMMA param
  157.              { TreeNode * t = $1;
  158.   if (t != NULL)
  159.   { while (t->sibling != NULL)
  160. t = t->sibling;
  161. t->sibling = $3;
  162. $$ = $1; }
  163.   else $$ = $3;
  164. }                  
  165.             | param
  166.                 { $$ = $1; }
  167.             ;
  168. param       : type_spec 
  169.                 { $$ = newDecNode(ParamK);
  170.                   $$ -> type = $1;
  171.                 }            
  172. | type_spec id
  173.                 { $$ = newDecNode(ParamK);
  174.                   $$ -> type = $1;
  175.                   $$ -> attr.name = savedIdName;
  176.                 }            
  177.             | type_spec id LSP RSP
  178.                 { $$ = newDecNode(ParamK);
  179.                   $$ -> type = $1;
  180.                   $$ -> attr.name = savedIdName;
  181.                 }            
  182.             | type_spec id LSP simple_exp RSP
  183.                 { $$ = newDecNode(ParamK);
  184.                   $$ -> type = $1;
  185.                   $$ -> attr.name = savedIdName;
  186.                   $$ -> child[0] = $4;
  187.                 }            
  188.             ;
  189. comp_stmt   : LFP local_dec stmt_list RFP
  190.                 { $$ = newDecNode(CompK);
  191.                   $$ -> child[0] = $2;
  192.                   $$ -> child[1] = $3;
  193.                 }            
  194.             ;
  195. local_dec   : local_dec var_dec            
  196.              { TreeNode * t = $1;
  197.   if (t != NULL)
  198.   { while (t->sibling != NULL)
  199. t = t->sibling;
  200. t->sibling = $2;
  201. $$ = $1; }
  202.   else $$ = $2;
  203. }                  
  204.             | 
  205.                 { $$ = NULL; }
  206.             ;
  207. stmt_list   : stmt_list stmt            
  208.              { TreeNode * t = $1;
  209.   if (t != NULL)
  210.   { while (t->sibling != NULL)
  211. t = t->sibling;
  212. t->sibling = $2;
  213. $$ = $1; }
  214.   else $$ = $2;
  215. }                  
  216.             | 
  217.                 { $$ = NULL; }
  218.             ;
  219. stmt        : exp_stmt { $$ = $1; }            
  220.             | sele_stmt { $$ = $1; }
  221.             | iter_stmt { $$ = $1; }
  222.             | return_stmt { $$ = $1; }
  223.             | comp_stmt { $$ = $1; }
  224.             | CONTINUE SEMI { $$ = newStmtNode(ContinueK); }
  225.             | BREAK SEMI    { $$ = newStmtNode(BreakK); }
  226.             ;
  227. exp_stmt    : exp SEMI
  228.                 { $$ = $1; }
  229.             | SEMI
  230.                 { $$ = NULL; }            
  231.             ;
  232. sele_stmt   : IF LP exp RP stmt %prec ELSE
  233.                 { $$ = newStmtNode(IfK);
  234.                   $$ -> child[0] = $3;
  235.                   $$ -> child[1] = $5;
  236.                 }            
  237.             | IF LP exp RP stmt ELSE stmt
  238.                 { $$ = newStmtNode(IfK);
  239.                   $$ -> child[0] = $3;
  240.                   $$ -> child[1] = $5;
  241.   $$ -> child[2] = $7;
  242.                 }
  243.             ;
  244. iter_stmt   : WHILE LP exp RP stmt
  245. { $$ = newStmtNode(WhileK);
  246.                   $$ -> child[0] = $3;
  247.                   $$ -> child[1] = $5;
  248.                 }            
  249.             ;    
  250. return_stmt : RETURN SEMI
  251.                 { $$ = newStmtNode(ReturnK);
  252.                   $$ -> child[0] = NULL;
  253.                 }
  254.             | RETURN exp SEMI
  255.                 { $$ = newStmtNode(ReturnK);
  256.                   $$ -> child[0] = $2;
  257.                 }
  258.             ;                   
  259. exp         : var ASSIGN exp
  260.                 { $$ = newStmtNode(AssignK);
  261.                   $$ -> child[0] = $1;
  262.                   $$ -> child[1] = $3;
  263.                 }
  264.             | simple_exp
  265.                 { $$ = $1; }
  266.             ;
  267. var         : id
  268.                 { $$ = newExpNode(IdK);
  269.                   $$ -> attr.name = savedIdName;
  270.                 }            
  271.             | id LSP simple_exp RSP
  272. { $$ = newExpNode(IdK);
  273.   $$ -> attr.name = savedIdName;
  274.                   $$ -> child[0] = $3;
  275.                 }           
  276.             ;
  277. simple_exp : simple_exp OR simple_exp 
  278. { $$ = newExpNode(OpK);
  279.   $$ -> child[0] = $1;
  280.   $$ -> child[1] = $3;
  281.   $$ -> attr.op = OR;
  282. }
  283. |simple_exp AND simple_exp 
  284. { $$ = newExpNode(OpK);
  285.   $$ -> child[0] = $1;
  286.   $$ -> child[1] = $3;
  287.   $$ -> attr.op = AND;
  288. }
  289. |simple_exp LT simple_exp 
  290. { $$ = newExpNode(OpK);
  291.   $$ -> child[0] = $1;
  292.   $$ -> child[1] = $3;
  293.   $$ -> attr.op = LT;
  294.   $$ -> type = Boolean;
  295. }
  296. |simple_exp LE simple_exp 
  297. { $$ = newExpNode(OpK);
  298.   $$ -> child[0] = $1;
  299.   $$ -> child[1] = $3;
  300.   $$ -> attr.op = LE;
  301.   $$ -> type = Boolean;
  302. }
  303. |simple_exp GT simple_exp 
  304. { $$ = newExpNode(OpK);
  305.   $$ -> child[0] = $1;
  306.   $$ -> child[1] = $3;
  307.   $$ -> attr.op = GT;
  308.   $$ -> type = Boolean;
  309. }
  310. |simple_exp GE simple_exp 
  311. { $$ = newExpNode(OpK);
  312.   $$ -> child[0] = $1;
  313.   $$ -> child[1] = $3;
  314.   $$ -> attr.op = GE;
  315.   $$ -> type = Boolean;
  316. }
  317. |simple_exp EQ simple_exp 
  318. { $$ = newExpNode(OpK);
  319.   $$ -> child[0] = $1;
  320.   $$ -> child[1] = $3;
  321.   $$ -> attr.op = EQ;
  322.   $$ -> type = Boolean;
  323. }
  324. |simple_exp NEQ simple_exp 
  325. { $$ = newExpNode(OpK);
  326.   $$ -> child[0] = $1;
  327.   $$ -> child[1] = $3;
  328.   $$ -> attr.op = NEQ;
  329.   $$ -> type = Boolean;
  330. }
  331. |simple_exp PLUS simple_exp 
  332. { $$ = newExpNode(OpK);
  333.   $$ -> child[0] = $1;
  334.   $$ -> child[1] = $3;
  335.   $$ -> attr.op = PLUS;
  336. }
  337. |simple_exp SUB simple_exp 
  338. { $$ = newExpNode(OpK);
  339.   $$ -> child[0] = $1;
  340.   $$ -> child[1] = $3;
  341.   $$ -> attr.op = SUB;
  342. }
  343. |simple_exp MUT simple_exp 
  344. { $$ = newExpNode(OpK);
  345.   $$ -> child[0] = $1;
  346.   $$ -> child[1] = $3;
  347.   $$ -> attr.op = MUT;
  348. }
  349. |simple_exp DIV simple_exp 
  350. { $$ = newExpNode(OpK);
  351.   $$ -> child[0] = $1;
  352.   $$ -> child[1] = $3;
  353.   $$ -> attr.op = DIV;
  354. }
  355. | factor
  356.     { $$ = $1; }
  357. ;
  359. factor      : LP exp RP
  360.                 { $$ = $2; }
  361.             | var
  362.                 { $$ = $1; }
  363. | call
  364.     { $$ = $1; }
  365. | NUM
  366.     { $$ = newExpNode(NumK);
  367.       $$ -> type = Integer;
  368.       $$ -> attr.val.i = atoi(tokenString);
  369.     }
  370. | FNUM
  371.     { $$ = newExpNode(FnumK);
  372.       $$ -> type = Float;
  373.       $$ -> attr.val.f = atof(tokenString);
  374.     }
  375. | SCHAR
  376.     { $$ = newExpNode(CharK);
  377.       $$ -> type = Char;
  378.       $$ -> attr.val.i = *(tokenString + 1);
  379.     }
  380. | NOT factor
  381.     { $$ = $2;
  382.       $$ -> attr.op = NOT;
  383.     }
  384. ;
  385. call        : var LP args RP
  386.                 { $$ = newStmtNode(CallK);
  387.   $$ -> attr.name = $1 -> attr.name;
  388.                   $$ -> child[0] = $3;
  389.                 }
  390.             ;
  391. arg_list    : arg_list COMMA exp            
  392. { TreeNode * t = $1;
  393.   if (t != NULL)
  394.   { while (t->sibling != NULL)
  395. t = t->sibling;
  396. t->sibling = $3;
  397. $$ = $1; }
  398.   else $$ = $3;
  399. }                  
  400.             | exp
  401.                 { $$ = $1; }
  402. ;
  403. args        : arg_list
  404.                 { $$ = $1; }           
  405.             | 
  406.                 { $$ = NULL; }
  407.             ;
  408. %%
  410. void yyerror(const char * message)
  411. { fprintf(listing,"Syntax error at line %d: %sn",lineno,message);
  412.   fprintf(listing,"Current token: ");
  413.   printToken(yychar,tokenString);
  414.   Error = TRUE;
  415. }
  417. /* yylex calls getToken to make Yacc/Bison output
  418.  * compatible with ealier versions of the TINY scanner
  419.  */
  420. #ifdef YYPROTOTYPE
  421. int YYCDECL yygettoken(void)
  422. #else
  423. int YYCDECL yygettoken()
  424. #endif
  425. {
  426. return yylex();
  427. }
  429. static TokenType yylex(void)
  430. { return getToken(); }
  432. TreeNode * parse(void)
  433. { yyparse();
  434.   return savedTree;
  435. }