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