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

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

编译器/解释器

开发平台：

Others

OPTIMIZE.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.  * this module combines constants at compile time.  Integer constants
  24.  * will get combined slightly better than floating point ones
  25.  */
  26. #include        <stdio.h>
  27. #include        "expr.h"
  28. #include        "c.h"
  30. int maxinttype(ENODE *ep1, ENODE *ep2)
  31. {
  32. int type1=ep1->nodetype;
  33. int type2 = ep2->nodetype;
  34. if (type1 == en_lucon || type2 == en_lucon)
  35. return en_lucon;
  36. if (type1 == en_lcon || type2 == en_lcon)
  37. return en_lcon;
  38. if (type1 == en_iucon || type2 == en_iucon)
  39. return en_iucon;
  40. if (type1 == en_icon || type2 == en_icon)
  41. return en_icon;
  42. return en_ccon;
  43. }
  44. int maxfloattype(ENODE *ep1, ENODE *ep2)
  45. {
  46. int type1=ep1->nodetype;
  47. int type2 = ep2->nodetype;
  48. if (type1 == en_lrcon || type2 == en_lrcon)
  49. return en_lrcon;
  50. if (type1 == en_rcon || type2 == en_rcon)
  51. return en_rcon;
  52. return en_fcon;
  53. }
  54. int getmode(ENODE *ep1,ENODE *ep2)
  55. /*
  56.  * get the constant mode of a pair of nodes
  57.  * 0 = Neither node is a constant
  58.  * 1 = icon,icon
  59.  * 2 = icon,rcon
  60.  * 3 = rcon,icon
  61.  * 4 = rcon,rcon
  62.  * 5 = icon,nothing
  63.  * 6 = rcon,nothing
  64.  * 7 = nothing,icon
  65.  * 8 = nothing,rcon
  66.  */
  67. {
  68. int mode = 0;
  69. if (isintconst(ep1->nodetype) )
  70. if (ep2)  {
  71. if (isintconst(ep2->nodetype))
  72. mode = 1;
  73. else  if (ep2->nodetype == en_rcon || ep2->nodetype == en_lrcon || ep2->nodetype == en_fcon)
  74. mode = 2;
  75. else mode = 5;
  76. }
  77. else
  78. mode = 5;
  79. else if (ep1->nodetype == en_rcon || ep1->nodetype == en_lrcon || ep1->nodetype == en_fcon)
  80. if (ep2)  {
  81. if (isintconst(ep2->nodetype))
  82. mode = 3;
  83. else  if (ep2->nodetype == en_rcon || ep2->nodetype == en_lrcon || ep2->nodetype == en_fcon)
  84. mode = 4;
  85. else mode = 6;
  86. }
  87. else
  88. mode = 6;
  89. else if (ep2)
  90. if (isintconst(ep2->nodetype))
  91. mode = 7;
  92. else  if (ep2->nodetype == en_rcon || ep2->nodetype == en_lrcon || ep2->nodetype == en_fcon)
  93. mode = 8;
  94. return(mode);
  95. }
  97. void dooper(ENODE ** node, int mode)
  98. /*
  99.  *      dooper will execute a constant operation in a node and
  100.  *      modify the node to be the result of the operation.
  101.  * It will also cast integers to floating point values when
  102.  * necessary
  103.  */                             
  104. {     ENODE    *ep,*ep1,*ep2;
  105.       ep = *node;
  106. ep1 = ep->v.p[0];
  107. ep2 = ep->v.p[1];
  108. if (mode ==5) {
  109. if (floatrecurse(ep2)) {
  110. ep1->v.f = ep1->v.i;
  111. ep1->nodetype = en_rcon;
  112. }
  113. return;
  114. }
  115. else if (mode == 7) {
  116. if (floatrecurse(ep1)) {
  117. ep2->v.f = ep2->v.i;
  118. ep2->nodetype = en_rcon;
  119. }
  120. return;
  121. }
  122. else if (mode == 6 || mode == 8)
  123. return;
  124. else
  125.         switch( ep->nodetype ) {
  126.                 case en_add:
  127.   switch (mode) {
  128. case 1:
  129.                          ep->nodetype = maxinttype(ep1,ep2);
  130.                          ep->v.i = ep1->v.i + ep2->v.i;
  131. break;
  132. case 2:
  133.                          ep->nodetype = maxfloattype(ep1,ep2);
  134.                          ep->v.f = ep1->v.i + ep2->v.f;
  135. break;
  136. case 3:
  137.                          ep->nodetype = maxfloattype(ep1,ep2);
  138.                          ep->v.f = ep1->v.f + ep2->v.i;
  139. break;
  140. case 4:
  141.                          ep->nodetype = maxfloattype(ep1,ep2);
  142.                          ep->v.f = ep1->v.f + ep2->v.f;
  143. break;
  144.                         }
  145. break;
  146.                 case en_sub:
  147.   switch (mode) {
  148. case 1:
  149.                          ep->nodetype = maxinttype(ep1,ep2);
  150.                          ep->v.i = ep1->v.i - ep2->v.i;
  151. break;
  152. case 2:
  153.                          ep->nodetype = maxfloattype(ep1,ep2);
  154.                          ep->v.f = ep1->v.i - ep2->v.f;
  155. break;
  156. case 3:
  157.                          ep->nodetype = maxfloattype(ep1,ep2);
  158.                          ep->v.f = ep1->v.f - ep2->v.i;
  159. break;
  160. case 4:
  161.                          ep->nodetype = maxfloattype(ep1,ep2);
  162.                          ep->v.f = ep1->v.f - ep2->v.f;
  163. break;
  164. }
  165.                         break;
  166. case en_pmul:
  167. case en_umul:
  168.                 case en_mul:
  169.   switch (mode) {
  170. case 1:
  171.                          ep->nodetype = maxinttype(ep1,ep2);
  172.                          ep->v.i = ep1->v.i * ep2->v.i;
  173. break;
  174. case 2:
  175.                          ep->nodetype = maxfloattype(ep1,ep2);
  176.                          ep->v.f = ep1->v.i * ep2->v.f;
  177. break;
  178. case 3:
  179.                          ep->nodetype = maxfloattype(ep1,ep2);
  180.                          ep->v.f = ep1->v.f * ep2->v.i;
  181. break;
  182. case 4:
  183.                          ep->nodetype = maxfloattype(ep1,ep2);
  184.                          ep->v.f = ep1->v.f * ep2->v.f;
  185. break;
  186. }
  187.                         break;
  188. case en_pdiv:
  189.                 case en_div:
  190.                 case en_udiv:
  191.   switch (mode) {
  192. case 1:
  193.                          ep->nodetype = maxinttype(ep1,ep2);
  194.                          ep->v.i = ep1->v.i / ep2->v.i;
  195. break;
  196. case 2:
  197.                          ep->nodetype = maxfloattype(ep1,ep2);
  198.                          ep->v.f = ep1->v.i / ep2->v.f;
  199. break;
  200. case 3:
  201.                          ep->nodetype = maxfloattype(ep1,ep2);
  202.                          ep->v.f = ep1->v.f / ep2->v.i;
  203. break;
  204. case 4:
  205.                          ep->nodetype = maxfloattype(ep1,ep2);
  206.                          ep->v.f = ep1->v.f / ep2->v.f;
  207. break;
  208. }
  209.                         break;
  210. case en_mod:
  211.                          ep->nodetype = maxinttype(ep1,ep2);
  212. ep->v.i = ep1->v.i % ep2->v.i;
  213. break;
  214.                 case en_lsh:
  215. case en_alsh:
  216.                          ep->nodetype = maxinttype(ep1,ep2);
  217.                         ep->v.i = ep1->v.i << ep2->v.i;
  218.                         break;
  219.                 case en_rsh:
  220. case en_arsh:
  221.                          ep->nodetype = maxinttype(ep1,ep2);
  222.                         ep->v.i = ep1->v.i >> ep2->v.i;
  223.                         break;
  224.                 case en_and:
  225.                          ep->nodetype = maxinttype(ep1,ep2);
  226.                         ep->v.i = ep1->v.i & ep2->v.i;
  227.                         break;
  228.                 case en_or:
  229.                          ep->nodetype = maxinttype(ep1,ep2);
  230.                         ep->v.i = ep1->v.i | ep2->v.i;
  231.                         break;
  232.                 case en_xor:
  233.                          ep->nodetype = maxinttype(ep1,ep2);
  234.                         ep->v.i = ep1->v.i ^ ep2->v.i;
  235.                         break;
  236.                 }
  237. }
  238. /*
  239.  * this stuff has been superceded by a lookup table
  240.  * I'll fix it eventually
  241.  */
  242. long     pwrof2(int i)
  243. /*
  244.  *      return which power of two i is or -1.
  245.  */
  246. {       long     p, q;
  247.         q = 2;
  248.         p = 1;
  249.         while( q > 0 )
  250.                 {
  251.                 if( q == i )
  252.                         return p;
  253.                 q <<= 1;
  254.                 ++p;
  255.                 }
  256.         return -1;
  257. }
  259. long     mod_mask(int i)
  260. /*
  261.  *      make a mod mask for a power of two.
  262.  */
  263. {       long     m;
  264.         m = 0;
  265.         while( i-- )
  266.                 m = (m << 1) | 1;
  267.         return m;
  268. }
  270. void opt0(ENODE ** node)
  271. /*
  272.  *      opt0 - delete useless expressions and combine constants.
  273.  *
  274.  *      opt0 will delete expressions such as x + 0, x - 0, x * 0,
  275.  *      x * 1, 0 / x, x / 1, x mod 0, etc from the tree pointed to
  276.  *      by node and combine obvious constant operations. It cannot
  277.  *      combine name and label constants but will combine icon type
  278.  *      nodes.
  279.  */
  280. {       ENODE    *ep;
  281.         int             sc,mode,val;
  282. double dval;
  283.         ep = *node;
  284.         if( ep == 0 )
  285.                 return;
  286.         switch( (*node)->nodetype ) {
  287.                 case en_b_ref:
  288.                 case en_w_ref:          /* optimize unary node */
  289.                 case en_ub_ref:
  290.                 case en_uw_ref:          /* optimize unary node */
  291.                 case en_l_ref:
  292. case en_ul_ref:
  293. case en_floatref: case en_doubleref: case en_longdoubleref:
  294. case en_cb: case en_cub:
  295. case en_cw: case en_cuw:
  296. case en_cl: case en_cul:
  297. case en_cf: case en_cd: case en_cp: case en_bits: case en_cld:
  298. case en_ainc:
  299. case en_adec:
  300. case en_not:
  301. case en_compl:
  302.                         opt0( &((*node)->v.p[0]));
  303.                         return;
  304.                 case en_uminus:
  305.                         opt0( &(ep->v.p[0]));
  306.                         if( isintconst(ep->v.p[0]->nodetype))
  307.                                 {
  308.                                 ep->nodetype = ep->v.p[0]->nodetype;
  309.                                 ep->v.i = -ep->v.p[0]->v.i;
  310.                                 }
  311.                         else if( ep->v.p[0]->nodetype == en_rcon || ep->v.p[0]->nodetype == en_fcon || ep->v.p[0]->nodetype == en_lrcon)
  312.                                 {
  313.                                 ep->nodetype = ep->v.p[0]->nodetype;
  314.                                 ep->v.i = -ep->v.p[0]->v.f;
  315.                                 }
  316.                         return;
  317.                 case en_add:
  318.                 case en_sub:
  319.                         opt0(&(ep->v.p[0]));
  320.                         opt0(&(ep->v.p[1]));
  321. mode = getmode(ep->v.p[0],ep->v.p[1]);
  322. switch (mode) {
  323. case 1: case 2: case 3: case 4:
  324. dooper(node,mode);
  325. break;
  326. case 5:
  327. if (ep->v.p[0]->v.i == 0) {
  328. if (ep->nodetype == en_sub) {
  329. *node = makenode(en_uminus,ep->v.p[1],0);
  330. }
  331. else *node = ep->v.p[1];
  332. }
  333. else dooper(node,mode);
  334. break;
  335. case 6:
  336. if (ep->v.p[0]->v.f == 0) {
  337. if (ep->nodetype == en_sub) {
  338. *node = ep->v.p[1];
  339. ep->v.p[1]->v.f = - ep->v.p[1]->v.f;
  341. }
  342. else *node = ep->v.p[1];
  343. }
  344. else dooper(node,mode);
  345. break;
  346.   case 7:
  347. if (ep->v.p[1]->v.i == 0) {
  348. *node = ep->v.p[0];
  349. }
  350. else dooper(node,mode);
  351. break;
  352. case 8:
  353. if (ep->v.p[1]->v.f == 0) {
  354. *node = ep->v.p[0];
  355. }
  356. else dooper(node,mode);
  357. break;
  358. }
  359.                         return;
  360.                 case en_mul:
  361. case en_umul:
  362. case en_pmul:
  363. case en_asmul: case en_asumul:
  364.                         opt0(&(ep->v.p[0]));
  365.                         opt0(&(ep->v.p[1]));
  366. mode = getmode(ep->v.p[0],ep->v.p[1]);
  367. switch(mode) {
  368. case 1: case 2: case 3: case 4:
  369. dooper(node,mode);
  370. break;
  371. case 5:
  372. if (!floatrecurse(ep->v.p[1])) {
  373.                                 sc = pwrof2(ep->v.p[0]->v.i);
  374.                                 if( sc != -1 )
  375.                                         {
  376. ENODE *temp = ep->v.p[0];
  377. ep->v.p[0 ] = ep->v.p[1];
  378. ep->v.p[1] = temp;
  379.                                         ep->v.p[1]->v.i = sc;
  380. switch(ep->nodetype) {
  381. case en_mul:
  382. ep->nodetype = en_alsh;
  383. break;
  384. case en_asmul:
  385. ep->nodetype = en_asalsh;
  386. break;
  387. case en_umul:
  388. case en_pmul:
  389. ep->nodetype = en_lsh;
  390. break;
  391. case en_asumul:
  392. ep->nodetype = en_aslsh;
  393. break;
  394. }
  395. break;
  396.                                         }
  397.                             }
  398. val = ep->v.p[0]->v.i;
  399. if (val == 0)
  400. *node = ep->v.p[0];
  401. else if (val == 1)
  402. *node = ep->v.p[1];
  403. else if (val == -1)
  404. *node = makenode(en_uminus,(char *)ep->v.p[1],0);
  405. else dooper(node,mode);
  406. break;
  407. case 6:
  408. dval = ep->v.p[0]->v.f;
  409. if (dval == 0)
  410. *node = ep->v.p[0];
  411. else if (dval == 1)
  412. *node = ep->v.p[1];
  413. else if (dval == -1)
  414. *node = makenode(en_uminus,(char *)ep->v.p[1],0);
  415. else dooper(node,mode);
  416. break;
  417. case 7:
  418. if (!floatrecurse(ep->v.p[0])) {
  419.                                 sc = pwrof2(ep->v.p[1]->v.i);
  420.                                 if( sc != -1 )
  421.                                         {
  422.                                         ep->v.p[1]->v.i = sc;
  423. switch(ep->nodetype) {
  424. case en_mul:
  425. ep->nodetype = en_alsh;
  426. break;
  427. case en_asmul:
  428. ep->nodetype = en_asalsh;
  429. break;
  430. case en_umul:
  431. case en_pmul:
  432. ep->nodetype = en_lsh;
  433. break;
  434. case en_asumul:
  435. ep->nodetype = en_aslsh;
  436. break;
  437. }
  438. break;
  439.                                         }
  440.                             }
  441. val = ep->v.p[1]->v.i;
  442. if (val == 0)
  443. *node = ep->v.p[1];
  444. else if (val == 1)
  445. *node = ep->v.p[0];
  446. else if (val == -1)
  447. *node = makenode(en_uminus,(char *)ep->v.p[0],0);
  448. else dooper(node,mode);
  449. break;
  450. case 8:
  451. dval = ep->v.p[1]->v.f;
  452. if (dval == 0)
  453. *node = ep->v.p[1];
  454. else if (dval == 1)
  455. *node = ep->v.p[0];
  456. else if (dval == -1)
  457. *node = makenode(en_uminus,(char *)ep->v.p[0],0);
  458. else dooper(node,mode);
  459. break;
  460. }
  461.                         break;
  462. case en_pdiv:
  463.                 case en_div:
  464. case en_udiv:
  465. case en_asdiv:
  466. case en_asudiv:
  467.                         opt0(&(ep->v.p[0]));
  468.                         opt0(&(ep->v.p[1]));
  469. mode = getmode(ep->v.p[0],ep->v.p[1]);
  470. switch(mode) {
  471. case 1:
  472. case 2:
  473. case 3:
  474. case 4: 
  475. dooper(node,mode);
  476. break;
  477. case 5:
  478. if (ep->v.p[0]->v.i == 0)
  479. *node = ep->v.p[0];
  480. else
  481. dooper(node,mode);
  482. break;
  483. case 6:
  484. if (ep->v.p[0]->v.f == 0)
  485. *node = ep->v.p[0];
  486. else
  487. dooper(node,mode);
  488. break;
  489. case 7:
  490. if (!floatrecurse(ep->v.p[0])) {
  491.                                 sc = pwrof2(ep->v.p[1]->v.i);
  492.                                 if( sc != -1 )
  493.                                         {
  494.                                         ep->v.p[1]->v.i = sc;
  495. switch(ep->nodetype) {
  496. case en_div:
  497. ep->nodetype = en_arsh;
  498. break;
  499. case en_asdiv:
  500. ep->nodetype = en_asarsh;
  501. break;
  502. case en_udiv:
  503. case en_pdiv:
  504. ep->nodetype = en_rsh;
  505. break;
  506. case en_asudiv:
  507. ep->nodetype = en_asrsh;
  508. break;
  509. }
  510. break;
  511.                                         }
  512.                             }
  513. val = ep->v.p[1]->v.i;
  514. if (val == 1)
  515. *node = ep->v.p[0];
  516. else if (val == -1)
  517. *node = makenode(en_uminus,(char *)ep->v.p[0],0);
  518. else dooper(node,mode);
  519. break;
  520. case 8:
  521. dval = ep->v.p[1]->v.f;
  522. if (dval == 1)
  523. *node = ep->v.p[0];
  524. else if (dval == -1)
  525. *node = makenode(en_uminus,(char *)ep->v.p[0],0);
  526. else dooper(node,mode);
  527. break;
  528. }
  529.                         break;
  530.                 case en_mod:
  531. case en_umod:
  532. case en_asmod: case en_asumod:
  533.                         opt0(&(ep->v.p[0]));
  534.                         opt0(&(ep->v.p[1]));
  535. mode = getmode(ep->v.p[0],ep->v.p[1]);
  536. switch(mode) {
  537. case 7:
  538. if (!floatrecurse(ep->v.p[0])) {
  539.                                 sc = pwrof2(ep->v.p[1]->v.i);
  540.                                 if( sc != -1 )
  541.                                         {
  542.                                         ep->v.p[1]->v.i = mod_mask(sc);
  543. if (ep->nodetype == en_asmod || ep->nodetype == en_asumod)
  544.                                          ep->nodetype = en_asand;
  545. else
  546.                                          ep->nodetype = en_and;
  547. break;
  548.                                         }
  549.                                 }
  550. case 1:
  551. case 2:
  552. case 3:
  553. case 4: 
  554. case 5: case 6: case 8:
  555. dooper(node,mode);
  556. }
  557.                         break;
  558.                 case en_and:    case en_or:
  559.                 case en_xor:    case en_rsh:
  560.                 case en_lsh:    case en_arsh: case en_alsh:
  561.                         opt0(&(ep->v.p[0]));
  562.                         opt0(&(ep->v.p[1]));
  563.                         if( isintconst(ep->v.p[0]->nodetype) &&
  564.                                 isintconst(ep->v.p[1]->nodetype) )
  565.                                 dooper(node,getmode(ep->v.p[0],ep->v.p[1]));
  566.                         break;
  567.                 case en_land:   case en_lor:
  568. case en_lt: case en_le:
  569. case en_ugt: case en_uge: case en_ult: case en_ule:
  570. case en_gt: case en_ge:
  571. case en_eq: case en_ne:
  572. case en_asalsh: case en_asarsh:
  573.                 case en_asand:  case en_asor:  case en_asxor:
  574.                 case en_asadd:  case en_assub:
  575.                 case en_asrsh:
  576.                 case en_aslsh:  case en_cond:
  577.                 case en_fcall:  case en_void: case en_trapcall: case en_intcall:
  578. case en_pfcall: case en_pfcallb:
  579.                 case en_assign: case en_moveblock: case en_stackblock: case en_callblock:
  580. case en_fcallb: case en_refassign: case en_pcallblock:
  581.                         opt0(&(ep->v.p[0]));
  582.                         opt0(&(ep->v.p[1]));
  583.                         break;
  584.                 }
  585. }
  586. long     xfold2(ENODE * node)
  587. /*
  588.  *      xfold2 will remove constant nodes and return the values to
  589.  *      the calling routines.
  590.  */
  591. {       long     i;
  592.         if( node == 0 )
  593.                 return 0;
  594.         switch( node->nodetype )
  595.                 {
  596.                 case en_icon:
  597. case en_lcon:
  598. case en_iucon:
  599. case en_lucon:
  600. case en_ccon:
  601.                         i = node->v.i;
  602.                         node->v.i = 0;
  603.                         return i;
  604.                 case en_add:
  605.                         return xfold2(node->v.p[0]) + xfold2(node->v.p[1]);
  606.                 case en_sub:
  607.                         return xfold2(node->v.p[0]) - xfold2(node->v.p[1]);
  608. case en_or:
  609.                         return xfold2(node->v.p[0]) | xfold2(node->v.p[1]);
  610. case en_xor:
  611.                         return xfold2(node->v.p[0]) ^ xfold2(node->v.p[1]);
  612.                 case en_uminus:
  613.                         return - xfold2(node->v.p[0]);
  614.                 case en_mul:
  615. case en_pmul:
  616. case en_umul:
  617.                 case en_lsh:
  618. case en_alsh:
  619. case en_asalsh: case en_asarsh: case en_arsh:
  620.                 case en_rsh:    case en_div:  case en_pdiv:
  621.                 case en_mod:    case en_asadd:
  622.                 case en_assub:  case en_asmul:
  623.                 case en_asdiv:  case en_asmod:
  624.                 case en_land: case en_lor:
  625.                 case en_asand: case en_and:
  626.                 case en_asor:   case en_void:  case en_asxor:
  627. case en_pfcall: case en_pfcallb:
  628.                 case en_fcall:  case en_assign: case en_moveblock: case en_trapcall:
  629. case en_stackblock: case en_intcall: case en_callblock: case en_fcallb:
  630. case en_asumul: case en_asudiv: case en_asumod: case en_refassign:
  631. case en_udiv: case en_pcallblock:
  632.                         fold_const2(&node->v.p[0]);
  633.                         fold_const2(&node->v.p[1]);
  634.                         return 0;
  635.                 case en_b_ref:  case en_w_ref:
  636.                 case en_ub_ref:  case en_uw_ref:
  637.                 case en_l_ref:  case en_compl: case en_ul_ref:
  638. case en_floatref: case en_doubleref: case en_longdoubleref:
  639.                 case en_not: case en_bits:
  640.                         fold_const2(&node->v.p[0]);
  641.                         return 0;
  642.                 }
  643.         return 0;
  644. }
  646. void fold_const2(ENODE ** node)
  647. /*
  648.  *      reorganize an expression for optimal constant grouping.
  649.  */
  650. {       ENODE    *ep;
  651.         long   i;
  652.         ep = *node;
  653.         if( ep == 0 )
  654.                 return;
  655. switch (ep->nodetype) {
  656. case en_add:
  657. if (ep->v.p[0]->nodetype == en_cp && isintconst(ep->v.p[0]->v.p[0]->nodetype)) {
  658. ep->v.p[0]->v.p[0]->v.i += xfold2(ep->v.p[1]);
  659. return;
  660. }
  661. else if (ep->v.p[1]->nodetype == en_cp && isintconst(ep->v.p[1]->v.p[0]->nodetype)) {
  662. ep->v.p[1]->v.p[0]->v.i += xfold2(ep->v.p[1]);
  663. return;
  664. }
  665.                 else if( isintconst(ep->v.p[0]->nodetype))
  666.                         {
  667.                         ep->v.p[0]->v.i += xfold2(ep->v.p[1]);
  668.                         return;
  669.                         }
  671.                 else if( isintconst(ep->v.p[1]->nodetype))
  672.                         {
  673.                         ep->v.p[1]->v.i += xfold2(ep->v.p[0]);
  674.                         return;
  675.                         }
  677. break;
  678. case en_sub:
  679. if (ep->v.p[0]->nodetype == en_cp && isintconst(ep->v.p[0]->v.p[0]->nodetype == en_icon)) {
  680. ep->v.p[0]->v.p[0]->v.i -= xfold2(ep->v.p[1]);
  681. return;
  682. }
  683. else if (ep->v.p[1]->nodetype == en_cp && isintconst(ep->v.p[1]->v.p[0]->nodetype)) {
  684. ep->v.p[1]->v.p[0]->v.i -= xfold2(ep->v.p[1]);
  685. return;
  686. }
  687.                 else if( isintconst(ep->v.p[0]->nodetype))
  688.                         {
  689.                         ep->v.p[0]->v.i -= xfold2(ep->v.p[1]);
  690.                         return;
  691.                         }
  692.                 else if( isintconst(ep->v.p[1]->nodetype))
  693.                         {
  694.                         ep->v.p[1]->v.i -= xfold2(ep->v.p[0]);
  695.                         return;
  696.                         }
  698. break;
  699. case en_or:
  700.                 if(isintconst( ep->v.p[0]->nodetype) )
  701.                         {
  702.                         ep->v.p[0]->v.i |= xfold2(ep->v.p[1]);
  703.                         return;
  704.                         }
  705.                 else if(isintconst( ep->v.p[1]->nodetype) )
  706.                         {
  707.                         ep->v.p[1]->v.i |= xfold2(ep->v.p[0]);
  708.                         return;
  709.                         }
  710. break;
  711. case en_xor:
  712.                 if( isintconst(ep->v.p[0]->nodetype))
  713.                         {
  714.                         ep->v.p[0]->v.i ^= xfold2(ep->v.p[1]);
  715.                         return;
  716.                         }
  717.                 else if( isintconst(ep->v.p[1]->nodetype))
  718.                         {
  719.                         ep->v.p[1]->v.i ^= xfold2(ep->v.p[0]);
  720.                         return;
  721.                         }
  722. break;
  723. }
  724.         i = xfold2(ep);
  725.         if( i != 0 ) {
  726. ep = xalloc(sizeof(ENODE));
  727. ep->nodetype = en_icon;
  728. ep->v.i = i;
  729.                  ep = makenode(en_add,ep,*node);
  730.                 *node = ep;
  731.         }
  732. }
  733. void opt4(ENODE ** node)
  734. /*
  735.  *      apply all constant optimizations.
  736.  */
  737. {
  738. opt0(node);
  739.         fold_const2(node);
  740.         opt0(node);
  741. }