Mercurial > hg > CbC > old > device

comparison mc-codegen.c @ 342:3e0b1183983d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
else if to switch
author kono
date Sat, 26 Jun 2004 12:35:35 +0900
parents ca34f02b2056
children 11f8f2e6bb72
comparison
equal deleted inserted replaced
341:ca34f02b2056 342:3e0b1183983d
491 code_bool(e1,USE_CREG); /* type? */ 491 code_bool(e1,USE_CREG); /* type? */
492 return INT; 492 return INT;
493 } 493 }
494 } 494 }
495 495
496 #define dual_ops(op) \
497 (op==GT|| op==UGT|| op==GE|| op==UGE|| op==LT|| \
498 op==ULT|| op==LE|| op==ULE|| \
499 op==DOP+GT|| op==DOP+GE|| op==DOP+LT|| op==DOP+LE || \
500 op==FOP+GT|| op==FOP+GE|| op==FOP+LT|| op==FOP+LE || \
501 op==FOP+EQ|| op==FOP+NEQ || \
502 op==EQ|| op==NEQ|| op==DOP+EQ|| op==DOP+NEQ)
503
504 static int 496 static int
505 rop_dual(op) 497 rop_dual(op)
506 { 498 {
507 // x op y => y dual(op) x 499 // x op y => y dual(op) x
508 switch(op) { 500 switch(op) {
541 bexpr_u(int e1, char cond, int l1) 533 bexpr_u(int e1, char cond, int l1)
542 { 534 {
543 int op = car(e1); 535 int op = car(e1);
544 if (chk) return; 536 if (chk) return;
545 // gexpr_init(); 537 // gexpr_init();
546 if (dual_ops(op) && (car(caddr(e1))==CONST||(car(caddr(e1))==DCONST))) 538 switch(op) {
547 b_expr(list3(rop_dual(op),caddr(e1),cadr(e1)),cond,l1,0); 539 case GT: case UGT: case GE: case UGE: case LT:
548 else 540 case ULT: case LE: case ULE:
549 b_expr(e1,cond,l1,0); 541 case DOP+GT: case DOP+GE: case DOP+LT: case DOP+LE:
542 case FOP+GT: case FOP+GE: case FOP+LT: case FOP+LE:
543 case FOP+EQ: case FOP+NEQ:
544 case EQ: case NEQ: case DOP+EQ: case DOP+NEQ:
545 if ((car(caddr(e1))==CONST||(car(caddr(e1))==DCONST))) {
546 b_expr(list3(rop_dual(op),caddr(e1),cadr(e1)),cond,l1,0);
547 return;
548 }
549 }
550 b_expr(e1,cond,l1,0);
550 } 551 }
551 552
552 /* bexpr for value used */ 553 /* bexpr for value used */
553 554
554 extern void 555 extern void
756 int reg = cadr(e); 757 int reg = cadr(e);
757 int tag = car(e); 758 int tag = car(e);
758 int lvar; 759 int lvar;
759 int t; 760 int t;
760 if (!n||n==&null_nptr) error(REG_ERR); 761 if (!n||n==&null_nptr) error(REG_ERR);
761 if (tag==REGISTER) { 762 switch(tag) {
762 n->dsp = new_lvar(size_of_int); 763 case REGISTER:
763 t = INT; 764 n->dsp = new_lvar(size_of_int); t = INT; break;
764 } else if (tag==DREGISTER) { 765 case DREGISTER:
765 n->dsp = new_lvar(size_of_double); 766 n->dsp = new_lvar(size_of_double); t = DOUBLE; break;
766 t = DOUBLE; 767 case FREGISTER:
767 } else if (tag==FREGISTER) { 768 n->dsp = new_lvar(size_of_float); t = DOUBLE; break;
768 n->dsp = new_lvar(size_of_float); 769 case LREGISTER:
769 t = DOUBLE; 770 n->dsp = new_lvar(size_of_longlong); t = LONGLONG; break;
770 } else if (tag==LREGISTER) { 771 default:
771 n->dsp = new_lvar(size_of_longlong); 772 error(-1);
772 t = LONGLONG; 773 }
773 } else error(-1);
774 n->sc = LVAR; 774 n->sc = LVAR;
775 lvar = list2(LVAR,n->dsp); 775 lvar = list2(LVAR,n->dsp);
776 g_expr_u(assign_expr0(list2(LVAR,n->dsp),list3(tag,reg,(int)n),t,t)); 776 g_expr_u(assign_expr0(list2(LVAR,n->dsp),list3(tag,reg,(int)n),t,t));
777 if (tag==REGISTER||tag==DREGISTER||tag==FREGISTER||tag==LREGISTER) { 777 if (tag==REGISTER||tag==DREGISTER||tag==FREGISTER||tag==LREGISTER) {
778 free_register(reg); 778 free_register(reg);
1002 */ 1002 */
1003 1003
1004 static int 1004 static int
1005 is_simple(int e1) 1005 is_simple(int e1)
1006 { 1006 {
1007 return ( 1007 switch(e1) {
1008 e1==CONST || e1==FNAME || e1==LVAR || e1==REGISTER ||e1==DREGISTER || 1008 case FREGISTER: case LREGISTER:
1009 e1==FREGISTER || e1==LREGISTER || 1009 case GVAR: case RGVAR: case RLVAR: case CRLVAR: case CRGVAR:
1010 e1==GVAR || e1==RGVAR || e1==RLVAR || e1==CRLVAR || e1==CRGVAR || 1010 case DRLVAR: case FRLVAR: case LRLVAR:
1011 e1==DRLVAR || e1==FRLVAR || e1==LRLVAR || 1011 case CURLVAR: case SURLVAR: case CURGVAR: case SURGVAR:
1012 e1==CURLVAR || e1==SURLVAR || e1==CURGVAR || e1==SURGVAR 1012 return 1;
1013 ); 1013 }
1014 return 0;
1014 } 1015 }
1015 1016
1016 static int 1017 static int
1017 is_same_type(int e1,int e2) 1018 is_same_type(int e1,int e2)
1018 { 1019 {
1019 int ce1=car(e1); 1020 int ce1=car(e1);
1020 int ce2=car(e2); 1021 int ce2=car(e2);
1021 return ( 1022 if (ce1==LVAR) {
1022 (ce1==LVAR && (ce2==RLVAR||ce2==CRLVAR||ce2==FRLVAR||ce2==DRLVAR)) 1023 switch(ce2) {
1023 || (ce1==LVAR && (ce2==SRLVAR||ce2==SURLVAR||ce2==CURLVAR)) 1024 case RLVAR: case CRLVAR: case FRLVAR: case DRLVAR:
1024 || (ce2==LVAR && (ce1==RLVAR||ce1==CRLVAR||ce1==FRLVAR||ce1==DRLVAR)) 1025 case SRLVAR: case SURLVAR: case CURLVAR:
1025 || (ce2==LVAR && (ce1==SRLVAR||ce1==SURLVAR||ce1==CURLVAR)) 1026 return 1;
1026 || (ce2==LVAR && (ce1==LRLVAR)) 1027 }
1027 || (ce1==GVAR && (ce2==RGVAR||ce2==CRGVAR||ce2==FRGVAR||ce2==DRGVAR)) 1028 } else if (ce2==LVAR) {
1028 || (ce1==GVAR && (ce2==SRGVAR||ce2==SURGVAR||ce2==CURGVAR)) 1029 switch(ce1) {
1029 || (ce2==GVAR && (ce1==RGVAR||ce1==CRGVAR||ce1==FRGVAR||ce1==DRGVAR)) 1030 case RLVAR: case CRLVAR: case FRLVAR: case DRLVAR:
1030 || (ce2==GVAR && (ce1==SRGVAR||ce1==SURGVAR||ce1==CURGVAR)) 1031 case SRLVAR: case SURLVAR: case CURLVAR: case LRLVAR:
1031 || (ce2==GVAR && (ce1==LRGVAR)) 1032 return 1;
1032 ); 1033 }
1034 } else if (ce1==GVAR) {
1035 switch(ce2) {
1036 case RGVAR: case CRGVAR: case FRGVAR: case DRGVAR:
1037 case SRGVAR: case SURGVAR: case CURGVAR:
1038 return 1;
1039 }
1040 } else if (ce2==GVAR) {
1041 switch(ce1) {
1042 case RGVAR: case CRGVAR: case FRGVAR: case DRGVAR:
1043 case SRGVAR: case SURGVAR: case CURGVAR: case LRGVAR:
1044 return 1;
1045 }
1046 }
1047 return 0;
1033 } 1048 }
1034 1049
1035 static int 1050 static int
1036 is_memory(int e1) 1051 is_memory(int e1)
1037 { 1052 {
1038 int ce1=car(e1); 1053 int ce1=car(e1);
1039 return ( 1054 switch(car(ce1)) {
1040 ce1==LVAR ||ce1==RLVAR||ce1==CRLVAR || ce1==DRLVAR || ce1==LRLVAR || 1055 case LVAR : case RLVAR: case CRLVAR : case DRLVAR : case LRLVAR :
1041 ce1==GVAR ||ce1==RGVAR||ce1==CRGVAR || ce1==DRGVAR || ce1==LRGVAR || 1056 case GVAR : case RGVAR: case CRGVAR : case DRGVAR : case LRGVAR :
1042 ce1==FRLVAR || ce1==FRGVAR || 1057 case FRLVAR : case FRGVAR :
1043 ce1==CURGVAR ||ce1==SURGVAR||ce1==SRGVAR || 1058 case CURGVAR : case SURGVAR: case SRGVAR :
1044 ce1==REGISTER|| ce1==DREGISTER || ce1==FREGISTER || 1059 case REGISTER : case DREGISTER : case FREGISTER :
1045 ce1==LREGISTER 1060 case LREGISTER:
1046 ); 1061 return 1;
1062 }
1063 return 0;
1047 } 1064 }
1048 1065
1049 1066
1050 static void 1067 static void
1051 jump(int e1, int env) 1068 jump(int e1, int env)
1323 e4 = caddr(e1);e5=car(e4); 1340 e4 = caddr(e1);e5=car(e4);
1324 if (is_same_type(e2,e4)&&cadr(e2)==cadr(e4)) { 1341 if (is_same_type(e2,e4)&&cadr(e2)==cadr(e4)) {
1325 if (use) g_expr(e4); 1342 if (use) g_expr(e4);
1326 return; 1343 return;
1327 } 1344 }
1328 if (!use && ( 1345 if (!use) {
1329 (e5==REGISTER) || 1346 if (e5==REGISTER) {
1330 (car(e2)==REGISTER&&( 1347 assign_opt(e5,e2,e4,byte);
1331 e5== CRGVAR || e5== CRLVAR || e5== RGVAR || e5== RLVAR || 1348 return;
1332 e5== CURGVAR || e5== CURLVAR || 1349 } else if (car(e2)==REGISTER) {
1333 e5== SURGVAR || e5== SURLVAR || 1350 switch(e5) {
1334 e5== GVAR || e5== LVAR || 1351 case ADDRESS:
1335 e5== CONST || e5== FNAME || e5== STRING || 1352 if (!((car(cadr(e4))==STRING) || car(cadr(e4))==GVAR))
1336 (e5==ADDRESS&&car(cadr(e4))==STRING) || 1353 break;
1337 (e5==ADDRESS&&car(cadr(e4))==GVAR) )))) { 1354 case CRGVAR : case CRLVAR : case RGVAR : case RLVAR :
1338 assign_opt(e5,e2,e4,byte); 1355 case CURGVAR : case CURLVAR :
1339 return; 1356 case SURGVAR : case SURLVAR :
1357 case GVAR : case LVAR :
1358 case CONST : case FNAME : case STRING :
1359 assign_opt(e5,e2,e4,byte);
1360 return;
1361 }
1362 }
1340 } 1363 }
1341 switch(car(e2)) { 1364 switch(car(e2)) {
1342 case GVAR: /* i=3 */ 1365 case GVAR: /* i=3 */
1343 g_expr(e4); 1366 g_expr(e4);
1344 code_assign_gvar(e2,USE_CREG,byte); 1367 code_assign_gvar(e2,USE_CREG,byte);
1415 return; 1438 return;
1416 } 1439 }
1417 if (car(e1)==DASS) d=1; 1440 if (car(e1)==DASS) d=1;
1418 else if (car(e1)==FASS) d=0; 1441 else if (car(e1)==FASS) d=0;
1419 else error(-1); 1442 else error(-1);
1420 if (!use && ( 1443 if (!use) {
1421 (e5==DREGISTER) || (e5==FREGISTER) || 1444 switch(e5) {
1422 (car(e2)==DREGISTER&&(e5==DRGVAR||e5==DRLVAR||e5==DCONST))|| 1445 case DRGVAR: case DRLVAR: case DCONST:
1423 (car(e2)==FREGISTER&&(e5==FRGVAR||e5==FRLVAR||e5==FCONST)) 1446 if (car(e2)!=DREGISTER) break;
1424 )) { 1447 dassign_opt(e5,e2,e4,d); return;
1425 dassign_opt(e5,e2,e4,d); 1448 case FRGVAR: case FRLVAR: case FCONST:
1426 return; 1449 if (car(e2)!=FREGISTER) break;
1450 case DREGISTER: case FREGISTER:
1451 dassign_opt(e5,e2,e4,d); return;
1452 }
1427 } 1453 }
1428 switch(car(e2)) { 1454 switch(car(e2)) {
1429 case GVAR: 1455 case GVAR:
1430 g_expr(e4); 1456 g_expr(e4);
1431 code_dassign_gvar(e2,USE_CREG,d); 1457 code_dassign_gvar(e2,USE_CREG,d);
1536 1562
1537 static int 1563 static int
1538 double_value(int e2) 1564 double_value(int e2)
1539 { 1565 {
1540 if (type>0&&car(type)==BIT_FIELD) e2=rvalue(e2); 1566 if (type>0&&car(type)==BIT_FIELD) e2=rvalue(e2);
1541 if (0) ;
1542 #if FLOAT_CODE 1567 #if FLOAT_CODE
1568 switch(car(e2)) {
1569 case LCONST:
1543 #if LONGLONG_CODE 1570 #if LONGLONG_CODE
1544 else if (car(e2)==LCONST) e2 = dlist2(DCONST,(double)lcadr(e2)); 1571 e2 = dlist2(DCONST,(double)lcadr(e2)); break;
1545 #endif 1572 #endif
1546 else if (car(e2)==CONST) e2 = dlist2(DCONST,(double)cadr(e2)); 1573 case CONST:
1547 else if (car(e2)==FCONST) e2 = dlist2(DCONST,dcadr(e2)); 1574 e2 = dlist2(DCONST,(double)cadr(e2)); break;
1548 else if(type==DOUBLE) ; 1575 case FCONST:
1549 else if(type==FLOAT) e2 = list3(CONV,rvalue(e2),F2D); 1576 e2 = dlist2(DCONST,dcadr(e2)); break;
1550 else if(type==UNSIGNED) e2 = list3(CONV,rvalue(e2),U2D); 1577 default:
1551 else if(integral(type)) e2 = list3(CONV,rvalue(e2),I2D); 1578 switch(type) {
1552 else if(type==LONGLONG) e2 = list3(CONV,rvalue(e2),LL2D); 1579 case DOUBLE: break;
1553 else if(type==ULONGLONG) e2 = list3(CONV,rvalue(e2),ULL2D); 1580 case FLOAT: e2 = list3(CONV,rvalue(e2),F2D); break;
1554 else { error(TYERR); e2 = dlist2(DCONST,1.0); } 1581 case INT:
1582 case UNSIGNED: e2 = list3(CONV,rvalue(e2),U2D); break;
1583 case LONGLONG: e2 = list3(CONV,rvalue(e2),LL2D); break;
1584 case ULONGLONG: e2 = list3(CONV,rvalue(e2),ULL2D); break;
1585 default:
1586 if(integral(type)) e2 = list3(CONV,rvalue(e2),I2D);
1587 else { error(TYERR); e2 = dlist2(DCONST,1.0); }
1588 }
1589 }
1555 #else 1590 #else
1556 else { error(TYERR); type = DOUBLE; return list2(CONST,0); } 1591 error(TYERR); type = DOUBLE; return list2(CONST,0);
1557 #endif 1592 #endif
1558 type = DOUBLE; 1593 type = DOUBLE;
1559 return e2; 1594 return e2;
1560 } 1595 }
1561 1596
1566 if (0) ; 1601 if (0) ;
1567 #if FLOAT_CODE 1602 #if FLOAT_CODE
1568 #if LONGLONG_CODE 1603 #if LONGLONG_CODE
1569 else if (car(e2)==LCONST) e2 = dlist2(FCONST,(double)lcadr(e2)); 1604 else if (car(e2)==LCONST) e2 = dlist2(FCONST,(double)lcadr(e2));
1570 #endif 1605 #endif
1571 else if(type==LONGLONG) e2 = list3(CONV,rvalue(e2),LL2F);
1572 else if(type==ULONGLONG) e2 = list3(CONV,rvalue(e2),ULL2F);
1573 else if (car(e2)==CONST) e2 = dlist2(FCONST,(double)cadr(e2)); 1606 else if (car(e2)==CONST) e2 = dlist2(FCONST,(double)cadr(e2));
1574 else if (car(e2)==DCONST) e2 = dlist2(FCONST,dcadr(e2)); 1607 else if (car(e2)==DCONST) e2 = dlist2(FCONST,dcadr(e2));
1575 else if(type==FLOAT) ; 1608 else {
1576 else if(type==DOUBLE) e2 = list3(CONV,rvalue(e2),D2F); 1609 switch(type) {
1577 else if(type==UNSIGNED) e2 = list3(CONV,rvalue(e2),U2F); 1610 case LONGLONG: e2 = list3(CONV,rvalue(e2),LL2F); break;
1578 else if(integral(type)) e2 = list3(CONV,rvalue(e2),I2F); 1611 case ULONGLONG: e2 = list3(CONV,rvalue(e2),ULL2F); break;
1579 else { error(TYERR); e2 = dlist2(DCONST,1.0); } 1612 case FLOAT: break;
1613 case DOUBLE: e2 = list3(CONV,rvalue(e2),D2F); break;
1614 case INT:
1615 case UNSIGNED: e2 = list3(CONV,rvalue(e2),U2F); break;
1616 default:
1617 if(integral(type)) e2 = list3(CONV,rvalue(e2),I2F);
1618 else { error(TYERR); e2 = dlist2(DCONST,1.0); }
1619 }
1620 }
1580 #else 1621 #else
1581 else { error(TYERR); e2 = list2(CONST,0); } 1622 else { error(TYERR); e2 = list2(CONST,0); }
1582 #endif 1623 #endif
1583 type = FLOAT; 1624 type = FLOAT;
1584 return e2; 1625 return e2;
1593 else if (car(e2)==CONST) e2 = llist2(LCONST,(long long)cadr(e2)); 1634 else if (car(e2)==CONST) e2 = llist2(LCONST,(long long)cadr(e2));
1594 else if (car(e2)==LCONST) ; 1635 else if (car(e2)==LCONST) ;
1595 #if FLOAT_CODE 1636 #if FLOAT_CODE
1596 else if (car(e2)==DCONST||car(e2)==FCONST) 1637 else if (car(e2)==DCONST||car(e2)==FCONST)
1597 e2 = llist2(LCONST,(long long)dcadr(e2)); 1638 e2 = llist2(LCONST,(long long)dcadr(e2));
1598 else if(type==FLOAT) e2 = list3(CONV,rvalue(e2),F2LL); 1639 #endif
1599 else if(type==DOUBLE) e2 = list3(CONV,rvalue(e2),D2LL); 1640 else {
1600 #endif 1641 switch(type) {
1601 else if(type==UNSIGNED) e2 = list3(CONV,rvalue(e2),U2LL); 1642 case FLOAT: e2 = list3(CONV,rvalue(e2),F2LL); break;
1602 else if(type==LONGLONG) e2 = e2; 1643 case DOUBLE: e2 = list3(CONV,rvalue(e2),D2LL); break;
1603 else if(type==ULONGLONG) e2 = e2; 1644 case UNSIGNED: e2 = list3(CONV,rvalue(e2),U2LL); break;
1604 else if(integral(type)) e2 = list3(CONV,rvalue(e2),I2LL); 1645 case LONGLONG: break;
1605 else { error(TYERR); e2 = llist2(LCONST,0LL); } 1646 case ULONGLONG: break;
1647 default:
1648 if(integral(type)) e2 = list3(CONV,rvalue(e2),I2LL);
1649 else { error(TYERR); e2 = llist2(LCONST,0LL); }
1650 }
1651 }
1606 #else 1652 #else
1607 else { error(TYERR); e2 = list2(CONST,0); } 1653 else { error(TYERR); e2 = list2(CONST,0); }
1608 #endif 1654 #endif
1609 type = LONGLONG; 1655 type = LONGLONG;
1610 return e2; 1656 return e2;
1619 else if (car(e2)==CONST) e2 = llist2(LCONST,(unsigned long long)cadr(e2)); 1665 else if (car(e2)==CONST) e2 = llist2(LCONST,(unsigned long long)cadr(e2));
1620 else if (car(e2)==LCONST) ; 1666 else if (car(e2)==LCONST) ;
1621 #if FLOAT_CODE 1667 #if FLOAT_CODE
1622 else if (car(e2)==DCONST||car(e2)==FCONST) 1668 else if (car(e2)==DCONST||car(e2)==FCONST)
1623 e2 = llist2(LCONST,(unsigned long long)dcadr(e2)); 1669 e2 = llist2(LCONST,(unsigned long long)dcadr(e2));
1624 else if(type==FLOAT) e2 = list3(CONV,rvalue(e2),F2ULL); 1670 #endif
1625 else if(type==DOUBLE) e2 = list3(CONV,rvalue(e2),D2ULL); 1671 else {
1626 #endif 1672 switch(type) {
1627 else if(type==UNSIGNED) e2 = list3(CONV,rvalue(e2),U2ULL); 1673 case FLOAT: e2 = list3(CONV,rvalue(e2),F2ULL); break;
1628 else if(type==LONGLONG) ; 1674 case DOUBLE: e2 = list3(CONV,rvalue(e2),D2ULL); break;
1629 else if(type==ULONGLONG) ; 1675 case UNSIGNED: e2 = list3(CONV,rvalue(e2),U2ULL); break;
1630 else if(integral(type)) e2 = list3(CONV,rvalue(e2),I2ULL); 1676 case LONGLONG: break;
1631 else { error(TYERR); e2 = llist2(LCONST,0LL); } 1677 case ULONGLONG: break;
1678 default:
1679 if(integral(type)) e2 = list3(CONV,rvalue(e2),I2ULL);
1680 else { error(TYERR); e2 = llist2(LCONST,0LL); }
1681 }
1682 }
1632 #else 1683 #else
1633 else unsigned_value(e2); 1684 else unsigned_value(e2);
1634 #endif 1685 #endif
1635 type = ULONGLONG; 1686 type = ULONGLONG;
1636 return e2; 1687 return e2;
1638 1689
1639 static int 1690 static int
1640 int_value(int e2) 1691 int_value(int e2)
1641 { 1692 {
1642 if (type>0&&car(type)==BIT_FIELD) e2=rvalue(e2); 1693 if (type>0&&car(type)==BIT_FIELD) e2=rvalue(e2);
1694 if (0);
1695 else if(type>0&&car(type)==ARRAY) return e2;
1696 else if(scalar(type)) return e2;
1697 #if FLOAT_CODE
1698 else if (car(e2)==DCONST||car(e2)==FCONST) e2 = list2(CONST,(int)dcadr(e2));
1699 #endif
1700 #if LONGLONG_CODE
1701 else if (car(e2)==LCONST) e2 = list2(CONST,(int)lcadr(e2));
1702 #endif
1703 else {
1704 switch(type) {
1705 case FLOAT: e2 = list3(CONV,rvalue(e2),F2I); break;
1706 case DOUBLE: e2 = list3(CONV,rvalue(e2),D2I); break;
1707 case LONGLONG: e2 = list3(CONV,rvalue(e2),LL2I); break;
1708 case ULONGLONG: e2 = list3(CONV,rvalue(e2),ULL2I); break;
1709 default:
1710 error(TYERR); e2 = list2(CONST,1);
1711 }
1712 }
1713 type = INT;
1714 return e2;
1715 }
1716
1717 static int
1718 unsigned_value(int e2)
1719 {
1720 if (type>0&&car(type)==BIT_FIELD) e2=rvalue(e2);
1721 else if(type>0&&car(type)==ARRAY) return e2;
1643 if (0); 1722 if (0);
1644 else if(scalar(type)) return e2; 1723 else if(scalar(type)) return e2;
1645 #if FLOAT_CODE 1724 #if FLOAT_CODE
1646 else if (car(e2)==DCONST||car(e2)==FCONST) e2 = list2(CONST,(int)dcadr(e2)); 1725 else if (car(e2)==DCONST||car(e2)==FCONST) e2 = list2(CONST,(int)dcadr(e2));
1647 else if(type==FLOAT) e2 = list3(CONV,rvalue(e2),F2I);
1648 else if(type==DOUBLE) e2 = list3(CONV,rvalue(e2),D2I);
1649 #endif 1726 #endif
1650 #if LONGLONG_CODE 1727 #if LONGLONG_CODE
1651 else if (car(e2)==LCONST) e2 = list2(CONST,(int)lcadr(e2)); 1728 else if (car(e2)==LCONST) e2 = list2(CONST,(unsigned)lcadr(e2));
1652 else if(type==LONGLONG) e2 = list3(CONV,rvalue(e2),LL2I); 1729 #endif
1653 else if(type==ULONGLONG) e2 = list3(CONV,rvalue(e2),ULL2I); 1730 else {
1654 #endif 1731 switch(type) {
1655 else if(car(type)==ARRAY) return e2; 1732 case LONGLONG: e2 = list3(CONV,rvalue(e2),LL2U); break;
1656 else { error(TYERR); e2 = list2(CONST,1); } 1733 case ULONGLONG: e2 = list3(CONV,rvalue(e2),ULL2U); break;
1657 type = INT; 1734 case FLOAT: e2 = list3(CONV,rvalue(e2),F2U); break;
1658 return e2; 1735 case DOUBLE: e2 = list3(CONV,rvalue(e2),D2U); break;
1659 } 1736 default:
1660 1737 error(TYERR);
1661 static int 1738 }
1662 unsigned_value(int e2) 1739 }
1663 {
1664 if (type>0&&car(type)==BIT_FIELD) e2=rvalue(e2);
1665 if (0);
1666 else if(scalar(type)) return e2;
1667 #if FLOAT_CODE
1668 // else if (car(e2)==DCONST||car(e2)==FCONST) e2 = list2(CONST,(unsigned)dcadr(e2));
1669 else if (car(e2)==DCONST||car(e2)==FCONST) e2 = list2(CONST,(int)dcadr(e2));
1670 else if(type==FLOAT) e2 = list3(CONV,rvalue(e2),F2U);
1671 else if(type==DOUBLE) e2 = list3(CONV,rvalue(e2),D2U);
1672 #endif
1673 #if LONGLONG_CODE
1674 else if(type==LONGLONG) e2 = list3(CONV,rvalue(e2),LL2U);
1675 else if(type==ULONGLONG) e2 = list3(CONV,rvalue(e2),ULL2U);
1676 #endif
1677 else if(car(type)==ARRAY) return e2;
1678 else error(TYERR);
1679 type = UNSIGNED; 1740 type = UNSIGNED;
1680 return e2; 1741 return e2;
1681 } 1742 }
1682 1743
1683 /* assign statement */ 1744 /* assign statement */
1699 1760
1700 /* with conversion (will destroy type global variable) */ 1761 /* with conversion (will destroy type global variable) */
1701 1762
1702 extern int 1763 extern int
1703 assign_expr(int e1,int e2,int t) { 1764 assign_expr(int e1,int e2,int t) {
1704 if(t==VOID) 1765 switch(t) {
1705 error(TYERR); 1766 case VOID:
1706 if(t==CHAR||t==UCHAR) { 1767 break;
1768 case CHAR:case UCHAR:
1707 e2=(t==UCHAR)?unsigned_value(e2):int_value(e2); 1769 e2=(t==UCHAR)?unsigned_value(e2):int_value(e2);
1708 return(list3(CASS,e1,e2)); 1770 return(list3(CASS,e1,e2));
1709 } else if(t==SHORT||t==USHORT) { 1771 case SHORT:case USHORT:
1710 e2=(t==USHORT)?unsigned_value(e2):int_value(e2); 1772 e2=(t==USHORT)?unsigned_value(e2):int_value(e2);
1711 return(list3(SASS,e1,e2)); 1773 return(list3(SASS,e1,e2));
1712 #if FLOAT_CODE 1774 #if FLOAT_CODE
1713 } else if(t==DOUBLE) { 1775 case DOUBLE:
1714 e2=double_value(e2); 1776 e2=double_value(e2);
1715 return(list3(DASS,e1,e2)); 1777 return(list3(DASS,e1,e2));
1716 } else if(t==FLOAT) { 1778 case FLOAT:
1717 e2=float_value(e2); 1779 e2=float_value(e2);
1718 return(list3(FASS,e1,e2)); 1780 return(list3(FASS,e1,e2));
1719 #endif 1781 #endif
1720 #if LONGLONG_CODE 1782 #if LONGLONG_CODE
1721 } else if(t==LONGLONG) { 1783 case LONGLONG:
1722 e2=longlong_value(e2); 1784 e2=longlong_value(e2);
1723 return(list3(LASS,e1,e2)); 1785 return(list3(LASS,e1,e2));
1724 } else if(t==ULONGLONG) { 1786 case ULONGLONG:
1725 e2=ulonglong_value(e2); 1787 e2=ulonglong_value(e2);
1726 return(list3(LASS,e1,e2)); 1788 return(list3(LASS,e1,e2));
1727 #endif 1789 #endif
1728 } else if(scalar(t)) { 1790 default:
1729 e2=(t==UNSIGNED)?unsigned_value(e2):int_value(e2); 1791 if(scalar(t)) {
1730 return(list3(ASS,e1,e2)); 1792 e2=(t==UNSIGNED)?unsigned_value(e2):int_value(e2);
1731 } else if (car(t)==BIT_FIELD) { 1793 return(list3(ASS,e1,e2));
1732 e2 = correct_type(e2,cadr(t)); 1794 }
1733 return(list4(BASS,e1,e2,list2(BASS,t))); 1795 switch(car(t)) {
1734 } else if((car(t)==STRUCT||car(t)==UNION)) { 1796 case BIT_FIELD:
1735 if (size(t)!=size(type)) error(TYERR); 1797 e2 = correct_type(e2,cadr(t));
1736 type=t; 1798 return(list4(BASS,e1,e2,list2(BASS,t)));
1737 if(car(e2)==RSTRUCT && car(cadr(e2))==FUNCTION) { 1799 case STRUCT:case UNION:
1738 replace_return_struct(cadr(e2),e1); 1800 if (size(t)!=size(type)) error(TYERR);
1739 return cadr(e2); 1801 type=t;
1740 } else { 1802 if(car(e2)==RSTRUCT && car(cadr(e2))==FUNCTION) {
1741 return (list4(STASS,e1,e2,size(t))); 1803 replace_return_struct(cadr(e2),e1);
1742 } 1804 return cadr(e2);
1743 } else { 1805 } else {
1744 error(TYERR); return list3(ASS,e1,e2); 1806 return (list4(STASS,e1,e2,size(t)));
1745 } 1807 }
1808 }
1809 }
1810 error(TYERR); return list3(ASS,e1,e2);
1746 } 1811 }
1747 1812
1748 extern int 1813 extern int
1749 cond(int t,int e1,int e2,int e3) 1814 cond(int t,int e1,int e2,int e3)
1750 { 1815 {
1782 } 1847 }
1783 1848
1784 extern int 1849 extern int
1785 assop(int e1,int e2,int op,int t,int no_float) 1850 assop(int e1,int e2,int op,int t,int no_float)
1786 { 1851 {
1852 int ass,u = 0;
1787 if(!(integral(type)||type==FLOAT||type==DOUBLE|| 1853 if(!(integral(type)||type==FLOAT||type==DOUBLE||
1788 type==LONGLONG||type==ULONGLONG 1854 type==LONGLONG||type==ULONGLONG
1789 )) error(TYERR); 1855 )) error(TYERR);
1856 switch(t) {
1790 #if FLOAT_CODE 1857 #if FLOAT_CODE
1791 if (t==FLOAT) { 1858 case FLOAT:
1792 if (no_float) error(TYERR); 1859 if (no_float) error(TYERR);
1793 e2=float_value(e2); 1860 e2=float_value(e2);
1794 return(list4(FASSOP,e1,e2,op+FOP)); 1861 return(list4(FASSOP,e1,e2,op+FOP));
1795 } else if (t==DOUBLE) { 1862 case DOUBLE:
1796 if (no_float) error(TYERR); 1863 if (no_float) error(TYERR);
1797 e2=double_value(e2); 1864 e2=double_value(e2);
1798 return(list4(DASSOP,e1,e2,op+DOP)); 1865 return(list4(DASSOP,e1,e2,op+DOP));
1799 }
1800 #endif 1866 #endif
1801 #if LONGLONG_CODE 1867 #if LONGLONG_CODE
1802 if (t==LONGLONG) { 1868 case LONGLONG:
1803 e2=longlong_value(e2); 1869 e2=longlong_value(e2);
1804 return(list4(LASSOP,e1,e2,op+LOP)); 1870 return(list4(LASSOP,e1,e2,op+LOP));
1805 } else if (t==ULONGLONG) { 1871 case ULONGLONG:
1806 e2=ulonglong_value(e2); 1872 e2=ulonglong_value(e2);
1807 return(list4(LASSOP,e1,e2,op+LOP+((op==MUL+AS||op==DIV+AS)?US:0))); 1873 return(list4(LASSOP,e1,e2,op+LOP+((op==MUL+AS||op==DIV+AS)?US:0)));
1808 } 1874 #endif
1809 #endif 1875 case CHAR:
1810 if((t==UNSIGNED||t==UCHAR||t==USHORT||type==UNSIGNED)&& 1876 type= INT; ass = CASSOP; break;
1811 (op==MUL||op==DIV||op==MOD)) 1877 case SHORT:
1812 op=op+US; 1878 type= INT; ass = SASSOP; break;
1813 if((t==UNSIGNED||t==UCHAR||t==USHORT)&&(op==RSHIFT||op==LSHIFT)) 1879 case INT:
1814 op=op+US; 1880 type= INT; ass = ASSOP; break;
1815 if(t==CHAR) { 1881 case UCHAR:
1816 type= INT; 1882 type= UNSIGNED; ass = CUASSOP; u=1; break;
1817 return(list4(CASSOP,e1,e2,op)); 1883 case USHORT:
1818 } 1884 type= UNSIGNED; ass = SUASSOP; u=1; break;
1819 if(t==UCHAR) { 1885 case UNSIGNED:
1820 type= UNSIGNED; 1886 type= UNSIGNED; ass = ASSOP; u=1; break;
1821 return(list4(CUASSOP,e1,e2,op)); 1887 default:
1822 } 1888 if (t>0 && car(t)==BIT_FIELD) {
1823 if(t==SHORT) { 1889 e2 = correct_type(e2,cadr(t));
1824 type= INT; 1890 return(list4(BASSOP,e1,e2,list2(op,t)));
1825 return(list4(SASSOP,e1,e2,op)); 1891 }
1826 } 1892 }
1827 if(t==USHORT) { 1893 if (u) {
1828 type= UNSIGNED; 1894 if (op==RSHIFT||op==LSHIFT) op=op+US;
1829 return(list4(SUASSOP,e1,e2,op)); 1895 else {
1830 } 1896 switch(type) {
1831 if (t>0 && car(t)==BIT_FIELD) { 1897 case UCHAR: case USHORT: case UNSIGNED:
1832 e2 = correct_type(e2,cadr(t)); 1898 if (op==MUL||op==DIV||op==MOD) op=op+US;
1833 return(list4(BASSOP,e1,e2,list2(op,t))); 1899 }
1900 }
1834 } 1901 }
1835 type=t; 1902 type=t;
1836 if(integral(t)) return(list4(ASSOP,e1,e2,op)); 1903 if(integral(t)) return(list4(ass,e1,e2,op));
1837 /* pointer += ... */ 1904 /* pointer += ... */
1838 if((op!=ADD&&op!=SUB)||car(t)!=POINTER) error(TYERR); 1905 if((op!=ADD&&op!=SUB)||car(t)!=POINTER) error(TYERR);
1839 e2=binop(MUL,e2,list2(CONST,size(cadr(t))),INT,UNSIGNED); 1906 e2=binop(MUL,e2,list2(CONST,size(cadr(t))),INT,UNSIGNED);
1840 type=t; 1907 type=t;
1841 1908
1849 { 1916 {
1850 int e2,e3,byte,op,sign,size; 1917 int e2,e3,byte,op,sign,size;
1851 int n,t; 1918 int n,t;
1852 1919
1853 /* e2 op= e3 */ 1920 /* e2 op= e3 */
1854 if (car(e1) == CUASSOP) { 1921 switch(car(e1)) {
1855 byte = 1; sign = 0; size = 1; 1922 case CUASSOP: byte = 1; sign = 0; size = 1; break;
1856 } else if (car(e1) == CASSOP) { 1923 case CASSOP: byte = 1; sign = 1; size = 1; break;
1857 byte = 1; sign = 1; size = 1; 1924 case SUASSOP: byte = size_of_short; sign = 0; size = size_of_short; break;
1858 } else if (car(e1) == SUASSOP) { 1925 case SASSOP: byte = size_of_short; sign = 1; size = size_of_short; break;
1859 byte = size_of_short; sign = 0; size = size_of_short; 1926 default: byte = 0; sign = 1; size = size_of_int;
1860 } else if (car(e1) == SASSOP) {
1861 byte = size_of_short; sign = 1; size = size_of_short;
1862 } else {
1863 byte = 0; sign = 1; size = size_of_int;
1864 } 1927 }
1865 e2 = cadr(e1); 1928 e2 = cadr(e1);
1866 if (car(e2)==INDIRECT) e2=cadr(e2); 1929 if (car(e2)==INDIRECT) e2=cadr(e2);
1867 e3 = caddr(e1); 1930 e3 = caddr(e1);
1868 op = cadddr(e1); 1931 op = cadddr(e1);
2775 2838
2776 extern void 2839 extern void
2777 lcheck(int e) 2840 lcheck(int e)
2778 { 2841 {
2779 int t; 2842 int t;
2780 if(!(scalar(type)||type==DOUBLE||type==FLOAT|| 2843 if(scalar(type)) return;
2781 type==LONGLONG||type==ULONGLONG)|| 2844 switch(type) {
2782 (car(e)!=GVAR&&car(e)!=LVAR&&car(e)!=INDIRECT 2845 case DOUBLE: case FLOAT : case LONGLONG: case ULONGLONG:
2783 && car(e)!=REGISTER 2846 return;
2784 && car(e)!=DREGISTER 2847 default:
2785 && car(e)!=FREGISTER 2848 switch(car(e)) {
2786 && car(e)!=LREGISTER) 2849 case GVAR: case LVAR: case INDIRECT :
2787 ) 2850 case REGISTER : case DREGISTER : case FREGISTER : case LREGISTER:
2788 if ((t=car(type))<0 && t!=STRUCT && t!=UNION) 2851 return;
2789 error(LVERR); 2852 }
2853 }
2854 if ((t=car(type))<0 && t!=STRUCT && t!=UNION)
2855 error(LVERR);
2790 } 2856 }
2791 2857
2792 extern int 2858 extern int
2793 indop(int e) 2859 indop(int e)
2794 { 2860 {
2797 type=cadr(type); 2863 type=cadr(type);
2798 else if(car(type)==CODE || car(type)==FUNCTION) 2864 else if(car(type)==CODE || car(type)==FUNCTION)
2799 type=type; 2865 type=type;
2800 else error(TYERR); 2866 else error(TYERR);
2801 } else 2867 } else
2802 type= CHAR; 2868 type= CHAR; // ?!
2803 if(car(e)==ADDRESS) 2869 if(car(e)==ADDRESS)
2804 return(cadr(e)); 2870 return(cadr(e));
2805 return(list2(INDIRECT,e)); 2871 return(list2(INDIRECT,e));
2806 } 2872 }
2807 2873