home *** CD-ROM | disk | FTP | other *** search
/ CD Shareware Magazine 1996 December / CD_shareware_12-96.iso / DOS / Programa / CCDL122.ZIP / SOURCE / STMT.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-03  |  22.2 KB  |  787 lines
  1. /*
  2.  * 68K/386 32-bit C compiler.
  3.  *
  4.  * copyright (c) 1996, David Lindauer
  5.  * 
  6.  * This compiler is intended for educational use.  It may not be used
  7.  * for profit without the express written consent of the author.
  8.  *
  9.  * It may be freely redistributed, as long as this notice remains intact
  10.  * and sources are distributed along with any executables derived from them.
  11.  *
  12.  * The author is not responsible for damages, either direct or consequential,
  13.  * that may arise from use of this software.
  14.  *
  15.  * v1.5 August 1996
  16.  * David Lindauer, gclind01@starbase.spd.louisville.edu
  17.  *
  18.  * Credits to Mathew Brandt for original K&R C compiler
  19.  *
  20.  */
  21. #include        <stdio.h> 
  22. #include        "expr.h" 
  23. #include        "c.h" 
  24. #include        "gen.h"
  25. #include        "cglbdec.h" 
  26.  
  27. extern SYM *currentfunc;
  28. extern int skm_closepa[];
  29. extern int incldepth;
  30. extern int inline[4096];
  31. extern int goodcode;
  32. extern TABLE oldlsym;
  33. extern int prm_cplusplus;
  34.  
  35. int skm_openpa[] = { openpa, begin, semicolon, 0 };
  36. int skm_semi[] = { semicolon, end, 0 };
  37.  
  38. static char phibuf[4096];
  39. static int lastlineno = 0;
  40.  
  41. SNODE *cbautoinithead, *cbautoinittail;
  42.  
  43. int scanassign(ENODE *node)
  44. {  
  45.         if( node == 0 )
  46.                 return 0;
  47.         switch( node->nodetype ) {
  48.                 case en_rcon:
  49.                 case en_icon:
  50.                 case en_nalabcon:
  51.                 case en_napccon:
  52.                 case en_nacon:
  53.                                 case en_absacon:
  54.                 case en_autocon:
  55.                 case en_autoreg:
  56.                                                 return FALSE;
  57.                                 case en_bits:
  58.                                 case en_floatref:
  59.                                 case en_doubleref:
  60.                                 case en_longdoubleref:
  61.                 case en_b_ref:
  62.                 case en_w_ref:
  63.                 case en_ul_ref:
  64.                 case en_l_ref:
  65.                 case en_ub_ref:
  66.                 case en_uw_ref:
  67.                 case en_uminus:
  68.                 case en_compl:  case en_ainc:
  69.                 case en_adec:   case en_not:
  70.                                 case en_cb: case en_cub:
  71.                                 case en_cw: case en_cuw:
  72.                                 case en_cl: case en_cul:
  73.                                 case en_cf: case en_cd: case en_cp: case en_cld:
  74.                                             return scanassign(node->v.p[0]);
  75.                 case en_eq:     case en_ne:
  76.                 case en_gt:     case en_ge:
  77.                 case en_lt:     case en_le:
  78.                                 case en_ugt:    case en_uge: case en_ult: case en_ule:
  79.                                             return 0;        /* No error if a conditional is higher than an equate */
  80.                 case en_asadd:  case en_assub:
  81.                                 case en_asalsh: case en_asarsh: case en_alsh: case en_arsh:
  82.                 case en_asmul:  case en_asdiv:
  83.                 case en_asmod:  case en_aslsh:
  84.                                 case en_asumod: case en_asudiv: case en_asumul:
  85.                 case en_mul:    case en_div:
  86.                 case en_umul:    case en_udiv: case en_umod:
  87.                 case en_lsh:    case en_rsh:
  88.                 case en_mod:    case en_and:
  89.                 case en_or:     case en_xor:
  90.                 case en_lor:    case en_land:
  91.                               case en_pmul:
  92.                 case en_asrsh:  case en_asand:  case en_pdiv:
  93.                 case en_asor:   case en_cond:
  94.                 case en_void:   
  95.                                 case en_moveblock: case en_stackblock:
  96.                 case en_add:    case en_sub: case en_refassign:
  97.                         return scanassign(node->v.p[0]) || scanassign(node->v.p[1]);
  98.                                 case en_assign:
  99.                                                 return 1;    /* Error if assign higher than conditional */
  100.                 }
  101.     return 0;
  102. }
  103. TYP *doassign(ENODE **exp, int canerror, int *skm)
  104. {
  105.     TYP *tp;
  106.   if( (tp =expression(exp)) == 0 )  {
  107.         if (canerror)
  108.         generror(ERR_EXPREXPECT,0,skm); 
  109.         *exp = 0;
  110.   }
  111.     else {
  112.         if (scanassign(*exp))
  113.             generror(ERR_BADEQUATE,0,0);
  114.     }
  115.     return tp;
  116. }
  117. SNODE    *whilestmt(void) 
  118. /* 
  119.  *      whilestmt parses the c while statement. 
  120.  */ 
  121. {       SNODE    *snp; 
  122.                 int ogc = goodcode;
  123.                 goodcode |= GF_INLOOP;
  124.         snp = xalloc(sizeof(SNODE)); 
  125.         snp->stype = st_while; 
  126.                 snp->s1 = 0;
  127.         getsym(); 
  128.                 needpunc(openpa,0);
  129.                 doassign(&snp->exp,TRUE,0);
  130.                 
  131.         needpunc( closepa,skm_closepa );
  132.                 goodcode |= GF_CONTINUABLE; 
  133.         snp->s1 = cppblockedstatement(); 
  134.                 goodcode = ogc; 
  135.         return snp; 
  136. } 
  137.   
  138. SNODE    *dostmt(void) 
  139. /* 
  140.  *      dostmt parses the c do-while construct. 
  141.  */ 
  142. {       SNODE    *snp; 
  143.                 int ogc = goodcode;
  144.                 goodcode |= GF_INLOOP;
  145.         snp = xalloc(sizeof(SNODE)); 
  146.         snp->stype = st_do; 
  147.         getsym(); 
  148.                 goodcode |= GF_CONTINUABLE; 
  149.         snp->s1 = cppblockedstatement(); 
  150.                 goodcode = ogc; 
  151.         if( lastst != kw_while ) 
  152.                                 gensymerror(ERR_IDENTEXPECT,lastid);
  153.         else   
  154.           getsym();
  155.                 needpunc(openpa,0); 
  156.                 doassign(&snp->exp,TRUE,0);
  157.         needpunc(closepa,skm_closepa); 
  158.         if( lastst != end && lastst != eof)
  159.           needpunc( semicolon,0 );
  160.         return snp; 
  161. } 
  162.   
  163. SNODE    *forstmt(void) 
  164. {       SNODE    *snp; 
  165.                 int ogc = goodcode;
  166.                 int plussemi = 0;
  167.                 goodcode |= GF_INLOOP;
  168.         snp = xalloc(sizeof(SNODE)); 
  169.         getsym(); 
  170.                 snp->label = snp->exp = snp->s2 = 0;
  171.         snp->stype = st_for; 
  172.         if (needpunc(openpa,skm_closepa)) { 
  173.                     if (castbegin(lastst)) {
  174.                         if (prm_cplusplus) {
  175.                             ENODE *exp=0,**next = &exp;
  176.                             cbautoinithead = cbautoinittail = 0;
  177.                             dodecl(sc_auto);
  178.                             while (cbautoinithead) {
  179.                                 if (*next) {
  180.                                     *next = makenode(en_void,(*next),cbautoinithead->exp);
  181.                                     next = &(*next)->v.p[1];
  182.                                 }
  183.                                 else *next = cbautoinithead->exp;
  184.                                 cbautoinithead = cbautoinithead->next;
  185.                             }
  186.                             snp->label = exp;
  187.                             plussemi = 1;
  188.                         }
  189.                         else {
  190.                             generror(ERR_NODECLARE,0,0);
  191.                             while (castbegin(lastst))
  192.                                 getsym();
  193.                             goto forjoin;
  194.                         }
  195.                     }
  196.                     else {
  197. forjoin:
  198.                         if( expression(&snp->label) == 0 ) 
  199.                             snp->label = 0;
  200.                         plussemi = needpunc(semicolon,0);
  201.                     }
  202.                     if (plussemi) {
  203.                         doassign(&snp->exp,FALSE,0);
  204.                         if (needpunc(semicolon,0)) {
  205.                             if( expression(&snp->s2) == 0 )  {
  206.                                 snp->s2 = 0;
  207.                             }
  208.                       }
  209.                     }
  210.             needpunc(closepa,skm_closepa); 
  211.                 }
  212.                 goodcode |= GF_CONTINUABLE; 
  213.         snp->s1 = cppblockedstatement(); 
  214.                 goodcode = ogc; 
  215.         return snp; 
  216. } 
  217.   
  218. SNODE    *ifstmt(void) 
  219. /* 
  220.  *      ifstmt parses the c if statement and an else clause if 
  221.  *      one is present. 
  222.  */ 
  223. {       SNODE    *snp;
  224.                 int ogc = goodcode; 
  225.                 int temp=0;
  226.         snp = xalloc(sizeof(SNODE)); 
  227.         snp->stype = st_if; 
  228.         getsym();
  229.                 needpunc(openpa,0); 
  230.                 doassign(&snp->exp,TRUE,0);
  231.         needpunc( closepa,skm_closepa ); 
  232.         snp->s1 = cppblockedstatement(); 
  233.         if( lastst == kw_else ) { 
  234.                     temp = goodcode & (GF_RETURN | GF_BREAK | GF_CONTINUE | GF_GOTO);
  235.                     goodcode = ogc;
  236.           getsym(); 
  237.           snp->s2 = cppblockedstatement(); 
  238.                     temp = temp & goodcode;
  239.         } 
  240.         else 
  241.           snp->s2 = 0; 
  242.                 goodcode = ogc | temp;
  243.         return snp; 
  244. } 
  245.   
  246. SNODE    *casestmt(void) 
  247. /* 
  248.  *      cases are returned as seperate statements. for normal 
  249.  *      cases label is the case value and s2 is zero. for the 
  250.  *      default case s2 is nonzero. 
  251.  */ 
  252. {       SNODE    *snp; 
  253.         SNODE    *head, *tail; 
  254.         snp = xalloc(sizeof(SNODE)); 
  255.         if( lastst == kw_case ) { 
  256.                 getsym(); 
  257.                 snp->s2 = 0;
  258.                 snp->stype = st_case;
  259.                 snp->label = (SNODE *)intexpr(0);
  260.                 } 
  261.         else if( lastst == kw_default) { 
  262.                                 goodcode |= GF_DEF;
  263.                 getsym(); 
  264.                 snp->stype = st_case;
  265.                 snp->s2 = (SNODE *)1; 
  266.                 } 
  267.         else    { 
  268.                 generror(ERR_NOCASE,0,0); 
  269.                 return 0; 
  270.                 } 
  271.         needpunc(colon,0); 
  272.         head = 0; 
  273.         while( lastst != end && lastst != eof &&
  274.                 lastst != kw_case && 
  275.                 lastst != kw_default ) { 
  276.                                 if (goodcode & (GF_RETURN | GF_BREAK | GF_CONTINUE | GF_GOTO)) {
  277.                                     generror(ERR_UNREACHABLE,0,0);
  278.                                 }
  279.                                 goodcode &= ~(GF_RETURN | GF_BREAK | GF_CONTINUE | GF_GOTO);
  280.                 if( head == 0 ) 
  281.                         head = tail = statement(); 
  282.                 else    { 
  283.                         tail->next = statement(); 
  284.                         } 
  285.                 while( tail->next != 0 ) 
  286.                   tail = tail->next; 
  287.                 }
  288.                 if (goodcode & GF_BREAK)
  289.                     goodcode &= ~GF_UNREACH;
  290.         snp->s1 = head; 
  291.         return snp; 
  292. } 
  293.   
  294. int     checkcases(SNODE *head) 
  295. /* 
  296.  *      checkcases will check to see if any duplicate cases 
  297.  *      exist in the case list pointed to by head. 
  298.  */ 
  299. {     
  300.     SNODE    *top, *cur;
  301.     top = head;
  302.     while( top != 0 )
  303.     {
  304.         cur = top->next;
  305.         while( cur != 0 )
  306.         {
  307.             if( (!(cur->s1 || cur->s2) && cur->label == top->label)
  308.                 || (cur->s2 && top->s2) )
  309.             {
  310.                 generror(ERR_DUPCASE,(int)cur->label,0);
  311.                 return 1;
  312.             }
  313.             cur = cur->next;
  314.         }
  315.         top = top->next;
  316.     }
  317.     return 0;
  318. } 
  319.   
  320. SNODE    *switchstmt(void) 
  321. {       SNODE    *snp; 
  322.         SNODE    *head, *tail; 
  323.                 TYP *tp;
  324.                 int ogc = goodcode;
  325.     TABLE oldoldlsym;
  326.     long oldlcauto;
  327.     if (prm_cplusplus) {
  328.         oldlcauto = lc_auto;
  329.         oldoldlsym = oldlsym;
  330.         oldlsym = lsyms;
  331.     }
  332.         snp = xalloc(sizeof(SNODE)); 
  333.         snp->stype = st_switch; 
  334.         getsym(); 
  335.         needpunc(openpa,0); 
  336.                 tp = doassign(&snp->exp,TRUE,0);
  337.                 if (tp) {
  338.                     switch  (tp->type) {
  339.                         case bt_char:
  340.                         case bt_unsignedchar:
  341.                         case bt_short:
  342.                         case bt_unsignedshort:
  343.                         case bt_long:
  344.                         case bt_unsigned:
  345.                         case bt_enum:
  346.                             break;
  347.                         default:
  348.                             generror(ERR_SWITCHINT,0,0);
  349.                     }
  350.                 }
  351.         needpunc(closepa, skm_closepa); 
  352.         needpunc(begin,0); 
  353.         head = 0; 
  354.                 goodcode |= GF_UNREACH;
  355.                 goodcode &= ~GF_DEF;
  356.         while( lastst != end && lastst != eof) { 
  357.                                 goodcode &= ~(GF_RETURN | GF_BREAK | GF_CONTINUE | GF_GOTO);
  358.                 if( head == 0 ) 
  359.                         head = tail = casestmt(); 
  360.                 else    { 
  361.                         tail->next = casestmt(); 
  362.                         if( tail->next != 0 ) 
  363.                                 tail = tail->next; 
  364.                         } 
  365.                 tail->next = 0; 
  366.                 } 
  367.                 if (goodcode & GF_RETURN) {
  368.                     if ((goodcode & GF_UNREACH)  && (goodcode & GF_DEF)) 
  369.                         ogc |= GF_RETURN;
  370.                 }
  371.                 goodcode = ogc;
  372.         snp->s1 = head; 
  373.         getsym(); 
  374.         checkcases(head);
  375.     if (prm_cplusplus) {
  376.         check_funcused(&oldlsym,&lsyms);
  377.         gather_labels(&oldlsym,&lsyms);
  378.         if (lc_auto > lc_maxauto) {
  379.             lc_maxauto = lc_auto;
  380.         }
  381.         cseg();
  382.         lc_auto = oldlcauto;
  383.         lsyms = oldlsym;
  384.         oldlsym.head = oldoldlsym.head;
  385.     }
  386.         return snp; 
  387. } 
  388.   
  389. SNODE    *retstmt(void) 
  390. {       SNODE    *snp; 
  391.                 TYP *tp;
  392.         snp = xalloc(sizeof(SNODE)); 
  393.         snp->stype = st_return; 
  394.                 snp->exp = 0;
  395.         getsym(); 
  396.                 if (lastst == end || lastst == semicolon) {
  397.                     if (currentfunc->tp->btp->type != bt_void)
  398.                         generror(ERR_RETMISMATCH,0,0);
  399.                     if (lastst == semicolon)
  400.                         getsym();
  401.                 }
  402.                 else {
  403.                     int ogc = goodcode;
  404.                     goodcode |= GF_SUPERAND;
  405.             tp = expression(&(snp->exp));
  406.                     goodcode = ogc;
  407.             if( lastst != end  && lastst != eof)
  408.                 needpunc( semicolon, 0 );
  409.                     if (tp->type == bt_void) {
  410.                         generror(ERR_NOVOIDRET,0,0);
  411.                     }
  412.                     else
  413.                         if (tp->type == bt_pointer && tp->val_flag)
  414.                             generror(ERR_NOFUNCARRAY,0,0);
  415.                         else
  416.                             if (!checktype(tp,currentfunc->tp->btp))
  417.                                 if (isscalar(tp) && isscalar(currentfunc->tp->btp))
  418.                                     promote_type(currentfunc->tp->btp, &(snp->exp));
  419.                                 else
  420.                                     if (currentfunc->tp->btp->type != bt_pointer ||
  421.                                             floatrecurse(snp->exp))
  422.                                         generror(ERR_RETMISMATCH,0,0);
  423.                 }
  424.         return snp; 
  425. } 
  426.   
  427. SNODE    *breakstmt(void) 
  428. {       SNODE    *snp; 
  429.         snp = xalloc(sizeof(SNODE)); 
  430.         snp->stype = st_break; 
  431.         getsym(); 
  432.         if( lastst != end && lastst != eof)
  433.                 needpunc( semicolon,0 );
  434.         return snp; 
  435. } 
  436.   
  437. SNODE    *contstmt(void) 
  438. {       SNODE    *snp; 
  439.         snp = xalloc(sizeof(SNODE)); 
  440.         snp->stype = st_continue; 
  441.                 if (!(goodcode & GF_CONTINUABLE))
  442.                     generror(ERR_NOCONTINUE,0,0);
  443.         getsym();
  444.         if( lastst != end && lastst != eof)
  445.                 needpunc( semicolon,0 );
  446.         return snp;
  447. }
  448. SNODE *_genwordstmt(void)
  449. {
  450.                 SNODE *snp;
  451.                 snp = xalloc(sizeof(SNODE));
  452.                 snp->stype = st__genword;
  453.                 snp->exp = 0;
  454.                 getsym();
  455.                 if (lastst != openpa) {
  456.                     generror(ERR_PUNCT,openpa,skm_semi);
  457.                     getsym();
  458.                     snp = 0;
  459.                 }
  460.                 else {
  461.                     getsym();
  462.                     snp->exp = (ENODE *) intexpr(0);
  463.                     if (lastst != closepa) {
  464.                         generror(ERR_PUNCT,closepa,skm_semi);
  465.                         snp = 0;
  466.                     }
  467.                     getsym();
  468.                 }
  469.                 if (lastst != end && lastst != eof)
  470.                     needpunc(semicolon,0);
  471.                 return(snp);
  472. }
  473. SNODE    *exprstmt(void) 
  474. /* 
  475.  *      exprstmt is called whenever a statement does not begin 
  476.  *      with a keyword. the statement should be an expression. 
  477.  */ 
  478. {       SNODE    *snp; 
  479.         snp = xalloc(sizeof(SNODE)); 
  480.         snp->stype = st_expr; 
  481.                 goodcode &= ~(GF_ASSIGN);
  482.               if( expression(&snp->exp) == 0 )  {
  483.                 generror(ERR_EXPREXPECT,0,skm_semi); 
  484.                     snp->exp = 0;
  485.               }
  486.                 if (!(goodcode & GF_ASSIGN))
  487.                     generror(ERR_CODENONE,0,0);
  488.         if( lastst != end && lastst != eof)
  489.                 needpunc( semicolon,0 );
  490.         return snp; 
  491. } 
  492.   
  493. SNODE *snp_line(void)
  494. {
  495.     SNODE *snp3 = 0;
  496.                 if (!incldepth && lineno != lastlineno && lastst != semicolon && lastst != begin) {
  497.                     int i = 0,j,l=pstrlen(inline);
  498.                     snp3 = xalloc(sizeof(SNODE));
  499.                     snp3->stype = st_line;
  500.                     snp3->exp = (ENODE *)lineno;
  501.                     snp3->next = 0;
  502.                     for (j=0; j<l; j++)
  503.                         i+= installphichar(inline[j],phibuf,i);
  504.                     if (phibuf[i-1] == '\n')
  505.                         i--;
  506.                     phibuf[i] = 0;
  507.                     if ((phibuf[i-1] & 0xf0) == 0x90)
  508.                         phibuf[i-1] = 0x90;
  509.                     snp3->label = (SNODE *)xalloc(i+1);
  510.                     strcpy(snp3->label, phibuf);
  511.                     lastlineno = lineno;
  512.                 }
  513.     return snp3;
  514. }
  515. void dodefaultinit(SYM *sp)
  516. {
  517.     TYP *tp;
  518.     if (lastst == assign) {
  519.         getsym();
  520.         if ((tp =autoasnop(&(sp->defalt), sp)) == 0) {
  521.              generror(ERR_EXPREXPECT,0,0);
  522.             getsym();
  523.         }
  524.         else sp->defalt = sp->defalt->v.p[1];
  525.     }
  526. }
  527. void doautoinit(SYM *sym)
  528. /*
  529.  * This is here rather than in init because autoinit is a type of 
  530.  * statement
  531.  */
  532. {
  533.         if (lastst == assign) {
  534.             SNODE *snp = snp_line();
  535.             if (snp) 
  536.                 if (cbautoinithead == 0)
  537.                     cbautoinithead = cbautoinittail = snp;
  538.                 else {
  539.                     cbautoinittail->next = snp;
  540.                     cbautoinittail= snp;
  541.                 }
  542.             getsym();
  543.             snp = xalloc(sizeof(SNODE));
  544.             snp->stype = st_expr;
  545.             if (autoasnop(&(snp->exp), sym) == 0) {
  546.                 generror(ERR_EXPREXPECT,0,0);
  547.                 getsym();
  548.             }
  549.             else {
  550.                 if (cbautoinithead == 0)
  551.                     cbautoinithead = cbautoinittail = snp;
  552.                 else {
  553.                     cbautoinittail->next = snp;
  554.                     cbautoinittail= snp;
  555.                 }
  556.             }
  557.         }
  558. }
  559.         
  560. SNODE    *compound(void) 
  561. /* 
  562.  *      compound processes a block of statements and forms a linked 
  563.  *      list of the statements within the block. 
  564.  * 
  565.  *      compound expects the input pointer to already be past the 
  566.  *      begin symbol of the block. 
  567.  */ 
  568. {       SNODE    *head, *tail; 
  569.         head = cbautoinithead;
  570.                 tail = cbautoinittail;
  571.                 goodcode &= ~(GF_RETURN | GF_BREAK | GF_CONTINUE | GF_GOTO);
  572.         while( lastst != end  && lastst != eof) { 
  573.                                 if (goodcode & (GF_RETURN | GF_BREAK | GF_CONTINUE | GF_GOTO)) 
  574.                                     generror(ERR_UNREACHABLE,0,0);
  575.                                 goodcode &= ~(GF_RETURN | GF_BREAK| GF_CONTINUE | GF_GOTO);
  576.                 if( head == 0 ) 
  577.                         head = tail = statement(); 
  578.                 else    { 
  579.                         tail->next = statement(); 
  580.                         } 
  581.                 while( tail->next != 0 ) 
  582.                   tail = tail->next; 
  583.                 } 
  584.                 if (head)
  585.                     tail->next = snp_line();
  586.                 if (lastst == eof)
  587.                     generror(ERR_PUNCT,end,0);
  588.                 else
  589.             getsym(); 
  590.  
  591.         return head; 
  592. } 
  593.   
  594. SNODE    *labelstmt(void) 
  595. /* 
  596.  *      labelstmt processes a label that appears before a 
  597.  *      statement as a seperate statement. 
  598.  */ 
  599. {       SNODE    *snp; 
  600.         SYM             *sp; 
  601.         snp = xalloc(sizeof(SNODE)); 
  602.         snp->stype = st_label; 
  603.         if( (sp = search(lastid,&lsyms)) == 0 ) { 
  604.                 sp = xalloc(sizeof(SYM)); 
  605.                 sp->name = litlate(lastid); 
  606.                 sp->storage_class = sc_label; 
  607.                                 sp->tp = xalloc(sizeof(TYP));
  608.                                 sp->tp->type = bt_unsigned;
  609.                                 sp->tp->uflags = 0;
  610.                 sp->value.i = nextlabel++; 
  611.                 insert(sp,&lsyms); 
  612.                 } 
  613.         else    { 
  614.                 if( sp->storage_class != sc_ulabel ) 
  615.                         gensymerror(ERR_DUPLABEL,sp->name); 
  616.                 else 
  617.                         sp->storage_class = sc_label; 
  618.                 } 
  619.         getsym();       /* get past id */ 
  620.         needpunc(colon,0); 
  621.         if( sp->storage_class == sc_label ) { 
  622.                 snp->label = (SNODE *)sp->value.i; 
  623.                 snp->next = 0; 
  624.                 return snp; 
  625.                 } 
  626.         return 0; 
  627. } 
  628.   
  629. SNODE    *gotostmt(void) 
  630. /* 
  631.  *      gotostmt processes the goto statement and puts undefined 
  632.  *      labels into the symbol table. 
  633.  */ 
  634. {       SNODE    *snp; 
  635.         SYM             *sp; 
  636.         getsym(); 
  637.         if( lastst != id ) { 
  638.                 generror(ERR_IDEXPECT,0,0); 
  639.                 return 0; 
  640.                 } 
  641.         snp = xalloc(sizeof(SNODE)); 
  642.         if( (sp = search(lastid,&lsyms)) == 0 ) { 
  643.                 sp = xalloc(sizeof(SYM)); 
  644.                 sp->name = litlate(lastid); 
  645.                 sp->value.i = nextlabel++; 
  646.                 sp->storage_class = sc_ulabel; 
  647.                                 sp->tp = xalloc(sizeof(TYP));
  648.                                 sp->tp->type = bt_unsigned;
  649.                 insert(sp,&lsyms); 
  650.                 } 
  651.                 sp->tp->uflags = UF_USED;
  652.         getsym();       /* get past label name */ 
  653.         if( lastst != end && lastst != eof)
  654.                 needpunc( semicolon,0 );
  655.         if( sp->storage_class != sc_label && sp->storage_class != sc_ulabel) 
  656.                 gensymerror( ERR_LABEL,sp->name); 
  657.         else    { 
  658.                 snp->stype = st_goto; 
  659.                 snp->label = (SNODE *)sp->value.i; 
  660.                 snp->next = 0; 
  661.                 return snp; 
  662.                 } 
  663.         return 0; 
  664. } 
  665.   
  666. SNODE    *statement(void) 
  667. /* 
  668.  *      statement figures out which of the statement processors 
  669.  *      should be called and transfers control to the proper 
  670.  *      routine. 
  671.  */ 
  672. {       SNODE    *snp, *snp2; 
  673.                 SNODE         *snp3=snp_line();
  674.  
  675.         switch( lastst ) { 
  676.                 case semicolon: 
  677.                         getsym(); 
  678.                         snp = 0; 
  679.                         break; 
  680.                 case begin: 
  681.                         getsym(); 
  682.                         snp2 = compoundblock(); 
  683.                                                 snp = xalloc(sizeof(SNODE));
  684.                                                 snp->exp = snp2;
  685.                                                 snp->stype = st_block;
  686.                                                 break;
  687.                 case kw_if: 
  688.                         snp = ifstmt(); 
  689.                         break; 
  690.                 case kw_while: 
  691.                         snp = whilestmt(); 
  692.                                                 snp->lst = snp3;
  693.                                                 snp3 = 0;
  694.                         break; 
  695.                 case kw_for: 
  696.                         snp = forstmt(); 
  697.                                                 snp->lst = snp3;
  698.                                                 snp3 = 0;
  699.                         break; 
  700.                 case kw_return: 
  701.                         snp = retstmt(); 
  702.                                                 goodcode |= GF_RETURN;
  703.                         break; 
  704.                 case kw_break: 
  705.                                                 goodcode |= GF_BREAK;
  706.                         snp = breakstmt(); 
  707.                         break; 
  708.                 case kw_goto: 
  709.                                                 goodcode |= GF_GOTO;
  710.                         snp = gotostmt(); 
  711.                         break; 
  712.                 case kw_continue: 
  713.                                                 goodcode |= GF_CONTINUE;
  714.                         snp = contstmt(); 
  715.                         break; 
  716.                 case kw_do: 
  717.                         snp = dostmt(); 
  718.                         break; 
  719.                 case kw_switch: 
  720.                         snp = switchstmt(); 
  721.                         break; 
  722.                                 case kw_else:
  723.                                                 generror(ERR_ELSE,0,0);
  724.                                                 getsym();
  725.                                                 break;
  726.                                 case kw__genword:
  727.                                                 snp = _genwordstmt();
  728.                                                 break;
  729.                 case id: 
  730.                         while( isspace(lastch) ) 
  731.                                 getch(); 
  732.                         if( lastch == ':' ) 
  733.                                 return labelstmt(); 
  734.                         /* else fall through to process expression */ 
  735.                 default:
  736.                                                 if (castbegin(lastst)) {
  737.                                                     if (prm_cplusplus) {
  738.                                                         cbautoinithead = cbautoinittail = 0;
  739.                                                         dodecl(sc_auto);
  740.                                                         snp = cbautoinithead;
  741.                                                     }
  742.                                                     else {
  743.                                                       generror(ERR_NODECLARE,0,skm_semi);
  744.                                                       snp = 0;
  745.                                                     }
  746.                                                 }
  747.                                                 else {
  748.                                snp = exprstmt(); 
  749.                                                     if (!goodcode)
  750.                                                         generror(ERR_CODENONE,0,0);
  751.                                                 }
  752.                         break; 
  753.                 } 
  754.         if( snp != 0 ) {
  755.                 snp->next = 0;
  756.                                 if (snp3) {
  757.                                     snp3->next = snp;
  758.                                     snp = snp3;
  759.                                 }
  760.                 } 
  761.         return snp; 
  762. }
  763. SNODE *cppblockedstatement(void)
  764. {
  765.     SNODE *snp;
  766.     TABLE oldoldlsym;
  767.     long oldlcauto;
  768.     if (prm_cplusplus) {
  769.         oldlcauto = lc_auto;
  770.         oldoldlsym = oldlsym;
  771.         oldlsym = lsyms;
  772.     }
  773.     snp = statement();
  774.     if (prm_cplusplus) {
  775.         check_funcused(&oldlsym,&lsyms);
  776.         gather_labels(&oldlsym,&lsyms);
  777.         if (lc_auto > lc_maxauto) {
  778.             lc_maxauto = lc_auto;
  779.         }
  780.         cseg();
  781.         lc_auto = oldlcauto;
  782.         lsyms = oldlsym;
  783.         oldlsym.head = oldoldlsym.head;
  784.     }
  785.     return(snp);
  786. }
  787.