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

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

编译器/解释器

开发平台：

Others

GSTMT386.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. #include        <stdio.h>
  23. #include        "expr.h"
  24. #include        "c.h"
  25. #include        "gen386.h"
  26. #include  "diag.h"
  28. extern TABLE gsyms;
  29. extern int stdaddrsize;
  30. extern int global_flag;
  31. extern int fsave_mask, save_mask;
  32. extern TYP              stdfunc;
  33. extern struct amode     push[], pop[];
  34. extern OCODE *peep_tail, *peep_head, *peep_insert;
  35. extern long stackdepth,framedepth;
  36. extern SYM *currentfunc;
  37. extern int regs[3];
  38. extern int prm_cplusplus,prm_linkreg;
  39. extern int firstlabel, nextlabel;
  40. extern long lc_maxauto;
  42. int funcfloat;
  44. static int     breaklab;
  45. static int     contlab;
  46. static int     retlab;
  47. static int diddef;
  48. static long gswitchbottom, gswitchcount;
  49. static long gswitchtop;
  51. AMODE    *makedreg(int r)
  52. /*
  53.  *      make an address reference to a data register.
  54.  */
  55. {       AMODE    *ap;
  56.         ap = xalloc(sizeof(AMODE));
  57.         ap->mode = am_dreg;
  58.         ap->preg = r;
  59.         return ap;
  60. }
  62. AMODE    *makefreg(int r)
  63. /*
  64.  *      make an address reference to a data register.
  65.  */
  66. {       AMODE    *ap;
  67.         ap = xalloc(sizeof(AMODE));
  68.         ap->mode = am_freg;
  69.         ap->preg = r;
  70.         return ap;
  71. }
  73. AMODE    *make_direct(int i)
  74. /*
  75.  *      make a direct reference to an immediate value.
  76.  */
  77. {       return make_offset(makenode(en_icon,(char *)i,0));
  78. }
  80. AMODE    *make_strlab(char *s)
  81. /*
  82.  *      generate a direct reference to a string label.
  83.  */
  84. {       AMODE    *ap;
  85.         ap = xalloc(sizeof(AMODE));
  86.         ap->mode = am_direct;
  87.         ap->offset = makenode(en_nacon,s,0);
  88.         return ap;
  89. }
  91. void genwhile(SNODE *stmt)
  92. /*
  93.  *      generate code to evaluate a while statement.
  94.  */
  95. {       int     lab1, lab2, lab3;
  96.         initstack();            /* initialize temp registers */
  97.         lab1 = contlab;         /* save old continue label */
  98.         contlab = nextlabel++;  /* new continue label */
  99.         if( stmt->s1 != 0 )      /* has block */
  100.                 {
  101.          lab2 = breaklab;        /* save old break label */
  102.                 breaklab = nextlabel++;
  103. gen_code(op_jmp,0,make_label(contlab),0);
  104. lab3 = nextlabel++;
  105. gen_label(lab3);
  106.                 genstmt(stmt->s1);
  107. gen_label(contlab);
  108. if (stmt->lst)
  109.   gen_line(stmt->lst);
  110.                 initstack();
  111.                 truejp(stmt->exp,lab3);
  112.                 gen_label(breaklab);
  113.                 breaklab = lab2;        /* restore old break label */
  114.                 }
  115.         else         /* no loop code */
  116.                 {
  117. if (stmt->lst)
  118.   gen_line(stmt->lst);
  119.          gen_label(contlab);
  120.                 initstack();
  121.                 truejp(stmt->exp,contlab);
  122.                 }
  123.         contlab = lab1;         /* restore old continue label */
  124. }
  126. void gen_for(SNODE *stmt)
  127. /*
  128.  *      generate code to evaluate a for loop
  129.  */
  130. {       int     old_break, old_cont, exit_label, loop_label;
  131.         old_break = breaklab;
  132.         old_cont = contlab;
  133.         loop_label = nextlabel++;
  134.         exit_label = nextlabel++;
  135.         contlab = nextlabel++;
  136.         initstack();
  137.         if( stmt->label != 0 )
  138.                 gen_expr(stmt->label,F_ALL | F_NOVALUE
  139.                         ,natural_size(stmt->label));
  141.         gen_code(op_jmp,0,make_label(contlab),0);
  142.         gen_label(loop_label);
  143.         if( stmt->s1 != 0 ) {
  144. breaklab = exit_label;
  145.                 genstmt(stmt->s1);
  146. }
  147.         initstack();
  148.         if( stmt->s2 != 0 )
  149.                 gen_expr(stmt->s2,F_ALL | F_NOVALUE,natural_size(stmt->s2));
  150. gen_label(contlab);
  151. if (stmt->lst)
  152.   gen_line(stmt->lst);
  153.         initstack();
  154.         if( stmt->exp != 0 )
  155.                 truejp(stmt->exp,loop_label);
  156. else
  157. gen_code(op_jmp,0,make_label(loop_label),0);
  158. gen_label(exit_label);
  159.   breaklab = old_break;
  160. contlab = old_cont;
  161. }
  163. void genif(SNODE *stmt)
  164. /*
  165.  *      generate code to evaluate an if statement.
  166.  */
  167. {       int     lab1, lab2;
  168.         lab1 = nextlabel++;     /* else label */
  169.         lab2 = nextlabel++;     /* exit label */
  170.         initstack();            /* clear temps */
  171.         falsejp(stmt->exp,lab1);
  172.         genstmt(stmt->s1);
  173.         if( stmt->s2 != 0 )             /* else part exists */
  174.                 {
  175.                 gen_code(op_jmp,0,make_label(lab2),0);
  176.                 gen_label(lab1);
  177.                 genstmt(stmt->s2);
  178.                 gen_label(lab2);
  179.                 }
  180.         else                            /* no else code */
  181.                 gen_label(lab1);
  182. }
  184. void gendo(SNODE *stmt)
  185. /*
  186.  *      generate code for a do - while loop.
  187.  */
  188. {       int     oldcont, oldbreak;
  189.         oldcont = contlab;
  190.         oldbreak = breaklab;
  191.         contlab = nextlabel++;
  192.         gen_label(contlab);
  193.         if( stmt->s1 != 0 && stmt->s1->next != 0 )
  194.                 {
  195.                 breaklab = nextlabel++;
  196.                 genstmt(stmt->s1);      /* generate body */
  197.                 initstack();
  198.                 truejp(stmt->exp,contlab);
  199.                 gen_label(breaklab);
  200.                 }
  201.         else
  202.                 {
  203.                 genstmt(stmt->s1);
  204.                 initstack();
  205.                 truejp(stmt->exp,contlab);
  206.                 }
  207.         breaklab = oldbreak;
  208.         contlab = oldcont;
  209. }
  211. AMODE *set_symbol(char *name,int flag)
  212. {
  213. SYM *sp;
  214. AMODE *ap;
  215.         sp = gsearch(name);
  216.         if( sp == 0 )
  217.                 {
  218.                 ++global_flag;
  219.                 sp = xalloc(sizeof(SYM));
  220.                 sp->tp = &stdfunc;
  221.                 sp->name = name;
  222. if (flag)
  223. sp->storage_class = sc_externalfunc;
  224. else
  225.                  sp->storage_class = sc_external;
  226. sp->extflag = 1;
  227.                 insert(sp,&gsyms);
  228.                 --global_flag;
  229.                 }
  230. ap = make_strlab(name);
  231. ap->mode = am_immed;
  232. return ap;
  233. }
  234. void call_library(char *lib_name)
  235. /*
  236.  *      generate a call to a library routine.
  237.  */
  238. {
  239. AMODE *ap;
  240. ap = set_symbol(lib_name,1);
  241.         gen_code(op_call,0,ap,0);
  242. }
  244. int analyzeswitch(SNODE *stmt)
  245. {
  246. gswitchbottom = 0x7fffffff;
  247. gswitchtop = 0x80000000;
  248. gswitchcount = 0;
  249. stmt = stmt->s1;
  250. while (stmt) {
  251. if (!stmt->s2) {
  252. gswitchcount++;
  253. if ((long)stmt->label < gswitchbottom)
  254. gswitchbottom = (int)stmt->label;
  255. if ((long)stmt->label > gswitchtop)
  256. gswitchtop = (int)stmt->label;
  257. }
  258. stmt = stmt->next;
  259. }
  260. gswitchtop++;
  261. if (gswitchcount == 0)
  262. return(0);
  263. if (gswitchcount > 3)
  264. if (gswitchcount*10/(gswitchtop-gswitchbottom) >= 8)
  265. return(1);
  266. return(2);
  267. }
  268. void bingen(int lower, int avg, int higher,AMODE *ap1, int deflab, int size,long * switchids,int * switchlabels,int *switchbinlabels)
  269. {
  270. AMODE *ap2 = make_immed(switchids[avg]);
  271. AMODE *ap3 = make_label(switchlabels[avg]);
  272. if (switchbinlabels[avg] != -1)
  273. gen_label(switchbinlabels[avg]);
  274. gen_code(op_cmp,4,ap1,ap2);
  275. gen_code(op_je,0,ap3,0);
  276. if (avg == lower) {
  277. ap3 = make_label(deflab);
  278. gen_code(op_jmp,0,ap3,0);
  279. }
  280. else {
  281. int avg1 = (lower + avg)/2;
  282. int avg2 = (higher + avg+1)/2;
  283. if (avg+1 < higher) 
  284. ap3 = make_label(switchbinlabels[avg2]=nextlabel++);
  285. else
  286. ap3 = make_label(deflab);
  287. if (size < 0)
  288. gen_code(op_jg,0,ap3,0);
  289. else
  290. gen_code(op_ja,0,ap3,0);
  291. bingen(lower,avg1,avg,ap1,deflab,size,switchids,switchlabels,switchbinlabels);
  292. if (avg+1 < higher)
  293. bingen(avg+1,avg2,higher,ap1,deflab,size,switchids,switchlabels,switchbinlabels);
  294. }
  295. }
  296. void genbinaryswitch(SNODE *stmt, int deflab)
  297. {
  298. int curlab, i=0,j,size = natural_size(stmt->exp);
  299. AMODE *ap1;
  300.   long switchbottom=gswitchbottom, switchcount=gswitchcount;
  301.   long switchtop=gswitchtop;
  302.   int *switchlabels=0;
  303.   long *switchids=0;
  304.   int *switchbinlabels=0;
  305. curlab = nextlabel++;
  306.   initstack();
  307.   ap1 = gen_expr(stmt->exp,F_DREG,4);
  308. global_flag++;
  309. switchlabels = xalloc((switchcount) * sizeof(int));
  310. switchbinlabels = xalloc((switchcount) * sizeof(int));
  311. switchids = xalloc((switchcount) * sizeof(long));
  312. global_flag--;
  313. stmt = stmt->s1;
  314. while (stmt) {
  315.                 if( stmt->s2 )          /* default case ? */
  316.                         {
  317.                         stmt->label = (SNODE *) deflab;
  318. diddef = TRUE;
  319.                         }
  320.                 else
  321.                         {
  322. switchlabels[i] = curlab;
  323. switchbinlabels[i] = -1;
  324. switchids[i++] = (int)stmt->label;
  325. stmt->label = (SNODE *)curlab;
  326.                         }
  327.                 if( stmt->next != 0 )
  328.                         curlab = nextlabel++;
  329.                 stmt = stmt->next;
  330.                 }
  331. for (i=0; i < switchcount; i++)
  332. for (j=i+1; j < switchcount; j++)
  333. if (switchids[j] < switchids[i]) {
  334. int temp = switchids[i];
  335. switchids[i] = switchids[j];
  336. switchids[j] = temp;
  337. temp = switchlabels[i];
  338. switchlabels[i] = switchlabels[j];
  339. switchlabels[j] = temp;
  340. }
  341. bingen(0,(switchcount)/2,switchcount,ap1,deflab,size,switchids,switchlabels,switchbinlabels);
  342. freeop(ap1);
  343. }
  344. void gencompactswitch(SNODE *stmt, int deflab)
  345. {       int             tablab,curlab,i, size = natural_size(stmt->exp);
  346.         AMODE    *ap,*ap2;
  347.   long switchbottom=gswitchbottom, switchcount=gswitchcount;
  348.   long switchtop=gswitchtop;
  349.   int *switchlabels=0;
  350. tablab = nextlabel++;
  351.         curlab = nextlabel++;
  352.         initstack();
  353.         ap = gen_expr(stmt->exp,F_DREG | F_VOL,4);
  354. initstack();
  355. if (switchbottom)
  356. gen_code(op_sub,4,ap,make_immed(switchbottom));
  357. if (size < 0)
  358. gen_code(op_jl,0,make_label(deflab),0);
  359. else
  360. gen_code(op_jb,0,make_label(deflab),0);
  361. gen_code(op_cmp,4,ap,make_immed(switchtop-switchbottom));
  362. if (size < 0)
  363. gen_code(op_jge,0,make_label(deflab),0);
  364. else
  365. gen_code(op_jnc,0,make_label(deflab),0);
  366. gen_code(op_shl,4,ap,make_immed(2));
  367. ap2 = xalloc(sizeof(AMODE));
  368. ap->mode = am_indisp;
  369. ap2->preg = ap->preg;
  370. ap->offset = makenode(en_labcon,(char *)tablab,0);
  371. gen_code(op_jmp,4,ap,0);
  373. initstack();
  374. align(4);
  375. gen_label(tablab);
  376. switchlabels = xalloc((switchtop-switchbottom) * sizeof(int));
  377. for (i=switchbottom; i < switchtop; i++) {
  378. switchlabels[i-switchbottom] = deflab;
  379. }
  380. stmt = stmt->s1;
  381. while (stmt) {
  382.                 if( stmt->s2 )          /* default case ? */
  383.                         {
  384.                         stmt->label = (SNODE *)deflab;
  385. diddef = TRUE;
  386.                         }
  387.                 else
  388.                         {
  389. switchlabels[(int)stmt->label-switchbottom] = curlab;
  390. stmt->label = (SNODE *)curlab;
  391.                         }
  392.                 if(stmt->next != 0 )
  393.                         curlab = nextlabel++;
  394.                 stmt = stmt->next;
  395.                 }
  396. for (i=0; i < switchtop-switchbottom; i++)
  397. gen_code(op_dd,4,make_label(switchlabels[i]),0);
  398. }
  400. void gencase(SNODE *stmt)
  401. /*
  402.  *      generate all cases for a switch statement.
  403.  */
  404. {       while( stmt != 0 )
  405.                 {
  406.                 gen_label((int)stmt->label);
  407.                 if( stmt->s1 != 0 )
  408.                         {
  409.                         genstmt(stmt->s1);
  410.                         }
  412.                 stmt = stmt->next;
  413.                 }
  414. }
  416. void genxswitch(SNODE *stmt)
  417. /*
  418.  *      analyze and generate best switch statement.
  419.  */
  420. {       int     oldbreak;
  421. int olddiddef = diddef;
  422. int deflab = nextlabel++;
  423.         oldbreak = breaklab;
  424.         breaklab = nextlabel++;
  425. diddef = FALSE;
  426. switch (analyzeswitch(stmt)) {
  427.    case 2:
  428. genbinaryswitch(stmt,deflab);
  429. break;
  430. case 1:
  431. gencompactswitch(stmt,deflab);
  432. break;
  433. case 0:
  434. if (stmt->s1)
  435. stmt->s1->label = (SNODE *) nextlabel++;
  436. break;
  437. }
  438.         gencase(stmt->s1);
  439. if (!diddef)
  440. gen_label(deflab);
  441.         gen_label(breaklab);
  442.         breaklab = oldbreak;
  443. diddef = olddiddef;
  444. }
  446. void genreturn(SNODE *stmt, int flag)
  447. /*
  448.  *      generate a return statement.
  449.  */
  450. {       AMODE    *ap,*ap1;
  451. int size;
  452.         if( stmt != 0 && stmt->exp != 0 ) {
  453.                 initstack();
  454. if (currentfunc->tp->btp && currentfunc->tp->btp->type != bt_void && (currentfunc->tp->btp->type == bt_struct || currentfunc->tp->btp->type == bt_union)) {
  455. size = currentfunc->tp->btp->size;
  456. ap = gen_expr(stmt->exp,F_ALL,4);
  457. if (!(save_mask & 0x40))
  458. gen_push(ESI,am_dreg,0);                                  
  459. if (!(save_mask & 0x80))
  460. gen_push(EDI,am_dreg,0);                                  
  461. if (prm_linkreg) {
  462. ap1 = xalloc(sizeof(AMODE));
  463. ap1->preg = EBP;
  464. ap1->mode = am_indisp;
  465. if (currentfunc->pascaldefn && currentfunc->tp->lst.head && currentfunc->tp->lst.head != (SYM *) -1) 
  466. ap1->offset = makenode(en_icon,(char *)(currentfunc->tp->lst.head->value.i+((currentfunc->tp->lst.head->tp->size+3) &0xFFFFFFFCL)),0);
  467. else
  468. ap1->offset = makenode(en_icon,(char *)8,0);
  469. }
  470. else
  471. if (currentfunc->pascaldefn && currentfunc->tp->lst.head && currentfunc->tp->lst.head != (SYM *) -1) 
  472. ap1 = make_stack(-stackdepth-framedepth-currentfunc->tp->lst.head->value.i-((currentfunc->tp->lst.head->tp->size+3) & 0xfffffffcL));
  473. else
  474. ap1 = make_stack(-stackdepth-framedepth);
  475. gen_code(op_mov,4,makedreg(ESI),ap);                   
  476. gen_code(op_mov,4,makedreg(EDI),ap1);
  477. gen_code(op_mov,4,makedreg(EAX),makedreg(EDI));
  478. gen_code(op_mov,4,makedreg(ECX),make_immed(size));  
  479. gen_code(op_cld,0,0,0);
  480. gen_code(op_rep,1,0,0);                                   
  481. gen_code(op_movsb,1,0,0);                               
  482. if (!(save_mask & 0x80))
  483. gen_pop(EDI,am_dreg,0);
  484. if (!(save_mask & 0x40))
  485. gen_pop(ESI,am_dreg,0);
  486. }
  487. else {
  488. size = currentfunc->tp->btp->size;
  489.                  ap = gen_expr(stmt->exp,F_DREG | F_FREG,size);
  490. if (size > 4) {
  491. if (ap->mode != am_freg)
  492. gen_code(op_fld,size,ap,0);
  493. }
  494.                  else
  495.                   if( ap->mode != am_dreg || ap->preg != 0 )
  496.                          gen_code(op_mov,size,makedreg(0),ap);
  497.                 }
  498. freeop(ap);
  499. }
  500. if (flag) {
  501.         if( retlab != -1 )
  502.                 gen_label(retlab);
  503.           if( fsave_mask != 0 )
  504. diag("Float restore in return");
  505. if (!prm_linkreg && lc_maxauto)
  506. gen_code(op_add,4,makedreg(ESP),make_immed(lc_maxauto));
  507. if (currentfunc->intflag) {
  508. gen_code(op_popad,0,0,0);
  509. if (prm_linkreg && (lc_maxauto || currentfunc->tp->lst.head && currentfunc->tp->lst.head != (SYM *)-1)) {
  510. gen_code(op_leave,0,0,0);
  511. }
  512.             gen_code(op_iretd,0,0,0);
  513. }
  514. else {
  515.             if( save_mask != 0 )
  516. popregs(save_mask);
  517. if (prm_linkreg && (lc_maxauto || currentfunc->tp->lst.head && currentfunc->tp->lst.head != (SYM *)-1)) {
  518. gen_code(op_leave,0,0,0);
  519. }
  520. if (currentfunc->pascaldefn) {
  521. long retsize = 0;
  522. if (currentfunc->tp->lst.head && currentfunc->tp->lst.head != (SYM *)-1) {
  523. retsize = currentfunc->tp->lst.head->value.i+((currentfunc->tp->lst.head->tp->size + 3) & 0xfffffffcL);
  524. if (prm_linkreg)
  525. retsize -= 8;
  526. }
  527. if (currentfunc->tp->btp && currentfunc->tp->btp->type != bt_void && (currentfunc->tp->btp->type == bt_struct || currentfunc->tp->btp->type == bt_union)) 
  528. retsize += 4;
  529. if (retsize) {
  530.              gen_code(op_ret,0,make_immed(retsize),0);
  531. return;
  532. }
  533. }
  534.             gen_code(op_ret,0,0,0);
  535. }
  536. }
  537.         else {
  538. if (retlab == -1)
  539.             retlab = nextlabel++;
  540.           gen_code(op_jmp,0,make_label(retlab),0);
  541. }
  542. }
  544. void genstmt(SNODE *stmt)
  545. /*
  546.  *      genstmt will generate a statement and follow the next pointer
  547.  *      until the block is generated.
  548.  */
  549. {
  550.    while( stmt != 0 )
  551.                 {
  552.                 switch( stmt->stype )
  553.                         {
  554. case st_block:
  555. genstmt(stmt->exp);
  556. break;
  557.                         case st_label:
  558.                                 gen_label((int)stmt->label);
  559.                                 break;
  560.                         case st_goto:
  561.                                 gen_code(op_jmp,0,make_label((int)stmt->label),0);
  562.                                 break;
  563.                         case st_expr:
  564.                                 initstack();
  565.                                 gen_expr(stmt->exp,F_ALL | F_NOVALUE,
  566.                                         natural_size(stmt->exp));
  567.                                 break;
  568.                         case st_return:
  569.                                 genreturn(stmt,0);
  570.                                 break;
  571.                         case st_if:
  572.                                 genif(stmt);
  573.                                 break;
  574.                         case st_while:
  575.                                 genwhile(stmt);
  576.                                 break;
  577.                         case st_do:
  578.                                 gendo(stmt);
  579.                                 break;
  580.                         case st_for:
  581.                                 gen_for(stmt);
  582.                                 break;
  583.                         case st_continue:
  584.                                 gen_code(op_jmp,0,make_label(contlab),0);
  585.                                 break;
  586.                         case st_break:
  587.                                 gen_code(op_jmp,0,make_label(breaklab),0);
  588.                                 break;
  589.                         case st_switch:
  590.                                 genxswitch(stmt);
  591.                                 break;
  592. case st_line:
  593.   gen_line(stmt);
  594. break;
  595. case st_asm:
  596. if (stmt->exp)
  597. add_peep(stmt->exp);
  598. break;
  599. case st__genword:
  600. gen_code(op_genword,0,make_immed((int)stmt->exp),0);
  601. break;
  602.                         default:
  604.                                 diag("unknown statement.");
  605.                                 break;
  606.                         }
  607.                 stmt = stmt->next;
  608.                 }
  609. }
  610. #ifdef CPLUSPLUS
  611. void scppinit(void)
  612. {
  613. if (!strcmp(currentfunc->name,"_main")) {
  614. AMODE *ap1,*ap2,*ap3,*ap4;
  615. int lbl = nextlabel++;
  616. initstack();
  617. ap1 = temp_data();
  618. ap4 = xalloc(sizeof(AMODE));
  619. ap4->preg = ap1->preg;
  620. ap4->mode = am_indisp;
  621. ap4->offset = makenode(en_icon,0,0);
  622. ap2 = set_symbol("cppistart",0);
  623. ap3 = set_symbol("cppiend",0);
  624. gen_code(op_mov,4,ap1,ap2);
  625. gen_label(lbl);
  626. gen_code(op_push,4,ap1,0);
  627. gen_code(op_call,4,ap4,0);
  628. gen_code(op_pop,4,ap1,0);
  629. gen_code(op_add,4,ap1,make_immed(4));
  630. gen_code(op_cmp,4,ap1,ap3);
  631. gen_code(op_jb,0,make_label(lbl),0);
  632. freeop(ap1);
  633. }
  634. }
  635. #endif
  636. void genfunc(SNODE *stmt)
  637. /*
  638.  *      generate a function body.
  639.  */
  640. {       retlab = contlab = breaklab = -1;
  641. funcfloat = 0;
  642. init_muldivval();
  643. stackdepth = 0;
  644. if (stmt->stype == st_line) {
  645. gen_line(stmt);
  646. stmt = stmt->next;
  647. }
  649. gen_codelab(currentfunc);  /* name of function */
  650.         opt1(stmt); /* push args & also subtracts SP */
  651. #ifdef CPLUSPLUS
  652. if (prm_cplusplus)
  653. scppinit();
  654. #endif
  655.         genstmt(stmt);
  656.         genreturn(0,1);
  657. }