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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编译器/解释器 > 查看源码
STMT.C
资源名称：c_compiler.zip　[点击查看]
上传用户：hlzzc88
上传日期：2007-01-06
资源大小：220k
文件大小：25k
源码类别：

编译器/解释器

开发平台：

Others

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