home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_300 / 338_02 / stmt.c < prev    next >
Text File  |  1989-10-06  |  13KB  |  424 lines
  1. #include        <stdio.h>
  2. #include        "c.h"
  3. #include        "expr.h"
  4. #include        "gen.h"
  5. #include        "cglbdec.h"
  6.  
  7. /*
  8.  *    68000 C compiler
  9.  *
  10.  *    Copyright 1984, 1985, 1986 Matthew Brandt.
  11.  *  all commercial rights reserved.
  12.  *
  13.  *    This compiler is intended as an instructive tool for personal use. Any
  14.  *    use for profit without the written consent of the author is prohibited.
  15.  *
  16.  *    This compiler may be distributed freely for non-commercial use as long
  17.  *    as this notice stays intact. Please forward any enhancements or questions
  18.  *    to:
  19.  *
  20.  *        Matthew Brandt
  21.  *        Box 920337
  22.  *        Norcross, Ga 30092
  23.  */
  24.  
  25. /*
  26.  *      the statement module handles all of the possible c statements
  27.  *      and builds a parse tree of the statements.
  28.  *
  29.  *      each routine returns a pointer to a statement parse node which
  30.  *      reflects the statement just parsed.
  31.  */
  32.  
  33. struct snode    *statement();   /* forward declaration */
  34.  
  35. struct snode    *whilestmt()
  36. /*
  37.  *      whilestmt parses the c while statement.
  38.  */
  39. {       struct snode    *snp;
  40.         snp = xalloc(sizeof(struct snode));
  41.         snp->stype = st_while;
  42.         getsym();
  43.         if( lastst != openpa )
  44.                 error(ERR_EXPREXPECT);
  45.         else    {
  46.                 getsym();
  47.                 if( expression(&(snp->exp)) == 0 )
  48.                         error(ERR_EXPREXPECT);
  49.                 needpunc( closepa );
  50.                 snp->s1 = statement();
  51.                 } 
  52.         return snp;
  53. } 
  54.   
  55. struct snode    *dostmt() 
  56. /* 
  57.  *      dostmt parses the c do-while construct.
  58.  */ 
  59. {       struct snode    *snp;
  60.         snp = xalloc(sizeof(struct snode));
  61.         snp->stype = st_do;
  62.         getsym(); 
  63.         snp->s1 = statement(); 
  64.         if( lastst != kw_while ) 
  65.                 error(ERR_WHILEXPECT); 
  66.         else    { 
  67.                 getsym();
  68.                 if( lastst != openpa ) 
  69.                         error(ERR_EXPREXPECT);
  70.                 else    { 
  71.                         getsym(); 
  72.                         if( expression(&(snp->exp)) == 0 ) 
  73.                                 error(ERR_EXPREXPECT); 
  74.                         needpunc(closepa);
  75.                         } 
  76.                 if( lastst != end )
  77.                         needpunc( semicolon );
  78.                 } 
  79.         return snp; 
  80. } 
  81.   
  82. struct snode    *forstmt() 
  83. {       struct snode    *snp; 
  84.         snp = xalloc(sizeof(struct snode));
  85.         getsym(); 
  86.         needpunc(openpa);
  87.         if( expression(&(snp->label)) == 0 ) 
  88.                 snp->label = 0; 
  89.         needpunc(semicolon); 
  90.         snp->stype = st_for; 
  91.         if( expression(&(snp->exp)) == 0 )
  92.                 snp->exp = 0; 
  93.         needpunc(semicolon);
  94.         if( expression(&(snp->s2)) == 0 ) 
  95.                 snp->s2 = 0; 
  96.         needpunc(closepa); 
  97.         snp->s1 = statement(); 
  98.         return snp; 
  99. } 
  100.   
  101. struct snode    *ifstmt()
  102. /* 
  103.  *      ifstmt parses the c if statement and an else clause if
  104.  *      one is present. 
  105.  */ 
  106. {       struct snode    *snp; 
  107.         snp = xalloc(sizeof(struct snode));
  108.         snp->stype = st_if;
  109.         getsym(); 
  110.         if( lastst != openpa )
  111.                 error(ERR_EXPREXPECT); 
  112.         else    { 
  113.                 getsym(); 
  114.                 if( expression(&(snp->exp)) == 0 ) 
  115.                         error(ERR_EXPREXPECT); 
  116.                 needpunc( closepa ); 
  117.                 snp->s1 = statement(); 
  118.                 if( lastst == kw_else ) {
  119.                         getsym(); 
  120.                         snp->s2 = statement();
  121.                         } 
  122.                 else 
  123.                         snp->s2 = 0; 
  124.                 } 
  125.         return snp;
  126. } 
  127.  
  128. struct snode    *casestmt() 
  129. /* 
  130.  *      cases are returned as seperate statements. for normal 
  131.  *      cases label is the case value and s2 is zero. for the 
  132.  *      default case s2 is nonzero. 
  133.  */ 
  134. {       struct snode    *snp; 
  135.         struct snode    *head, *tail;
  136.         snp = xalloc(sizeof(struct snode));
  137.         if( lastst == kw_case ) {
  138.                 getsym(); 
  139.                 snp->s2 = 0;
  140.                 snp->stype = st_case;
  141.                 snp->label = intexpr();
  142.                 }
  143.         else if( lastst == kw_default) { 
  144.                 getsym();
  145.                 snp->s2 = 1;
  146.                 } 
  147.         else    { 
  148.                 error(ERR_NOCASE); 
  149.                 return 0; 
  150.                 } 
  151.         needpunc(colon); 
  152.         head = 0;
  153.         while( lastst != end && 
  154.                 lastst != kw_case &&
  155.                 lastst != kw_default ) { 
  156.                 if( head == 0 ) 
  157.                         head = tail = statement(); 
  158.                 else    { 
  159.                         tail->next = statement();
  160.                         if( tail->next != 0 ) 
  161.                                 tail = tail->next;
  162.                         } 
  163.                 tail->next = 0; 
  164.                 } 
  165.         snp->s1 = head; 
  166.         return snp; 
  167. } 
  168.   
  169. int     checkcases(head)
  170. /* 
  171.  *      checkcases will check to see if any duplicate cases
  172.  *      exist in the case list pointed to by head. 
  173.  */ 
  174. struct snode    *head; 
  175. {     
  176.     struct snode    *top, *cur;
  177.     cur = top = head;
  178.     while( top != 0 )
  179.     {
  180.         cur = top->next;
  181.         while( cur != 0 )
  182.         {
  183.             if( (!(cur->s1 || cur->s2) && cur->label == top->label)
  184.                 || (cur->s2 && top->s2) )
  185.             {
  186.                 printf(" duplicate case label %d\n",cur->label);
  187.                 return 1;
  188.             }
  189.             cur = cur->next;
  190.         }
  191.         top = top->next;
  192.     }
  193.     return 0;
  194. } 
  195.  
  196. struct snode    *switchstmt() 
  197. {       struct snode    *snp; 
  198.         struct snode    *head, *tail; 
  199.         snp = xalloc(sizeof(struct snode));
  200.         snp->stype = st_switch; 
  201.         getsym(); 
  202.         needpunc(openpa); 
  203.         if( expression(&(snp->exp)) == 0 )
  204.                 error(ERR_EXPREXPECT); 
  205.         needpunc(closepa);
  206.         needpunc(begin); 
  207.         head = 0; 
  208.         while( lastst != end ) { 
  209.                 if( head == 0 ) 
  210.                         head = tail = casestmt();
  211.                 else    { 
  212.                         tail->next = casestmt();
  213.                         if( tail->next != 0 ) 
  214.                                 tail = tail->next; 
  215.                         } 
  216.                 tail->next = 0; 
  217.                 } 
  218.         snp->s1 = head; 
  219.         getsym(); 
  220.         if( checkcases(head) )
  221.                 error(ERR_DUPCASE); 
  222.         return snp;
  223. } 
  224.   
  225. struct snode    *retstmt() 
  226. {       struct snode    *snp; 
  227.         snp = xalloc(sizeof(struct snode));
  228.         snp->stype = st_return; 
  229.         getsym();
  230.         expression(&(snp->exp));
  231.         if( lastst != end )
  232.                 needpunc( semicolon );
  233.         return snp; 
  234. } 
  235.   
  236. struct snode    *breakstmt() 
  237. {       struct snode    *snp;
  238.         snp = xalloc(sizeof(struct snode));
  239.         snp->stype = st_break;
  240.         getsym(); 
  241.         if( lastst != end )
  242.                 needpunc( semicolon );
  243.         return snp; 
  244. }
  245.   
  246. struct snode    *contstmt()
  247. {       struct snode    *snp; 
  248.         snp = xalloc(sizeof(struct snode));
  249.         snp->stype = st_continue; 
  250.         getsym();
  251.         if( lastst != end )
  252.                 needpunc( semicolon );
  253.         return snp;
  254. }
  255.   
  256. struct snode    *exprstmt()
  257. /* 
  258.  *      exprstmt is called whenever a statement does not begin 
  259.  *      with a keyword. the statement should be an expression. 
  260.  */ 
  261. {       struct snode    *snp;
  262.         snp = xalloc(sizeof(struct snode));
  263.         snp->stype = st_expr;
  264.         if( expression(&(snp->exp)) == 0 ) { 
  265.                 error(ERR_EXPREXPECT); 
  266.                 getsym(); 
  267.                 } 
  268.         if( lastst != end )
  269.                 needpunc( semicolon );
  270.         return snp;
  271. }
  272.   
  273. struct snode    *compound()
  274. /* 
  275.  *      compound processes a block of statements and forms a linked 
  276.  *      list of the statements within the block. 
  277.  * 
  278.  *      compound expects the input pointer to already be past the
  279.  *      begin symbol of the block. 
  280.  */
  281. {       struct snode    *head, *tail; 
  282.         head = 0; 
  283.         while( lastst != end ) { 
  284.                 if( head == 0 ) 
  285.                         head = tail = statement(); 
  286.                 else    { 
  287.                         tail->next = statement();
  288.                         if( tail->next != 0 )
  289.                                 tail = tail->next; 
  290.                         }
  291.                 } 
  292.         getsym(); 
  293.         return head; 
  294. } 
  295.  
  296. struct snode    *labelstmt() 
  297. /*
  298.  *      labelstmt processes a label that appears before a 
  299.  *      statement as a seperate statement. 
  300.  */ 
  301. {       struct snode    *snp;
  302.         SYM             *sp; 
  303.         snp = xalloc(sizeof(struct snode));
  304.         snp->stype = st_label;
  305.         if( (sp = search(lastid,lsyms.head)) == 0 ) {
  306.                 sp = xalloc(sizeof(SYM));
  307.                 sp->name = litlate(lastid);
  308.                 sp->storage_class = sc_label; 
  309.                 sp->tp = 0; 
  310.                 sp->value.i = nextlabel++; 
  311.                 insert(sp,&lsyms); 
  312.                 }
  313.         else    { 
  314.                 if( sp->storage_class != sc_ulabel )
  315.                         error(ERR_LABEL); 
  316.                 else 
  317.                         sp->storage_class = sc_label; 
  318.                 } 
  319.         getsym();       /* get past id */ 
  320.         needpunc(colon); 
  321.         if( sp->storage_class == sc_label ) {
  322.                 snp->label = &( (int) sp->value.i);
  323.                 snp->next = 0;
  324.                 return snp;
  325.                 }
  326.         return 0; 
  327. } 
  328.   
  329. struct snode    *gotostmt()
  330. /* 
  331.  *      gotostmt processes the goto statement and puts undefined
  332.  *      labels into the symbol table. 
  333.  */ 
  334. {       struct snode    *snp; 
  335.         SYM             *sp; 
  336.         getsym(); 
  337.         if( lastst != id ) { 
  338.                 error(ERR_IDEXPECT);
  339.                 return 0;
  340.                 } 
  341.         snp = xalloc(sizeof(struct snode));
  342.         if( (sp = search(lastid,lsyms.head)) == 0 ) {
  343.                 sp = xalloc(sizeof(SYM));
  344.                 sp->name = litlate(lastid);
  345.                 sp->value.i = nextlabel++;
  346.                 sp->storage_class = sc_ulabel;
  347.                 sp->tp = 0; 
  348.                 insert(sp,&lsyms);
  349.                 } 
  350.         getsym();       /* get past label name */ 
  351.         if( lastst != end )
  352.                 needpunc( semicolon );
  353.         if( sp->storage_class != sc_label && sp->storage_class != sc_ulabel) 
  354.                 error( ERR_LABEL );
  355.         else    {
  356.                 snp->stype = st_goto;
  357.                 snp->label = &( (int) sp->value.i);
  358.                 snp->next = 0;
  359.                 return snp;
  360.                 }
  361.         return 0;
  362. }
  363.  
  364.  
  365. struct snode    *statement()
  366. /*
  367.  *      statement figures out which of the statement processors
  368.  *      should be called and transfers control to the proper
  369.  *      routine.
  370.  */
  371. {       struct snode    *snp;
  372.  
  373.         switch( lastst ) {
  374.                 case semicolon:
  375.                         getsym();
  376.                         snp = 0;
  377.                         break;
  378.                 case begin:
  379.                         getsym();
  380.                         snp = compound();
  381.                         return snp;
  382.                 case kw_if:
  383.                         snp = ifstmt();
  384.                         break;
  385.                 case kw_while:
  386.                         snp = whilestmt();
  387.                         break;
  388.                 case kw_for:
  389.                         snp = forstmt();
  390.                         break;
  391.                 case kw_return:
  392.                         snp = retstmt();
  393.                         break;
  394.                 case kw_break:
  395.                         snp = breakstmt(); 
  396.                         break; 
  397.                 case kw_goto: 
  398.                         snp = gotostmt(); 
  399.                         break; 
  400.                 case kw_continue: 
  401.                         snp = contstmt(); 
  402.                         break; 
  403.                 case kw_do: 
  404.                         snp = dostmt(); 
  405.                         break; 
  406.                 case kw_switch: 
  407.                         snp = switchstmt();
  408.                         break; 
  409.                 case id: 
  410.                         while( isspace(lastch) ) 
  411.                                 cgetch();
  412.                         if( lastch == ':' ) 
  413.                                 return labelstmt(); 
  414.                         /* else fall through to process expression */ 
  415.                 default: 
  416.                         snp = exprstmt(); 
  417.                         break; 
  418.                 } 
  419.         if( snp != 0 ) 
  420.                 snp->next = 0; 
  421.         return snp; 
  422. } 
  423.  
  424.